def all_news(request): """ Latest news, result of query search or given page with focused news """ if BaseUser.is_student(request.user): student = request.user.student student.last_news_view = datetime.datetime.now() student.save() elif BaseUser.is_employee(request.user): employee = request.user.employee employee.last_news_view = datetime.datetime.now() employee.save() query = request.GET.get('q') if query: query = query.strip() items = News.objects.get_published().filter( Q(title__icontains=query) | Q(body__icontains=query)) else: items = News.objects.exclude(category='-') paginator = Paginator(items, settings.NEWS_PER_PAGE) page = request.GET.get('page') try: news = paginator.page(page) except (PageNotAnInteger, EmptyPage): news = paginator.page(1) data = {'items': news, 'page_range': paginator.page_range, 'query': query} return render(request, 'news/list_all.html', data)
def filter_only_mine(self: QuerySet, user: User): if BaseUser.is_student(user): return self.filter(students__in=[user.student]) elif BaseUser.is_employee(user): return self.filter(Q(advisor=user.employee) | Q(supporting_advisor=user.employee)) # this is an error situation, one of the conditions above should have caught it return self
def roles(request): """Merge user's group membership info into template context.""" return { 'is_employee': BaseUser.is_employee(request.user), 'is_external_contractor': BaseUser.is_external_contractor(request.user), 'is_student': BaseUser.is_student(request.user), }
def filter_by_user(self: QuerySet, user: User): """Filter the queryset based on special logic depending on the type of the user """ # Students should not see theses that are not "ready" yet if BaseUser.is_student(user): return self.exclude(status__in=NOT_READY_STATUSES) return self
def _serialize_user_type(user: User): if is_theses_admin(user): return ThesisUserType.ADMIN elif is_theses_regular_employee(user): return ThesisUserType.REGULAR_EMPLOYEE elif BaseUser.is_student(user): return ThesisUserType.STUDENT # We're generally not expecting this to happen return ThesisUserType.NONE
def course_view_data(request, slug) -> Tuple[Optional[CourseInstance], Optional[Dict]]: """Retrieves course and relevant data for the request. If course does not exist it returns two None objects. """ course: CourseInstance = None try: course = CourseInstance.objects.filter(slug=slug).select_related( 'semester', 'course_type').prefetch_related('tags', 'effects').get() except CourseInstance.DoesNotExist: return None, None student: Student = None if request.user.is_authenticated and BaseUser.is_student(request.user): student = request.user.student groups = course.groups.exclude(extra='hidden').select_related( 'teacher', 'teacher__user', ).prefetch_related('term', 'term__classrooms', 'guaranteed_spots', 'guaranteed_spots__role') # Collect the general groups statistics. groups_stats = Record.groups_stats(groups) # Collect groups information related to the student. student_status_groups = Record.is_recorded_in_groups(student, groups) student_can_enqueue = Record.can_enqueue_groups(student, course.groups.all()) student_can_dequeue = Record.can_dequeue_groups(student, course.groups.all()) for group in groups: group.num_enrolled = groups_stats.get(group.pk).get('num_enrolled') group.num_enqueued = groups_stats.get(group.pk).get('num_enqueued') group.is_enrolled = student_status_groups.get(group.pk).get('enrolled') group.is_enqueued = student_status_groups.get(group.pk).get('enqueued') group.priority = student_status_groups.get(group.pk).get('priority') group.can_enqueue = student_can_enqueue.get(group.pk) group.can_dequeue = student_can_dequeue.get(group.pk) teachers = {g.teacher for g in groups} course.is_enrollment_on = any(g.can_enqueue for g in groups) data = { 'course': course, 'teachers': teachers, 'groups': groups, 'grouped_waiting_students': get_grouped_waiting_students(course, request.user) } return course, data
def create_ical_file(request: HttpRequest) -> HttpResponse: user = request.user semester = Semester.get_default_semester() cal = iCalendar() cal.add('x-wr-timezone').value = 'Europe/Warsaw' cal.add('version').value = '2.0' cal.add('prodid').value = 'Fereol' cal.add('calscale').value = 'GREGORIAN' cal.add('calname').value = "{} - schedule".format(user.get_full_name()) cal.add('method').value = 'PUBLISH' if BaseUser.is_student(user): student = user.student records = Record.objects.filter( student_id=student.pk, group__course__semester_id=semester.pk, status=RecordStatus.ENROLLED).select_related( 'group', 'group__course') groups = [r.group for r in records] elif BaseUser.is_employee(user): groups = list( Group.objects.filter(course__semester=semester, teacher=user.employee)) else: raise InvalidUserException() for group in groups: course_name = group.course.name group_type = group.human_readable_type().lower() try: terms = group.get_all_terms_for_export() except IndexError: continue for term in terms: start_datetime = datetime.datetime.combine(term.day, term.start) start_datetime += BREAK_DURATION end_datetime = datetime.datetime.combine(term.day, term.end) event = cal.add('vevent') event.add('summary').value = "{} - {}".format( course_name, group_type) if term.room: event.add('location').value = 'sala ' + term.room.number \ + ', Instytut Informatyki Uniwersytetu Wrocławskiego' event.add('description').value = 'prowadzący: ' \ + group.get_teacher_full_name() event.add('dtstart').value = start_datetime event.add('dtend').value = end_datetime cal_str = cal.serialize() response = HttpResponse(cal_str, content_type='application/calendar') ical_file_name = get_ical_filename(user, semester) response['Content-Disposition'] = "attachment; filename={}".format( ical_file_name) return response
def dispatch_notifications_task(user): """Dispatch all pending notifications for the given user by email. We batch all the e-mails for the user together and send them using one SMTP connection. We also wait for THROTTLE_SECONDS until we let the next task in the work queue to send emails. This rate limiting is introduced for Gmail to accept our queries. """ if BaseUser.is_employee(user): model, created = NotificationPreferencesTeacher.objects.get_or_create(user=user) elif BaseUser.is_student(user): model, created = NotificationPreferencesStudent.objects.get_or_create(user=user) else: return repo = get_notifications_repository() pending_notifications = repo.get_unsent_for_user(user) if not pending_notifications: return messages = [] for pn in pending_notifications: # User controls in account settings # what notifications will be send if not getattr(model, pn.description_id, None): continue ctx = { 'content': render_description( pn.description_id, pn.description_args), 'greeting': f'Dzień dobry, {user.first_name}', } message_contents = render_to_string('notifications/email_base.html', ctx) messages.append(( 'Wiadomość od Systemu Zapisów IIUWr', strip_tags(message_contents), settings.MASS_MAIL_FROM, [user.email], )) send_mass_mail(messages, fail_silently=False) # Only mark the notifications as sent if the e-mails went out successfully. for pn in pending_notifications: repo.mark_as_sent(user, pn) time.sleep(settings.EMAIL_THROTTLE_SECONDS)
def common_groups(cls, user: User, groups: List[Group]) -> Set[int]: """Returns ids of those of groups that user is involved in. User may be an employee — we then return groups he is teaching. If user is a student, we return those of the groups, he is enrolled into. If user is neither a student nor an employee, an empty set is returned. """ common_groups = set() if BaseUser.is_student(user): student_records = Record.objects.filter( group__in=groups, student=user.student, status=RecordStatus.ENROLLED) common_groups = {r.group_id for r in student_records} if BaseUser.is_employee(user): common_groups = set( Group.objects.filter(pk__in=[g.pk for g in groups], teacher=user.employee).values_list('pk', flat=True)) return common_groups
def get_queryset(self): from apps.enrollment.courses.models.group import Group query = [] if BaseUser.is_student(self.request.user): query.append(Q(record__student=self.request.user.student) & Q(record__status='1')) if BaseUser.is_employee(self.request.user): query.append(Q(teacher=self.request.user.employee)) queryset = super(MyScheduleAjaxView, self).get_queryset() groups = Group.objects.filter(reduce(operator.or_, query)) return queryset.filter(Q(event__group__in=groups) | Q(event__interested=self.request.user) | Q(event__author=self.request.user)).select_related('event', 'event__group', 'event__group__teacher')
def my_profile(request): """User profile page. The profile page displays user settings (e-mail address, notifications). If he is a student, his opening times will be displayed. If the user is an employee, the page allows him to modify his public information (office, consultations). """ semester = Semester.objects.get_next() data = { 'semester': semester, } if BaseUser.is_employee(request.user): data.update({ 'consultations': request.user.employee.consultations, 'room': request.user.employee.room, 'homepage': request.user.employee.homepage, 'title': request.user.employee.title, }) if semester and BaseUser.is_student(request.user): student: Student = request.user.student groups_opening_times = GroupOpeningTimes.objects.filter( student_id=student.pk, group__course__semester_id=semester.pk).select_related( 'group', 'group__course', 'group__teacher', 'group__teacher__user').prefetch_related( 'group__term', 'group__term__classrooms') groups_times = [] got: GroupOpeningTimes for got in groups_opening_times: group: Group = got.group group.opening_time = got.time groups_times.append(group) t0_time_obj = T0Times.objects.filter(student_id=student.pk, semester_id=semester.pk) try: t0_time = t0_time_obj.get().time except T0Times.DoesNotExist: t0_time = None grade_info = StudentGraded.objects.filter( student=student).select_related('semester').order_by( '-semester__records_opening') semesters_participated_in_grade = [x.semester for x in grade_info] current_semester_ects = Record.student_points_in_semester( student, semester) data.update({ 't0_time': t0_time, 'groups_times': groups_times, 'semesters_participated_in_grade': semesters_participated_in_grade, 'current_semester_ects': current_semester_ects, }) notifications_form = create_form(request) data.update({ 'form': notifications_form, }) return render(request, 'users/my_profile.html', data)
def _to_base_person(user: User): if BaseUser.is_employee(user): return user.employee elif BaseUser.is_student(user): return user.student raise exceptions.NotFound()
def client_connection(request): if request.method == 'POST': form = ContactForm(request.POST) if form.is_valid(): idUser = form.cleaned_data['idUser'] passwordUser = form.cleaned_data['passwordUser'] groupNumber = form.cleaned_data['groupNumber'] groupKey = int(form.cleaned_data['groupKey']) user = authenticate(username=idUser, password=passwordUser) if user is None: return HttpResponse("nie ma takiego użytkownika") if BaseUser.is_student(user): return HttpResponse("użytkownik nie jest studentem") if groupNumber == "*": st = "" students_polls = Poll.get_all_polls_for_student(user.student) if students_polls: semester = students_polls[0].semester StudentGraded.objects.get_or_create(student=user.student, semester=semester) groupped_polls = group_polls_by_course(students_polls) for polls in groupped_polls: if len(polls) == 1: st += str(polls[0].pk) + '***' st += '[' + str(polls[0].title) + ']%%%' if polls[0].group: st += str(polls[0].group.course.name) + '%%%' st += str( polls[0].group.get_type_display()) + ': %%%' st += str( polls[0].group.get_teacher_full_name()) + '%%%' st += str('***') st += str( PublicKey.objects.get( poll=polls[0].pk).public_key) + '???' else: for poll in polls: st += str(poll.pk) + '***' if not poll.group: st += 'Ankiety ogólne: %%% [' + poll.title + '] ' else: st += 'Przedmiot: ' + polls[0].group.course.name + '%%% [' + poll.title + '] ' + \ poll.group.get_type_display() + ': ' + poll.group.get_teacher_full_name() + '***' st += str( PublicKey.objects.get( poll=poll.pk).public_key) + '&&&' st += '???' return HttpResponse(st) students_polls = Poll.get_all_polls_for_student(user.student) st = "" for students_poll in students_polls: if int(students_poll.pk) == int(groupNumber): st = secure_signer_without_save(user, students_poll, groupKey) secure_signer(user, students_poll, groupKey) p = students_poll break if st == "": st = "Nie jesteś zapisany do tej ankiety" try: a = int(st[0][0]) except ValueError as err: return HttpResponse(st) if st == "Nie jesteś zapisany do tej ankiety": return HttpResponse(st) elif st == "Bilet już pobrano": return HttpResponse(st) else: return HttpResponse( to_plaintext([(p, '***', '%%%')]) + '???' + str(a))