def filter_rushees(request):
""" filters the current rushees page and saves filter choices
in session
"""
if request.method == 'POST':
form = FilterForm(request.POST)
site_settings = getSettings()
ROUND_CHOICES = [(0, settings.NO_FILTER_PLACEHOLDER)]
num_rounds = site_settings.num_rush_rounds
for i in range(1, num_rounds+1):
ROUND_CHOICES.append((i, i))
form.fields['round'].choices = ROUND_CHOICES
if form.is_valid():
filters = {}
for field in form.fields:
if form.cleaned_data[field] != '' and form.cleaned_data[field] != '0' and form.cleaned_data[field] != False:
filters[field] = form.cleaned_data[field]
request.session['rushee_filter'] = filters
# if session variable is empty, just delete it
if not bool(request.session['rushee_filter']):
del request.session['rushee_filter']
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
else:
return HttpResponse(form.errors)
else:
raise Http404
def signin(request, event_id=-1):
""" page for rushees signing into events when they are already registered
event_id -- if passed in URL represents the event being signed into
if not passed, defaults to -1 meaning first event
"""
template = loader.get_template('rush/signin.html')
form = RusheeForm()
objects = Rushee.objects.filter(cut=False).order_by('name')
all_events = RushEvent.objects.all().order_by('date')
settings = getSettings()
round_range = range(1, settings.num_rush_rounds + 1)
if int(event_id) != -1:
this_event = RushEvent.objects.get(id=int(event_id))
objects = (Rushee.objects.filter(round=this_event.round, cut=False)
.exclude(rushevent=this_event).order_by('name'))
else:
this_event = all_events.first()
context = {
"rush_page": "active",
"form": form,
"event": this_event,
"objects": objects,
"events": all_events,
'round_range': round_range,
'settings': settings
}
return HttpResponse(template.render(context, request))
def index(request):
""" landing page for recruitment module
"""
template = loader.get_template('rush/index.html')
filter_form, rushees = get_filtered_rushees(request)
all_events = RushEvent.objects.all().order_by('date')
settings = getSettings()
round_range = range(1, settings.num_rush_rounds + 1)
round_groups = []
for i in round_range:
round_group = all_events.filter(round=i)
round_groups.append(round_group)
context = {
"rush_page": "active",
"rushees": rushees,
"filter_form": filter_form,
"settings": settings,
"round_range": round_range,
"events": all_events,
"round_groups": round_groups,
"round_iterator": range(len(round_groups)),
}
return HttpResponse(template.render(context, request))
def get_filtered_rushees(request):
rushees = Rushee.objects.filter(cut=False).order_by('name')
site_settings = getSettings()
ROUND_CHOICES = [(0, settings.NO_FILTER_PLACEHOLDER)]
num_rounds = site_settings.num_rush_rounds
for i in range(1, num_rounds+1):
ROUND_CHOICES.append((i, i))
try:
if request.session['rushee_filter']:
if 'cut' in request.session['rushee_filter']:
filter_form = FilterForm(initial=request.session['rushee_filter'])
rushees = Rushee.objects.all().order_by('name')
for filter in request.session['rushee_filter']:
if filter != 'cut':
variable_column = filter
search_type = 'icontains'
filter_string = variable_column + '__' + search_type
rushees = rushees.filter(**{ filter_string: request.session['rushee_filter'][filter]})
filter_form = FilterForm(initial=request.session['rushee_filter'])
filter_form.fields['round'].choices = ROUND_CHOICES
except KeyError:
filter_form = FilterForm()
filter_form.fields['round'].choices = ROUND_CHOICES
return filter_form, rushees
def index(request):
template = loader.get_template('cal/index.html')
d = datetime.today()
curr_month = d.month
curr_year = d.year
month = int(request.GET.get('month', d.month))
year = int(request.GET.get('year', d.year))
if month == 13:
month = 1
year = year +1
if month == 0:
month = 12
year = year -1
cal = Calendar(request, year, month)
cal.setfirstweekday(6) # sets sunday to be the first day of the week to show on the calendar
context = {
'calendar': cal.formatmonth(withyear=True),
'cal_page': 'active',
'settings': getSettings(),
'year': year,
'curr_month': curr_month,
'curr_year': curr_year,
'prev_month': month -1,
'next_month': month +1,
'event_form': ChapterEventForm(),
'chapter_events': ChapterEvent.objects.filter(date__month=month),
}
return HttpResponse(template.render(context, request))
def toggle_rush_signin(request):
""" activates rush signin """
settings = getSettings()
if settings.rush_signin_active:
settings.rush_signin_active = False
else:
settings.rush_signin_active = True
settings.save()
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def current_rushees(request):
""" page containing list of rushees who haven't been cut """
template = loader.get_template('rush/current-rushees.html')
filter_form, rushees = get_filtered_rushees(request)
settings = getSettings()
context = {
"rush_page": "active",
"rushees": rushees,
"filter_form": filter_form,
"settings": settings,
}
return HttpResponse(template.render(context, request))
def event(request, event_id):
""" page showing single rush event details
event_id -- primary key of event
"""
this_event = RushEvent.objects.get(id=event_id)
context = {
'event': this_event,
'settings': getSettings(),
'rush_page': 'active',
}
template = loader.get_template('rush/event.html')
return HttpResponse(template.render(context, request))
def register(request, event_id):
""" adds a rushee to the database when they first sign in
event_id -- primary key of event that rushee is registering in
"""
form = RusheeForm(request.POST)
if form.is_valid():
obj = Rushee()
obj.name = form.cleaned_data['name']
obj.email = form.cleaned_data['email']
obj.year = form.cleaned_data['year']
obj.major = form.cleaned_data['major']
obj.hometown = form.cleaned_data['hometown']
obj.address = form.cleaned_data['address']
obj.phone_number = form.cleaned_data['phone_number']
obj.in_person = form.cleaned_data['in_person']
obj.friends_rushing = form.cleaned_data['friends_rushing']
# NOTE: Please don't mess with this, I don't know how I made it work
# Handles saving the image as a file in media/profile_images
# and then storing them as a model field for Rushees
data_url_pattern = re.compile('data:image/png;base64,(.*)$')
image_data = request.POST.get('profile_picture_data')
# try/catch: catches error thrown if picture data not inputted
try:
image_data = data_url_pattern.match(image_data).group(1)
image_data = bytes(image_data, 'UTF-8')
image_data = base64.b64decode(image_data)
img_io = io.BytesIO(image_data)
# immortalize this line for all time as the line that made our first
# rush session take 7 hours instead of 4
# obj.profile_picture_data = image_data
obj.save()
obj.profile_picture.save(str(obj.id) + '.png', File(img_io))
obj.save()
except (AttributeError, TypeError) as e:
obj.save()
this_event = RushEvent.objects.get(id=event_id)
this_event.attendance.add(obj)
this_event.save()
template = loader.get_template('rush/register.html')
context = {
"name": obj.name,
"event_id": event_id,
'settings': getSettings(),
'rush_page': 'active'
}
return HttpResponse(template.render(context, request))
else:
return HttpResponse(form.errors.as_data())
def results(request, rushee_id):
""" shows results of voting on a rushee
rushee_id -- primary key of rushee whose results are being viewed
"""
this_rushee = Rushee.objects.get(id=rushee_id)
this_rushee.voting_open = False
this_rushee.save()
template = loader.get_template('rush/results.html')
context = {
"rushee": this_rushee,
'settings': getSettings()
}
return HttpResponse(template.render(context, request))
def votepage(request, rushee_id):
""" opens voting, displays a timer to show that voting is open, then redirects to results
rushee_id -- primary key of rushee being voted on
"""
# reset vote list
this_rushee = Rushee.objects.get(id=rushee_id)
this_rushee.voting_open = True
this_rushee.save()
# add additional data here if needed
template = loader.get_template('rush/votepage.html')
context = {
"rushee": this_rushee,
'settings': getSettings()
}
return HttpResponse(template.render(context, request))
def attendance(request, rushee_id, event_id):
""" update database with attendance when a rushee signs into an event
rushee_id -- primary key of rushee
event_id -- primary key of event rushee is attending
"""
template = loader.get_template('rush/register.html')
obj = Rushee.objects.get(id=rushee_id)
this_event = RushEvent.objects.get(id=event_id)
this_event.attendance.add(obj)
this_event.save()
name = obj.name.split()[0]
context = {
"name": name,
"event_id": event_id,
'settings': getSettings(),
'rush_page': 'active'
}
return HttpResponse(template.render(context, request))
def setUp(self):
self.client = TenantClient(self.tenant)
self.user = User.objects.create(username="******")
self.client.force_login(self.user)
settings = getSettings()
settings.rush_signin_active = True
settings.save()
self.rushee = Rushee.objects.create(name='test_rushee')
self.event1 = RushEvent.objects.create(name='first_event',
date='2001-01-01',
time='00:00:00',
round=1,
new_rushees_allowed=True)
self.event2 = RushEvent.objects.create(name='second_event',
date='2001-01-02',
time='00:00:00',
round=1,
new_rushees_allowed=False)
def events(request):
""" page showing all Rush Events """
template = loader.get_template('rush/events.html')
all_events = RushEvent.objects.all().order_by('date')
settings = getSettings()
round_range = range(1, settings.num_rush_rounds + 1)
round_groups = []
for i in round_range:
round_group = all_events.filter(round=i)
round_groups.append(round_group)
context = {
'settings': settings,
'round_range': round_range,
'events': all_events,
'round_groups': round_groups,
'round_iterator': range(len(round_groups)),
'rush_page': "active",
}
return HttpResponse(template.render(context, request))
def date(request, year, month, day):
template = loader.get_template('cal/date.html')
this_date = datetime(year, month, day)
social_events = SocialEvent.objects.filter(date=this_date)
rush_events = RushEvent.objects.filter(date=this_date)
chapter_events = ChapterEvent.objects.filter(date=this_date)
public_social_events = []
public_chapter_events = []
org_community = request.tenant.community
for tenant in Client.objects.filter(community=org_community).exclude(name=request.tenant.name).exclude(name='public').all():
with tenant_context(tenant):
for event in SocialEvent.objects.filter(is_public=True, date=this_date):
public_social_events.append((event, tenant.name))
for event in ChapterEvent.objects.filter(is_public=True, date=this_date):
public_chapter_events.append((event, tenant.name))
all_events = sorted(
chain(social_events, rush_events, chapter_events),
key=lambda instance: instance.time
)
community_events = sorted(
chain(public_social_events, public_chapter_events),
key=lambda instance: instance[0].time
)
context = {
'settings': getSettings(),
'cal_page': 'active',
'today': datetime.today(),
'date': this_date.strftime('%B %d, %Y').lstrip("0"),
'social_events': social_events,
'rush_events': rush_events,
'chapter_events': chapter_events,
'all_events': all_events,
'community_events': community_events,
'next_date': this_date + timedelta(days=1),
'prev_date': this_date - timedelta(days=1)
}
return HttpResponse(template.render(context, request))
def rushee(request, num):
""" rushee profile page
num -- primary key of the rushee being viewed
"""
template = loader.get_template('rush/rushee.html')
obj = Rushee.objects.get(id=num)
all_events = RushEvent.objects.all().order_by('date')
comments = Comment.objects.filter(rushee=obj)
form = CommentForm()
current_round = obj.round
# for navigation buttons on rushee page
next_url = ""
prev_url = ""
# check for filter in session variables
try:
# if show cut rushees filter is true, need to use list of all rushees
if 'cut' in request.session['rushee_filter']:
all_rushees = Rushee.objects.all()
# otherwise, use list of only non-cut rushees
else:
all_rushees = Rushee.objects.filter(cut=False)
# by default, next rushee should be next alphabetically in these lists
next_rushee = all_rushees.filter(name__gt=obj.name).order_by('name')[0].id
# loop through filters to further filter all_rushees
for filter in request.session['rushee_filter']:
if filter != 'cut':
variable_column = filter
search_type = 'icontains'
filter_string = variable_column + '__' + search_type
next_rushee = (all_rushees.filter(**{ filter_string: request.session['rushee_filter'][filter]})
.filter(name__gt=obj.name).order_by('name')[0].id)
next_url = '/rush/rushee' + str(next_rushee)
# filter found but this is last rushee alphabetically that filter applies to (rushees[0] DNE)
except IndexError:
next_url = ""
# filter is not set in session, use default behavior
except KeyError:
# get next rushee alphabetically
try:
next_rushee = Rushee.objects.filter(name__gt=obj.name, cut=False).order_by('name')[0].id
next_url = '/rush/rushee' + str(next_rushee)
# this is last rushee alphabetically (rushees[0] DNE)
except IndexError:
next_url = ""
# check for filter in session variables
try:
# if show cut rushees filter is set, need to use all rushees
if 'cut' in request.session['rushee_filter']:
all_rushees = Rushee.objects.all()
# otherwise, use only non-cut rushees
else:
all_rushees = Rushee.objects.filter(cut=False)
# default behavior, if no other filters just get next alphabetically
prev_rushee = all_rushees.filter(name__lt=obj.name).order_by('-name')[0].id
# loop through filters to futher filter list
for filter in request.session['rushee_filter']:
if filter != 'cut':
variable_column = filter
search_type = 'icontains'
filter_string = variable_column + '__' + search_type
prev_rushee = (all_rushees.filter(**{ filter_string: request.session['rushee_filter'][filter]})
.filter(name__lt=obj.name).order_by('-name')[0].id)
prev_url = '/rush/rushee' + str(prev_rushee)
# filter found but this is first rushee alphabetically that filter applies to (rushees[0] DNE)
except IndexError:
prev_url = ""
# filter is not set in session, use default behavior
except KeyError:
# get previous rushee alphabetically
try:
prev_rushee = Rushee.objects.filter(name__lt=obj.name, cut=False).order_by('-name')[0].id
prev_url = '/rush/rushee' + str(prev_rushee)
# this is first rushee alphabetically (rushee[0] DNE)
except IndexError:
prev_url = ""
context = {
"rushee": obj,
"comments": comments,
"form": form,
"events": all_events,
'settings': getSettings(),
'next_url': next_url,
'prev_url': prev_url,
'rush_page': 'active'
}
return HttpResponse(template.render(context, request))
