def save(self, commit=True):
designated_service_cleaned = self.cleaned_data['designated_service']
workers_cleaned = self.cleaned_data['workers']
groups_cleaned = self.cleaned_data['groups']
# add to worke group, designated services should have only one worker group
workergroup = designated_service_cleaned.worker_groups.all().first()
workergroup.workers.add(*list(workers_cleaned))
# add service to workers
for w in workers_cleaned:
w.designated.add(designated_service_cleaned)
for group in groups_cleaned:
group.user_set.add(
*list(Trainee.objects.filter(worker__in=workers_cleaned)))
# populating the designated hours for newly added trainees so that the force page doesn't show.
current_term = Term.current_term()
week_range = range(0, current_term.term_week_of_date(date.today()))
for worker in workers_cleaned:
services = worker.designated.all()
for service in services:
for week in week_range:
service_attendance = ServiceAttendance.objects.get_or_create(
designated_service=service,
worker=worker,
term=current_term,
week=week)[0]
service_attendance.excused = True
service_attendance.save()
def post(self, request, *args, **kwargs):
"""'approve' when an approve button is pressed 'delete' when a delete
button is pressed 'attend_assign' when assgning discipline from
AttendanceAssign"""
if 'approve' in request.POST:
for value in request.POST.getlist('selection'):
Discipline.objects.get(pk=value).approve_all_summary()
messages.success(request, "Checked Discipline(s) Approved!")
if 'delete' in request.POST:
for value in request.POST.getlist('selection'):
Discipline.objects.get(pk=value).delete()
messages.success(request, "Checked Discipline(s) Deleted!")
if 'trainee_pk' in request.POST:
trainee_pk = request.POST.getlist('trainee_pk')
ls_count = request.POST.getlist('ls_count')
period = int(request.POST.get('period'))
for idx, pk in enumerate(trainee_pk):
discipline = Discipline(
infraction='AT',
quantity=ls_count[idx],
due=Period(Term.current_term()).start(period + 1) + timedelta(weeks=1), # Due on the second Monday of the next period
offense='MO',
trainee=Trainee.objects.get(pk=pk))
try:
discipline.save()
except IntegrityError:
logger.error('Abort trasanction error')
transaction.rollback()
messages.success(request, "Discipline Assigned According to Attendance!")
return self.get(request, *args, **kwargs)
def get_context_data(self, **kwargs):
ctx = super(InterimIntentionsCalendarView,
self).get_context_data(**kwargs)
term = Term.current_term()
interim_start = term.end + timedelta(days=1)
if not InterimIntentionsAdmin.objects.get(
term=term
).date_1yr_return or not InterimIntentionsAdmin.objects.get(
term=term).date_2yr_return:
interim_end = interim_start + timedelta(days=1)
ctx['subtitle'] = "Please enter the return dates for next term."
else:
date_1 = InterimIntentionsAdmin.objects.get(
term=term).date_1yr_return
date_2 = InterimIntentionsAdmin.objects.get(
term=term).date_2yr_return
interim_end = date_2.date() if (
date_2 >= date_1) else date_1.date()
ctx['interim_length'] = (interim_end - interim_start).days + 1
ctx['date_list'] = [
interim_start + timedelta(days=x)
for x in range(0, ctx['interim_length'])
]
ctx['trainees'] = Trainee.objects.values('firstname', 'lastname', 'id')
for t in ctx['trainees']:
t['name'] = unicode(t['firstname'] + ' ' + t['lastname'])
t['intention'] = InterimIntentions.objects.filter(
trainee__id=t['id'], admin__term=term).first()
ctx['page_title'] = 'Interim Calendar Report'
return ctx
class RollsJSON(BaseDatatableView):
model = Roll
fields = [
'id', 'trainee', 'event', 'event.id', 'date', 'status', 'finalized',
'submitted_by'
]
columns = fields
order_columns = fields
max_display_length = 200
term = Term.current_term()
def filter_queryset(self, qs):
qs = qs.filter(date__gte=self.term.start, date__lte=self.term.end)
search = self.request.GET.get(u'search[value]', None)
qs_params = Q()
ret = qs.none()
if search:
for exp in search.split():
try:
q = Q(trainee__firstname__icontains=exp) | Q(trainee__lastname__icontains=exp) | Q(id__icontains=exp) | \
Q(event__id__icontains=exp) | Q(event__name__icontains=exp) | Q(date__icontains=exp) | Q(status__icontains=exp)
qs_params = qs_params & q if q else qs_params
except ValueError:
continue
ret = ret | qs.filter(qs_params).distinct()
return ret
else:
return qs
def create(self, validated_data):
if validated_data.get("id"):
#this is pretty naive and inefficient, needs to be optimized later
chart = Chart.objects.get(pk=validated_data.get("id"))
seats = Seat.objects.filter(chart=chart).delete()
chart.width = validated_data.get("width")
chart.height = validated_data.get("height")
chart.name = validated_data.get("name")
chart.save()
seats = validated_data.pop('trainees')
print seats
for y in range(0, validated_data.get('height')):
for x in range(0, validated_data.get('width')):
if seats[y][x] != {} and seats[y][x].get('pk') != '':
trainee = Trainee.objects.get(pk=seats[y][x]['pk'])
s = Seat(trainee=trainee, chart=chart, x=x, y=y)
s.save()
return chart
seats = validated_data.pop('trainees')
print seats
validated_data['term'] = Term.current_term()
new_chart = Chart.objects.create(**validated_data)
for y in range(0, validated_data.get('height')):
for x in range(0, validated_data.get('width')):
if seats[y][x] != {} and seats[y][x].get('pk') != '':
trainee = Trainee.objects.get(pk=seats[y][x]['pk'])
s = Seat(trainee=trainee, chart=new_chart, x=x, y=y)
s.save()
return new_chart
class GroupSlipsJSON(BaseDatatableView):
model = GroupSlip
columns = [
'id', 'trainee', 'submitted', 'trainees', 'description', 'status',
'service_assignment', 'start', 'end'
]
order_columns = [
'id', 'trainee', 'submitted', '', 'description', 'status',
'service_assignment', 'start', 'end'
]
max_display_length = 200
which_url = 'get_admin_url'
term = Term.current_term()
def filter_queryset(self, qs):
qs = qs.filter(start__gte=self.term.start, end__lte=self.term.end)
search = self.request.GET.get(u'search[value]', None)
qs_params = Q()
ret = qs.none()
if search:
for exp in search.split():
try:
q = Q(id__icontains=exp) | Q(
service_assignment__service__name__icontains=exp)
qs_params = qs_params & q if q else qs_params
except ValueError:
continue
ret = ret | qs.filter(qs_params).distinct()
return ret
else:
return qs
def import_csvfile(file_path):
# sanity check
localities, teams, residences = check_csvfile(file_path)
if localities or teams or residences:
return False
log.info("Beginning CSV File Import")
# TODO(import2): Remove this
# count = 0;
with open(file_path, 'r') as f:
reader = csv.DictReader(f)
for row in reader:
# count = count + 1
# if count > 10:
# return
import_row(row)
term = Term.current_term()
schedules = Schedule.objects.filter(term=term)
# TODO(import2) -- this needs to be smarter eventually
for schedule in schedules:
schedule.assign_trainees_to_schedule()
log.info("Import complete")
return True
def get_object(self, queryset=None):
term = Term.current_term()
worker = trainee_from_user(self.request.user).worker
self.designated_assignments = worker.assignments.all().filter(
service__designated=True).exclude(
service__name__icontains="Breakfast")
try:
self.week = self.kwargs['week']
except KeyError:
self.week = term.term_week_of_date(datetime.now().date())
# get service
try:
self.service_id = self.kwargs['service_id']
except KeyError:
self.service_id = self.designated_assignments[0].service.id
self.service = Service.objects.get(id=self.service_id)
# get the existing object or created a new one
service_attendance = ServiceAttendance.objects.get_or_create(
worker=worker,
term=term,
week=self.week,
designated_service=self.service)[0]
return service_attendance
def weighted_service_frequency(self):
# cache results
if not hasattr(self, '_service_freq'):
# dictionary format is {category: {day: week count, day: week count}, category: {day: week count}}
# keeps track of how often a worker got assigned to a service on a specific day
self._services_freq = {}
current_term = Term.current_term()
for a in self.assignments.all():
if a.week_schedule.start >= current_term.start:
day = a.service.weekday
if a.service.category in self._services_freq:
if day in self._services_freq[a.service.category]:
# weeks are added so assignments for more recent weeks will have larger weights
self._services_freq[a.service.category][
day] += a.week_schedule.week
else:
self._services_freq[
a.service.category][day] = a.week_schedule.week
else:
self._services_freq[a.service.category] = {
day: a.week_schedule.week
}
return self._services_freq
class LeaveSlipsJSON(BaseDatatableView):
model = IndividualSlip
fields = ['id', 'trainee', 'rolls', 'status', 'TA', 'type']
columns = fields
order_columns = fields
max_display_length = 200
which_url = 'get_admin_url'
term = Term.current_term()
def filter_queryset(self, qs):
qs = qs.filter(rolls__date__gte=self.term.start,
rolls__date__lte=self.term.end)
search = self.request.GET.get(u'search[value]', None)
qs_params = Q()
ret = qs.none()
if search:
for exp in search.split():
try:
q = Q(trainee__firstname__icontains=exp) | Q(trainee__lastname__icontains=exp) | Q(id__icontains=exp) | \
Q(type__icontains=exp) | Q(rolls__event__name__icontains=exp) | Q(rolls__event__id__icontains=exp) | Q(rolls__id__icontains=exp)
qs_params = qs_params & q if q else qs_params
except ValueError:
continue
ret = ret | qs.filter(qs_params).distinct()
return ret
else:
return qs
def _send_emails(self):
# Only send email during the term
today = date.today()
if Term.current_term().is_date_within_term(today):
send_absentee_report(today.year, today.month, today.day)
print 'Cron job emails sent!'
else:
print 'Absentee report not sent because term not currently in session'
def form_valid(self, form):
term = Term.current_term()
index = len(HCSurveyAdmin.objects.filter(term=term)) + 1
hcsa = form.save(commit=False)
hcsa.term = term
hcsa.index = index
hcsa.save()
return super(HCSurveyAdminCreate, self).form_valid(form)
def filter_list(self, week, trainee):
term = Term.current_term()
# return pre-training recordings
if week == 0:
return filter(lambda f: f.code == 'PT', self.filter_term(term))
# also filters year: if not a class with a Y1/Y2 designation or if the class year matches trainee's year, add file to files list
return filter(lambda f: f.week == week and f.can_trainee_view(trainee),
self.filter_term(term))
def form_valid(self, form):
term = Term.current_term()
index = len(HCSurveyAdmin.objects.filter(term=term)) + 1
hcsa = form.save(commit=False)
hcsa.term = term
hcsa.index = index
hcsa.save()
return HttpResponseRedirect(self.success_url)
def form_valid(self, form):
hc_recommendation = form.save(commit=False)
hc_recommendation.survey_admin = self.admin_model.objects.get_or_create(
term=Term.current_term())[0]
hc_recommendation.hc = self.request.user
hc_recommendation.house = self.request.user.house
hc_recommendation.save()
return super(HCRecommendationCreate, self).form_valid(form)
def mid_term():
""" Returns true if we are still in the current term or if the current term hasn't yet
started yet """
term = Term.current_term()
if term:
return term.currently_in_term()
else:
return False
def badgeprintout(request):
return render(
request, 'badges/print.html', {
'object_list':
Badge.objects.filter(
Q(term_created__exact=Term.current_term())
& Q(deactivated__exact=False))
})
def get_context_data(self, **kwargs):
context = super(HCRecommendationTAView,
self).get_context_data(**kwargs)
hcra = HCRecommendationAdmin.objects.filter(term=Term.current_term())
context['hc_recommendations'] = HCRecommendation.objects.filter(
survey_admin=hcra)
context['page_title'] = "HC Recommendations Report"
return context
def xb_form_valid(self, data): term = Term.current_term() print term xb, created = XBAdmin.objects.get_or_create(term=term) print xb form = XBAdminForm(data, instance=xb) print form form.save()
def get_context_data(self, **kwargs):
context = super(DisciplineListView, self).get_context_data(**kwargs)
try:
context['current_period'] = Period(Term.current_term()).period_of_date(datetime.now().date())
except ValueError:
# ValueError thrown if current date is not in term (interim)
# return last period of previous period
context['current_period'] = Period.last_period()
return context
def get_queryset(self):
try:
week = int(self.request.GET.get('week', ''))
day = int(self.request.GET.get('weekday', ''))
date = Term.current_term().get_date(week, day)
return Event.objects.filter(chart__isnull=False).filter(Q(weekday=day, day__isnull=True) | Q(day=date))
except ValueError as e:
print '%s (%s)' % (e.message, type(e))
return Event.objects.all()
def get_object(self, queryset=None):
ct = Term.current_term()
if is_trainee(self.request.user):
trainee = trainee_from_user(self.request.user)
else:
trainee = Trainee.objects.first()
obj, created = SemiAnnual.objects.get_or_create(trainee=trainee,
term=ct)
return obj
def __init__(self, *args, **kwargs): super(BaseScheduleForm, self).__init__(*args, **kwargs) self.fields['trainees'].widget.attrs['class'] = 'select-fk' self.fields['parent_schedule'].widget.attrs['class'] = 'select-fk' self.fields['term'].widget.attrs['class'] = 'select-fk' self.fields['term'].initial = Term.current_term() self.fields['season'].initial = 'All' self.fields['trainee_select'].initial = 'MA' self.fields['query_filter'].widget.attrs['class'] = 'select-fk'
def get_context_data(self, **kwargs):
context = super(TAAudioHome, self).get_context_data(**kwargs)
audio_requests = AudioRequest.objects.none()
reqs = AudioRequest.objects.filter_term(
Term.current_term()).order_by('date_requested')
for status in ['P', 'F', 'A', 'D']:
audio_requests = chain(audio_requests, reqs.filter(status=status))
context['audio_requests'] = audio_requests
return context
def get_context_data(self, **kwargs):
ctx = super(HCSurveyAdminUpdate, self).get_context_data(**kwargs)
ctx['hc_admins'] = HCSurveyAdmin.objects.filter(
term=Term.current_term()).order_by('-index')
ctx['update'] = True
ctx['hcsa_form'] = ctx['form']
ctx['page_title'] = 'Update HC Survey'
ctx['button_label1'] = 'Update'
return ctx
def assign_classnotes(week=None):
term = Term.current_term()
start = term.start
end = term.end
if week is not None:
end = term.enddate_of_week(week)
for trainee in Trainee.objects.all().iterator():
update_classnotes_list(trainee)
assign_individual_classnotes(trainee, start, end)
def get_or_create_week_schedule(scheduler, week_number):
ct = Term.current_term()
# service week starts on Tuesdays rather than Mondays
start = ct.get_date(int(week_number), 1)
if WeekSchedule.objects.filter(start=start).exists():
week_schedule = WeekSchedule.objects.get(start=start)
else:
week_schedule = WeekSchedule(start=start, scheduler=scheduler)
week_schedule.save()
return week_schedule
def hc_surveys(user):
ret = False
if is_trainee(user):
tr = trainee_from_user(user)
if tr.has_group(['HC']) and tr.type != 'C':
term = Term.current_term()
admins = HCSurveyAdmin.objects.filter(open_survey=True).filter(term=term)
if admins.exists():
ret = True
return ret
def attendance_announcements(trainee):
today = datetime.date.today()
term = Term.current_term()
week = term.term_week_of_date(today)
if trainee.self_attendance:
weeks = map(str, filter(lambda w: not term.is_attendance_finalized(w, trainee), range(week)))
else:
weeks = []
message = 'You have not finalized your attendance for week {week}. Fellowship with a TA to finalize it.'
return [(messages.WARNING, message.format(week=', '.join(weeks)))] if weeks else []
def weighted_service_frequency(self):
# cache results
if not hasattr(self, '_service_freq'):
self._services_freq = Counter()
current_term = Term.current_term()
for a in self.assignments.all():
if a.week_schedule.start >= current_term.start:
self._services_freq[
a.service.category] += a.week_schedule.week / 10.0
return self._services_freq
def handle(self, *args, **options):
verbose = int(options['verbosity']) > 1
if options['all']:
for term in Term.objects.all():
self.fetch_courses(term, verbose=verbose)
return
term = Term.current_term()
if options['year'] is not None and options['semester'] is not None:
term = Term.objects.get(year=options['year'],
semester=options['semester'])
self.fetch_courses(term, verbose=verbose)
