def count_challenges(requested_user: User,
candidate_semester: Semester) -> dict:
challenges = OffChallenge.objects.filter(requester__exact=requested_user)
r = (candidate_semester and RequirementHangout.objects.filter(
eventType=EVENT_NAMES.CHALLENGE,
candidateSemesterActive=candidate_semester,
enable=True,
).first())
start_time, end_time = get_semester_bounds(timezone.now())
if r is not None:
challenges = challenges.filter(
request_date__gt=r.hangoutsDateStart or start_time,
request_date__lt=r.hangoutsDateEnd or end_time,
)
confirmed = challenges.filter(
Q(officer_confirmed=True) & Q(csec_confirmed=True)).count()
rejected = challenges.filter(
Q(officer_confirmed=False) | Q(csec_confirmed=False)).count()
pending = challenges.count() - confirmed - rejected
return {
ATTR.NUM_PENDING: pending,
ATTR.NUM_REJECTED: rejected,
ATTR.NUM_CONFIRMED: confirmed,
}
def get_context_data(self):
view_option = self.request.GET.get('option')
semester_start, semester_end = get_semester_bounds(timezone.now())
all_events = Event.objects \
.filter(start_time__gte=semester_start) \
.filter(start_time__lte=semester_end) \
.order_by('start_time')
if view_option == "upcoming":
all_events = all_events.filter(start_time__gte=timezone.now())
rsvpd_event_ids = Rsvp.objects \
.filter(user__exact=self.request.user) \
.values_list('event', flat=True)
rsvpd_events = all_events \
.filter(pk__in=rsvpd_event_ids)
not_rsvpd_events = all_events \
.exclude(pk__in=rsvpd_event_ids)
for event in rsvpd_events:
event.waitlisted = event.on_waitlist(
self.request.user) # Is this bad practice? idk
event_types = EventType.objects.order_by('type')
context = {
'rsvpd_events': rsvpd_events,
'not_rsvpd_events': not_rsvpd_events,
'event_types': event_types,
}
return context
def get_context_data(self):
# Get the start and end time for event filtering
start_time, end_time = get_semester_bounds(timezone.now())
if self.request.GET.get("option") == "upcoming":
start_time = timezone.now()
# Get the current event type
event_types = EventType.objects.order_by("type").all()
event_types = sorted(event_types,
key=lambda e: not (e.type == ATTR.MANDATORY))
event_type = self.request.GET.get("event_type", event_types[0].type)
event_type = EventType.objects.filter(type=event_type).first()
# Get all events
all_events = Event.objects.filter(
start_time__gte=start_time,
start_time__lte=end_time,
access_level__gte=get_access_level(self.request.user),
event_type=event_type,
).order_by("start_time")
rsvpd_data, not_rsvpd_data = [], []
for event in all_events:
if event.rsvp_set.filter(user=self.request.user):
data, url = rsvpd_data, "events:unrsvp"
waitlisted = event.on_waitlist(self.request.user)
else:
data, url = not_rsvpd_data, "events:rsvp"
waitlisted = False
data.append({
"event": event,
"action": reverse(url, args=[event.id]),
"location": format_url(event.location),
"waitlisted": waitlisted,
})
data = [
{
ATTR.CLASS: "right-half",
ATTR.TITLE: "RSVP'd / Waitlist",
ATTR.EVENTS: rsvpd_data,
ATTR.DISPLAY_VALUE: "un-RSVP",
},
{
ATTR.CLASS: "left-half",
ATTR.TITLE: "Not RSVP'd",
ATTR.EVENTS: not_rsvpd_data,
ATTR.DISPLAY_VALUE: "RSVP",
},
]
context = {
"data": data,
"event_types": event_types,
"event_type": event_type,
}
return context
def count_num_bitbytes(
requested_user: User,
candidate_semester: Semester,
) -> int:
r = (candidate_semester and RequirementBitByteActivity.objects.filter(
candidateSemesterActive=candidate_semester, enable=True).first())
start_time, end_time = get_semester_bounds(timezone.now())
return BitByteActivity.objects.filter(
participants__exact=requested_user,
confirmed=True,
request_date__gt=(r and r.bitByteDateStart) or start_time,
request_date__lt=(r and r.bitByteDateEnd) or end_time,
).count()
def get_required_events(candidate_semester: Semester,
required_events_merger: set) -> dict:
required_events = {}
if candidate_semester is None:
return required_events
semester_start, semester_end = get_semester_bounds(timezone.now())
requirement_events = RequriementEvent.objects.filter(
Q(enable=True) | Q(eventType__type__in=required_events_merger),
candidateSemesterActive=candidate_semester.id,
)
for r in requirement_events:
required_events[r.eventType.type] = {
"eventsDateStart": r.eventsDateStart or semester_start,
"eventsDateEnd": r.eventsDateEnd or semester_end,
"title": r.title if r.enableTitle else None,
}
return required_events
def get_events(rsvps, date, required_events, candidateSemester,
requirement_mandatory, confirmed):
event_models = rsvps.filter(confirmed=confirmed)
events = sort_rsvps_into_events(event_models, required_events)
# We want to show all mandatory events, not just the events the candidate has RSVP'd to
# Get all mandatory events i.e. events with event type "Mandatory"
if candidateSemester and requirement_mandatory:
mandatory_events = requirement_mandatory.events.all()
if requirement_mandatory.eventsDateStart and requirement_mandatory.eventsDateEnd:
mandatory_events = itertools.chain(mandatory_events, \
Event.objects.filter(
event_type__type=MANDATORY,
start_time__gt=requirement_mandatory.eventsDateStart,
end_time__lt=requirement_mandatory.eventsDateEnd,
)
)
else:
curr_sem_start, curr_sem_end = get_semester_bounds(date)
mandatory_events = Event.objects.filter(
event_type__type=MANDATORY,
start_time__gt=curr_sem_start,
end_time__lt=curr_sem_end,
)
# Initialize events[MANDATORY] if hasn't
if MANDATORY not in events:
events[MANDATORY] = []
# Can assume Mandatory Events where user RSVPed to is SEPARATE from those that they don't RSVP to
if not confirmed:
# Only add the non-rsvped Mandatory events to the Not Confirmed list
mandatorySet = {}
for mandatory_event in mandatory_events:
# If no rsvps are found, add this mandatory event to the list of unconfirmed events
if rsvps.filter(event__id=mandatory_event.id).count() == 0:
mandatorySet[mandatory_event.id] = mandatory_event
events[MANDATORY].extend(mandatorySet.values())
events[MANDATORY].sort(key=lambda x: x.start_time)
return events
def get_unconfirmed_events(rsvps, date):
unconfirmed_events = sort_rsvps_into_events(rsvps.filter(confirmed=False))
curr_sem_start, curr_sem_end = get_semester_bounds(date)
# We want to show all mandatory events, not just the events the candidate has RSVP'd to
# Get all mandatory events i.e. events with event type "Mandatory"
mandatory_events = Event.objects.filter(
event_type__type=map_event_vars[settings.MANDATORY_EVENT],
start_time__gt=curr_sem_start,
end_time__lt=curr_sem_end,
)
# Initialize unconfirmed_events[settings.MANDATORY_EVENT]
if settings.MANDATORY_EVENT not in unconfirmed_events:
unconfirmed_events[settings.MANDATORY_EVENT] = []
for mandatory_event in mandatory_events:
# If no rsvps are found, add this mandatory event to the list of unconfirmed events
if rsvps.filter(event__id=mandatory_event.id).count() == 0:
unconfirmed_events[settings.MANDATORY_EVENT].append(mandatory_event)
return unconfirmed_events
def get_required_hangouts(candidate_semester: Semester) -> dict:
required_hangout_events = {}
if EventType.objects.filter(type="Hangout").count() == 0:
return required_hangout_events
time_start, time_end = get_semester_bounds(timezone.now())
if candidate_semester is not None:
requirement_hangout = RequirementHangout.objects.filter(
candidateSemesterActive=candidate_semester.id,
eventType=EVENT_NAMES.HANGOUT,
enable=True,
).first()
if requirement_hangout:
time_start = requirement_hangout.hangoutsDateStart or time_start
time_end = requirement_hangout.hangoutsDateEnd or time_end
# TODO: Hardcoded-ish for now, allow for choice of Hangout events
required_hangout_events["Hangout"] = {
"eventsDateStart": time_start,
"eventsDateEnd": time_end,
"title": "Hangout",
}
return required_hangout_events
def get_mandatory_events(candidate_semester: Semester, confirmed_rsvps: bool):
# We want to show all mandatory events, not just the events the candidate has RSVP'd to
r = (candidate_semester and RequirementMandatory.objects.filter(
candidateSemesterActive=candidate_semester.id, enable=True).first())
mandatory_events = Event.objects.none()
start_time, end_time = get_semester_bounds(timezone.now())
if r:
mandatory_events = r.events.all()
if r.eventsDateStart and r.eventsDateEnd:
start_time, end_time = r.eventsDateStart, r.eventsDateEnd
mandatory_events |= Event.objects.filter(
event_type__type=EVENT_NAMES.MANDATORY,
start_time__gt=start_time,
end_time__lt=end_time,
)
mandatory_events = mandatory_events.distinct().order_by("start_time")
confirmed_events = [r.event.id for r in confirmed_rsvps]
confirmed = mandatory_events.filter(id__in=confirmed_events)
unconfirmed = mandatory_events.exclude(id__in=confirmed_events)
return confirmed, unconfirmed
def get_context_data(self):
view_option = self.request.GET.get('option')
semester_start, semester_end = get_semester_bounds(timezone.now())
all_events = Event.objects \
.filter(start_time__gte=semester_start) \
.filter(start_time__lte=semester_end) \
.filter(access_level__gte=get_access_level(self.request.user)) \
.order_by('start_time')
if view_option == "upcoming":
all_events = all_events.filter(start_time__gte=timezone.now())
rsvpd_event_ids = Rsvp.objects \
.filter(user__exact=self.request.user) \
.values_list('event', flat=True)
rsvpd_events = all_events \
.filter(pk__in=rsvpd_event_ids)
not_rsvpd_events = all_events \
.exclude(pk__in=rsvpd_event_ids)
for event in rsvpd_events:
event.waitlisted = event.on_waitlist(self.request.user) # Is this bad practice? idk
event_types = EventType.objects.order_by('type').all()
event_types = sorted(event_types, key=lambda e: not (e.type == ATTR.MANDATORY))
rsvpd_data, not_rsvpd_data = [], []
for event_type in event_types:
typed_rsvpd_events = rsvpd_events.filter(event_type=event_type)
typed_not_rsvpd_events = not_rsvpd_events.filter(event_type=event_type)
rsvpd_padding, not_rsvpd_padding = get_padding(len(typed_not_rsvpd_events), len(typed_rsvpd_events))
rsvpd_data.append({
ATTR.EVENT_TYPE: event_type,
ATTR.EVENTS: [
[event, reverse("events:unrsvp", args=[event.id])]
for event in typed_rsvpd_events
],
ATTR.PADDING: rsvpd_padding,
})
not_rsvpd_data.append({
ATTR.EVENT_TYPE: event_type,
ATTR.EVENTS: [
[event, reverse("events:rsvp", args=[event.id])]
for event in typed_not_rsvpd_events
],
ATTR.PADDING: not_rsvpd_padding,
})
data = [
{
ATTR.CLASS: "right-half",
ATTR.TITLE: "RSVP'd / Waitlist",
ATTR.EVENTS_DATA: rsvpd_data,
ATTR.DISPLAY_VALUE: "un-RSVP",
},
{
ATTR.CLASS: "left-half",
ATTR.TITLE: "Not RSVP'd",
ATTR.EVENTS_DATA: not_rsvpd_data,
ATTR.DISPLAY_VALUE: "RSVP",
},
]
context = {
ATTR.DATA: data,
}
return context
