def schedule_one(request, pk): """ view to get or update or delete a single schedule corresponding to the primary key passed as an argument to the view. """ try: schedule = Schedule.objects.get(pk=pk) except Schedule.DoesNotExist: return HttpResponse(status=404) if request.method == 'GET': serializer = ScheduleSerializer(instance=schedule) return JsonResponse(serializer.data, status=200) elif request.method == 'PUT': data = JSONParser().parse(request) serializer = ScheduleSerializer(instance=schedule, data=data) if serializer.is_valid(): serializer.save() return JsonResponse(serializer.data) return JsonResponse(serializer.errors, status=400) elif request.method == 'DELETE': schedule.delete() return HttpResponse(status=204)
def test_recipient_in_db_not_raises_validation_error(self): recipients = [{'name': 'test', 'email_address': '*****@*****.**'}] data_1 = create_schedule_input_data(content="placeholder 1", recipients=recipients) data_2 = create_schedule_input_data(content="placeholder 2", recipients=recipients) serializer_1 = ScheduleSerializer(data=data_1) serializer_2 = ScheduleSerializer(data=data_2) self.assertEqual(serializer_1.is_valid(), True) serializer_1.save() self.assertEqual(serializer_2.is_valid(), True) serializer_2.save()
def test_schedule_unique_together_validation(self): recipients = [{'name': 'test', 'email_address': '*****@*****.**'}] data_1 = create_schedule_input_data(recipients=recipients) serializer_1 = ScheduleSerializer(data=data_1) serializer_1.is_valid() serializer_1.save() data_2 = create_schedule_input_data(recipients=recipients) serializer_2 = ScheduleSerializer(data=data_2) serializer_2.is_valid() self.assertEqual(serializer_2.errors['non_field_errors'][0], FIELDS_NOT_UNIQUE_TOGETHER_ERROR) with self.assertRaises(ValidationError): serializer_2.is_valid(raise_exception=True)
def schedule_list(request): """ view to fetch all schedules stored or to add a new schedule """ if request.method == 'GET': schedules = Schedule.objects.all() serializers = ScheduleSerializer(instance=schedules, many=True) return JsonResponse(serializers.data, safe=False) elif request.method == 'POST': data = JSONParser().parse(request) serializer = ScheduleSerializer(data=data) if serializer.is_valid(): serializer.save() return JsonResponse(serializer.data, status=201) return JsonResponse(serializer.errors, status=400)
def routes_bus_passengers_sold_view(request, id): """ Filter all the buses from a particular route with more than X percentage of its capacity sold. parameter id its the id of the route and url parameters for the percentage """ # Get all the schedules for the route schedules = Schedule.objects.filter(route=id) percentage_minimum = 0 try: # Get the percentage from the url parameters, in case # no percentage parameter sent, the value will be 0 percentage_minimum = int(request.GET.get("percentage")) except Exception as e: error_message = { "Error": "Invalid request, " + str(e) } return JsonResponse(error_message, status=status.HTTP_400_BAD_REQUEST) buses = [] # Go through the schedules for schedule in schedules: # Get the property max capaticy from the bus for each # particular schedule bus = Bus.objects.get(id=schedule.bus.id) max_capacity_bus = bus.seats # Get the seats sold on for the schedule seats = Seat.objects.filter(schedule=schedule.id) # Calculate the percentage percentage_calculated = (seats.count() * 100) / max_capacity_bus if percentage_calculated >= percentage_minimum: dict = {"schedule": ScheduleSerializer( schedule).data, "percentage_sold_on_bus": percentage_calculated, "seats_sold": seats.count()} buses.append(dict) return JsonResponse(buses, status=status.HTTP_200_OK, safe=False)
def test_update_schedule_end_date_before_start_raises_error(self): serialize_input_data(recipients=self.recipients) schedule = Schedule.objects.first() new_data = create_schedule_input_data() new_data['start_date'] = new_data['end_date'] + timedelta(days=1) serializer = ScheduleSerializer(instance=schedule, data=new_data) with self.assertRaises(ValidationError): serializer.is_valid(raise_exception=True)
def test_update_schedule_content(self): serialize_input_data(recipients=self.recipients) self.assertEqual(Schedule.objects.count(), 1) data = create_schedule_input_data(content="new content") schedule = Schedule.objects.first() updated_serializer = ScheduleSerializer(instance=schedule, data=data) self.assertEqual(updated_serializer.is_valid(), True) updated_serializer.save() self.assertEqual(schedule.content, updated_serializer.data['content']) self.assertEqual(schedule.content, "new content")
def test_update_frequency_gt_end_date_raises_validation_error(self): serialize_input_data(recipients=self.recipients) self.assertEqual(Schedule.objects.count(), 1) data = create_schedule_input_data(frequency=timedelta(days=5), end_date=default_date_time(days=1)) schedule = Schedule.objects.first() updated_serializer = ScheduleSerializer(instance=schedule, data=data) updated_serializer.is_valid() self.assertEqual(updated_serializer.errors['non_field_errors'][0], FREQUENCY_GREATER_THAN_END_DATE_ERROR) with self.assertRaises(ValidationError): updated_serializer.is_valid(raise_exception=True)
def test_update_schedule_status_to_paused(self): serialize_input_data(recipients=self.recipients) schedule = Schedule.objects.first() self.assertEqual(schedule.status, Schedule.NOT_ADDED) new_data = create_schedule_input_data() new_data['status'] = Schedule.PAUSED serializer = ScheduleSerializer(instance=schedule, data=new_data) self.assertEqual(serializer.is_valid(), True) if serializer.is_valid(): serializer.save() self.assertEqual(schedule.status, Schedule.PAUSED) self.assertEqual(Schedule.objects.count(), 1)
def test_recipients_more_than_500_raises_validation_error(self): data = {} recipients = [{ 'name': 'test', 'email_address': f'test{idx}@test.com' } for idx in range(501)] data = create_schedule_input_data(recipients=recipients) serializer = ScheduleSerializer(data=data) serializer.is_valid() self.assertEqual(serializer.errors['non_field_errors'][0], RECIPIENTS_GREATER_THAN_500_ERROR) with self.assertRaises(ValidationError): serializer.is_valid(raise_exception=True)
def test_serializer_can_deserialize_json(self): recipients = [{ 'name': 'test', 'email_address': '*****@*****.**' }, { 'name': 'test2', 'email_address': '*****@*****.**' }] data = create_schedule_input_data(recipients=recipients) serializer = ScheduleSerializer(data=data) self.assertEqual(serializer.is_valid(), True) schedule = serializer.save() self.assertIsInstance(schedule, Schedule) self.assertEqual(Schedule.objects.count(), 1) self.assertEqual(Recipient.objects.count(), 2)
def test_update_schedule_recipients(self): serialize_input_data(recipients=self.recipients) self.assertEqual(Schedule.objects.count(), 1) recipients = [{'name': 'test', 'email_address': '*****@*****.**'}] data = create_schedule_input_data(recipients=recipients) schedule = Schedule.objects.first() updated_serializer = ScheduleSerializer(instance=schedule, data=data) self.assertEqual(updated_serializer.is_valid(), True) updated_serializer.save() updated_recipients = schedule.recipients.all() self.assertEqual( updated_recipients[0].email_address, updated_serializer.data['recipients'][0]['email_address']) self.assertEqual(updated_recipients[0].email_address, '*****@*****.**')
def test_recipient_duplication_raises_validation_error(self): recipients = [{ 'name': 'test', 'email_address': '*****@*****.**' }, { 'name': 'test', 'email_address': '*****@*****.**' }] data = create_schedule_input_data(recipients=recipients) serializer = ScheduleSerializer(data=data) serializer.is_valid() self.assertEqual(serializer.errors['non_field_errors'][0], RECIPIENTS_CONTAIN_DUPLICATES_ERROR) with self.assertRaises(ValidationError): serializer.is_valid(raise_exception=True)
def test_update_schedule_frequency(self): serialize_input_data(start_date=default_date_time(), end_date=default_date_time(days=5), recipients=self.recipients) self.assertEqual(Schedule.objects.count(), 1) data = create_schedule_input_data(frequency=timedelta(days=2), end_date=default_date_time(days=5)) schedule = Schedule.objects.first() updated_serializer = ScheduleSerializer(instance=schedule, data=data) self.assertEqual(updated_serializer.is_valid(), True) updated_serializer.save() self.assertEqual(updated_serializer.validated_data['frequency'], timedelta(days=2)) self.assertEqual(updated_serializer.validated_data['frequency'], schedule.frequency) self.assertEqual(Schedule.objects.count(), 1)
def test_serializer_can_serialize_queryset(self): recipients = [{ 'name': 'test', 'email_address': '*****@*****.**' }, { 'name': 'test2', 'email_address': '*****@*****.**' }] num_schedules = 10 serialize_input_data(recipients=recipients, num_schedules=num_schedules) schedules = Schedule.objects.all() serialized_schedules = ScheduleSerializer(instance=schedules, many=True) self.assertEqual(len(schedules), num_schedules) self.assertEqual(len(serialized_schedules.data), num_schedules)
def test_updating_interval_adds_new_celery_task(self): serialize_input_data(recipients=self.recipients) schedule = Schedule.objects.first() interval = Interval.objects.first() self.assertEqual(interval.interval, schedule.frequency) self.assertIsNotNone(app.conf.beat_schedule[str(interval.interval)]) self.assertEqual(Interval.objects.count(), 1) new_data = create_schedule_input_data() new_data['frequency'] = timedelta(days=3) new_data['end_date'] = new_data['start_date'] + timedelta(days=5) serializer = ScheduleSerializer(instance=schedule, data=new_data) if serializer.is_valid(): serializer.save() interval = Interval.objects.get(interval=new_data['frequency']) self.assertIsNotNone(app.conf.beat_schedule[str(interval.interval)]) # self.assertEqual(len(app.conf.beat_schedule), 2) self.assertEqual(Interval.objects.count(), 2)
def test_update_interval_when_updating_schedule(self): serialize_input_data(recipients=self.recipients) schedule = Schedule.objects.first() interval = Interval.objects.first() self.assertEqual(schedule.frequency, interval.interval) new_data = create_schedule_input_data() new_data['frequency'] = timedelta(days=3) new_data['end_date'] = new_data['start_date'] + timedelta(days=5) serializer = ScheduleSerializer(instance=schedule, data=new_data) self.assertEqual(serializer.is_valid(), True) if serializer.is_valid(): serializer.save() interval = Interval.objects.get(interval=new_data['frequency']) self.assertEqual(Schedule.objects.count(), 1) self.assertEqual(Interval.objects.count(), 2) self.assertEqual(schedule.frequency, new_data['frequency']) self.assertEqual(schedule.frequency, interval.interval)
def test_invalid_email_addresses_raise_validation_error(self): recipients = [{ 'name': 'test', 'email_address': 'test' }, { 'name': 'test', 'email_address': '*****@*****.**' }] data = create_schedule_input_data(recipients=recipients) schedule_serializer = ScheduleSerializer(data=data) self.assertEqual(schedule_serializer.is_valid(), False) self.assertEqual( schedule_serializer.errors['recipients'][0]['email_address'][0], INVALID_EMAIL_ADDRESS_ERROR) self.assertEqual(Schedule.objects.count(), 0) self.assertEqual(Recipient.objects.count(), 0) with self.assertRaises(ValidationError): schedule_serializer.is_valid(raise_exception=True)
def extract_signatures(pdfpath, profile): def remove_spaces(string): return "".join(string.rstrip().lstrip()) try: # signatures = [] with pdfplumber.open(pdfpath) as pdf: table1 = pdf.pages[0].extract_tables()[0][1:] schedule = Schedule.objects.create(profile=profile) for val in table1: if 'Local:' in val[1] and 'Tipo:' in val[ 1] and 'MATRICULADO' in val[3]: code = remove_spaces(val[0]).upper() group = remove_spaces(val[2]).title() schedules = val[4].split() about = val[1].split('\n') # Tipo: DISCIPLINA Local: sala de aula virtual classroom_type = about[-1].split('Local:') classroom = remove_spaces(classroom_type[-1]).title() stype = remove_spaces( classroom_type[0].split('Tipo:')[-1]).title() professor = remove_spaces(about[-2]).title() name = remove_spaces((' '.join(about[0:-2]))).title() classroom = Classroom.objects.create(profile=profile, content={ "name": name, "code": code, "type": stype, "professor": professor, "classroom": classroom, "group": group, "schedules": schedules }) schedule.classrooms.add(classroom) # signatures.append({"name": name, "code": code, "type": stype, "professor": professor, "classroom": classroom, "group": group, "schedules": schedules}) return ScheduleSerializer(instance=schedule).data except Exception as ex: print("Signature exception ", str(ex)) return -1
def serialize_input_data(description="placeholder", subject="placeholder", content="placeholder", frequency=timedelta(days=1), start_date=default_date_time(), end_date=default_date_time(days=1), status=Schedule.NOT_ADDED, recipients=[], num_schedules=1): for num in range(num_schedules): data = create_schedule_input_data(description=description, subject=subject, content=f"{content}: {num}", frequency=frequency, start_date=start_date, end_date=end_date, status=status, recipients=recipients) serializer = ScheduleSerializer(data=data) if serializer.is_valid(): serializer.save()