Coverage for app/logic/participants.py: 87%

1from peewee import fn, JOIN 

2from datetime import date 

3from app.models.user import User 

4from app.models.event import Event 

5from app.models.term import Term 

6from app.models.eventRsvp import EventRsvp 

7from app.models.program import Program 

8from app.models.programEvent import ProgramEvent 

9from app.models.eventParticipant import EventParticipant 

10from app.logic.users import isEligibleForProgram 

11from app.logic.volunteers import getEventLengthInHours 

12 

13def trainedParticipants(programID, currentTerm): 

14 """ 

15 This function tracks the users who have attended every Prerequisite 

16 event and adds them to a list that will not flag them when tracking hours. 

17 """ 

18 

19 academicYear = currentTerm.academicYear 

20 

21 # Reset program eligibility each term for all other trainings 

22 

23 otherTrainingEvents = (Event.select(Event.id) 

24 .join(ProgramEvent).switch() 

25 .join(Term) 

26 .where( 

27 ProgramEvent.program == programID, 

28 (Event.isTraining | Event.isAllVolunteerTraining), 

29 Event.term.academicYear == academicYear) 

30 ) 

31 

32 allTrainingEvents = set(otherTrainingEvents) 

33 eventTrainingDataList = [participant.user for participant in ( 

34 EventParticipant.select().where(EventParticipant.event.in_(allTrainingEvents)) 

35 )] 

36 attendedTraining = list(dict.fromkeys(filter(lambda user: eventTrainingDataList.count(user) == len(allTrainingEvents), eventTrainingDataList))) 

37 return attendedTraining 

38 

39def sendUserData(bnumber, eventId, programid): 

40 """Accepts scan input and signs in the user. If user exists or is already 

41 signed in will return user and login status""" 

42 try: 

43 signedInUser = User.get(User.bnumber == bnumber) 

44 except Exception as e: 

45 print(e) 

46 return None, "does not exist" 

47 event = Event.get_by_id(eventId) 

48 if not isEligibleForProgram(programid, signedInUser): 

49 userStatus = "banned" 

50 elif ((EventParticipant.select(EventParticipant.user) 

51 .where(EventParticipant.user == signedInUser, EventParticipant.event==eventId)) 

52 .exists()): 

53 userStatus = "already in" 

54 else: 

55 userStatus = "success" 

56 totalHours = getEventLengthInHours(event.timeStart, event.timeEnd, event.startDate) 

57 EventParticipant.create (user=signedInUser, event=eventId, hoursEarned=totalHours) 

58 return signedInUser, userStatus 

59 

60def checkUserRsvp(user, event): 

61 return EventRsvp.select().where(EventRsvp.user==user, EventRsvp.event == event).exists() 

62 

63def checkUserVolunteer(user, event): 

64 return EventParticipant.select().where(EventParticipant.user == user, EventParticipant.event == event).exists() 

65 

66def addPersonToEvent(user, event): 

67 """ 

68 Add a user to an event. 

69 If the event is in the past, add the user as a volunteer (EventParticipant) including hours worked. 

70 If the event is in the future, rsvp for the user (EventRsvp) 

71 

72 Returns True if the operation was successful, false otherwise 

73 """ 

74 try: 

75 volunteerExists = checkUserVolunteer(user, event) 

76 rsvpExists = checkUserRsvp(user, event) 

77 if event.isPast: 

78 if not volunteerExists: 

79 eventHours = getEventLengthInHours(event.timeStart, event.timeEnd, event.startDate) 

80 EventParticipant.create(user = user, event = event, hoursEarned = eventHours) 

81 else: 

82 if not rsvpExists: 

83 EventRsvp.create(user = user, event = event) 

84 if volunteerExists or rsvpExists: 

85 return "already in" 

86 except Exception as e: 

87 print(e) 

88 return False 

89 

90 return True 

91 

92def unattendedRequiredEvents(program, user): 

93 

94 # Check for events that are prerequisite for program 

95 requiredEvents = (Event.select(Event) 

96 .join(ProgramEvent) 

97 .where(Event.isTraining == True, ProgramEvent.program == program)) 

98 

99 if requiredEvents: 

100 attendedRequiredEventsList = [] 

101 for event in requiredEvents: 

102 attendedRequirement = (EventParticipant.select().where(EventParticipant.user == user, EventParticipant.event == event)) 

103 if not attendedRequirement: 

104 attendedRequiredEventsList.append(event.name) 

105 if attendedRequiredEventsList is not None: 

106 return attendedRequiredEventsList 

107 else: 

108 return [] 

109 

110 

111def getEventParticipants(event): 

112 eventParticipants = (EventParticipant.select(EventParticipant, User) 

113 .join(User) 

114 .where(EventParticipant.event == event)) 

115 

116 return {p.user: p.hoursEarned for p in eventParticipants} 

117 

118def getUserParticipatedTrainingEvents(program, user, currentTerm): 

119 """ 

120 This function returns a dictionary of all trainings for a program and 

121 whether the current user participated in them. 

122 

123 :returns: trainings for program and if the user participated 

124 """ 

125 academicYear = currentTerm.academicYear 

126 

127 programTrainings = (Event.select(Event, ProgramEvent, Term, EventParticipant) 

128 .join(EventParticipant, JOIN.LEFT_OUTER).switch() 

129 .join(ProgramEvent).switch() 

130 .join(Term) 

131 .where((Event.isTraining | Event.isAllVolunteerTraining), 

132 ProgramEvent.program == program, 

133 Event.term.academicYear == academicYear, 

134 EventParticipant.user.is_null(True) | (EventParticipant.user == user))) 

135 

136 UserParticipatedTrainingEvents = {} 

137 for training in programTrainings.objects(): 

138 if training.startDate > date.today(): 

139 didParticipate = [None, training.startDate.strftime("%m/%d/%Y")] 

140 elif training.user: 

141 didParticipate = True 

142 else: 

143 didParticipate = False 

144 UserParticipatedTrainingEvents[training.name] = didParticipate 

145 return UserParticipatedTrainingEvents