def lesson_analysis(self, start, end):
from schools.courses.models import Lesson
from schools.companies.models import Subcount
from collections import defaultdict
from schools.lectors.models import Lector #@UnresolvedImport
import schools
lessons = Lesson.objects.filter(real_end__range=(start, schools.fix_date_boundaries(end)))
lector_lessons = defaultdict(dict)
for lesson in lessons:
if lesson.course not in lector_lessons[lesson.real_lector]:
lector_lessons[lesson.real_lector][lesson.course] = Subcount(lesson.course)
subcount = lector_lessons[lesson.real_lector][lesson.course]
subcount.length += lesson.real_minutes_length
subcount.price += lesson.real_lector_price
lectors = Lector.objects.all()
for lector in lectors:
lector.analysis_courses = lector_lessons[lector].values()
lector.analysis_length = sum([subcount.length
for subcount in lector_lessons[lector].values() ])
lector.analysis_price = sum([subcount.price
for subcount in lector_lessons[lector].values() ])
return lectors
def invoice(self, start, end, companies=None):
lesson_attendees = defaultdict(list)
_attendees = LessonAttendee.objects.filter(lesson__real_end__range=(start, fix_date_boundaries(end)))
if companies is not None: _attendees = _attendees.filter(course_member__student__company__in=companies)
for attendee in _attendees.select_related('lesson'):
lesson_attendees[attendee.course_member].append(attendee)
course_members = defaultdict(list)
_members = CourseMember.objects.filter(lessonattendee__lesson__real_end__range=(start, fix_date_boundaries(end)))
if companies is not None: _members = _members.filter(student__company__in=companies)
for course_member in _members.distinct():
course_member.invoice_attendees = lesson_attendees[course_member]
course_member.invoice_price = sum([a.course_member_price for a in lesson_attendees[course_member]])
course_member.invoice_length = sum([a.lesson.real_minutes_length for a in lesson_attendees[course_member]])
course_member.invoice_count = len(lesson_attendees[course_member])
course_members[course_member.student].append(course_member)
return course_members
def classroom_lessons(request, object_id):
'''
Filter classrooms and export them in JSON format.
'''
classroom = get_object_or_404(Classroom, pk=object_id)
form = ClassroomLessonsForm(request.GET)
lessons = classroom.plannedlessons_set.all()
if form.is_valid():
if form.cleaned_data['start']:
lessons = lessons.filter(end__gte=form.cleaned_data['start'])
if form.cleaned_data['end']:
lessons = lessons.filter(start__lt=fix_date_boundaries(form.cleaned_data['end']))
lessons = [{'id':a.pk,
'start':format(a.start, 'Y-m-d\TH:i:s.000O'),
'end':format(a.end, 'Y-m-d\TH:i:s.000O'),
'title':unicode(a.course)} for a in lessons]
text = simplejson.dumps(lessons)
return HttpResponse(text, mimetype='application/json')
def _search_lessons(queryset, form, date_required=False):
if 'course' in form.cleaned_data and form.cleaned_data['course']:
queryset = queryset.filter(course=form.cleaned_data['course'])
if form.cleaned_data['start']:
queryset = queryset.filter(end__gte=form.cleaned_data['start'])
elif date_required:
queryset = queryset.none()
if form.cleaned_data['end']:
queryset = queryset.filter(start__lt=fix_date_boundaries(form.cleaned_data['end']))
elif date_required:
queryset = queryset.none()
if form.cleaned_data['realized'] is not None:
queryset = queryset.filter(realized=form.cleaned_data['realized'])
if form.cleaned_data['building']:
queryset = queryset.filter(classroom__building=form.cleaned_data['building'])
if form.cleaned_data['lector']:
queryset = queryset.filter(course__lector=form.cleaned_data['lector'])
if form.cleaned_data['classroom']:
queryset = queryset.filter(classroom=form.cleaned_data['classroom'])
return queryset
def course_plan(self, start, end):
class CoursePlan():
def __init__(self, lessonhours, price):
self.lesson_hours = lessonhours
self.price = price
lessons = Lesson.objects.filter(end__range=(start, fix_date_boundaries(end)))
# kurz, plánované lekciohodiny, plánované kurzohodiny, plánovaná cena
lesson_dict = defaultdict(list)
for lesson in lessons:
lesson_dict[lesson.course].append(lesson)
for course, lessons_list in lesson_dict.items():
lessonhours = sum([lesson.minutes_length for lesson in lessons_list])
course_members = course.coursemember_set.filter(Q(end__isnull=True) | Q(end__gte=start), start__lt=fix_date_boundaries(end))
price = sum([sum(course_member_price(lesson, course_members, lesson.start, lesson.end).values()) for lesson in lessons_list])
course.course_plan = CoursePlan(lessonhours, price)
return lesson_dict.keys()
def invoice(self, start, end, companies=None):
from schools.courses.models import CourseMember
course_members = CourseMember.objects.invoice(start, end, companies)
students_list = Student.objects.filter(coursemember__lessonattendee__lesson__real_end__range=(start, fix_date_boundaries(end))).distinct()
if companies is not None: students_list = students_list.filter(company__in=companies)
students = defaultdict(list)
for student in students_list:
student.invoice_course_members = course_members[student]
student.invoice_price = sum([a.invoice_price for a in course_members[student]])
student.invoice_length = sum([a.invoice_length for a in course_members[student]])
student.invoice_count = sum([a.invoice_count for a in course_members[student]])
students[student.company].append(student)
return students
def course_member_price(lesson, course_members, start, end):
expense_groups = defaultdict(list)
for course_member in course_members:
expense_groups[course_member.expense_group].append(course_member)
course_members_dict = {}
for expense_group, course_members in expense_groups.items():
expense_group_prices = expense_group.expensegroupprice_set.filter(Q(end__isnull=True)|Q(end__gte=start), start__lt=fix_date_boundaries(end))
hour_rate = list(expense_group_prices)[-1]
price = calculate_price(hour_rate.price, end - start)
for course_member in course_members:
course_members_dict[course_member] = price / len(course_members)
return course_members_dict
def create_lesson_attendees(sender, *args, **kwargs):
lesson = kwargs['lesson']
course_members = lesson.course.coursemember_set.filter(Q(end__isnull=True) | Q(end__gte=lesson.start), start__lt=fix_date_boundaries(lesson.end))
lesson_members = [a.course_member for a in lesson.lessonattendee_set.all()]
course_members = filter(lambda member:member not in lesson_members, course_members)
lesson.lessonattendee_set = [LessonAttendee(course_member=a) for a in course_members]
def planned_lesson_attendees(lesson):
course_members = lesson.course.coursemember_set.filter(Q(end__isnull=True) | Q(end__gte=lesson.start), start__lt=fix_date_boundaries(lesson.end))
return course_members
def building_price_for(self, start_date, end_date):
price = Decimal(0)
for start, end in iter_months(start_date, end_date):
expenses = BuildingMonthExpense.objects.filter(Q(end__isnull=True)|Q(end__gte=start), start__lt=fix_date_boundaries(end))
if expenses:
expense = expenses[0]
days = Decimal((end-start).days + 1)
price += (days/Decimal(monthrange(start.year, start.month)[1])) * expense.price
return price
