def annotate_nested_names(cls, qs: QuerySet): """ Include the nested name for each item in the queryset. Assumes the queryset is correctly ordered; uses the `name` field and saves to `nested_name` field. Args: qs (QuerySet): An ordered queryset, like from `get_assessment_qs` """ # preconditions; check that we have a name attribute and we don't have a nested_name attribute el = qs.first() assert hasattr(el, "name") assert not hasattr(el, "nested_name") last_depth = -math.inf names: List[str] = [] for node in qs: if node.depth == 1: node.nested_name = node.name else: if node.depth > last_depth: pass else: for i in range(last_depth - node.depth + 1): names.pop() names.append(node.name) node.nested_name = "|".join(names) last_depth = node.depth
def test_professional_closed_period_manager_get_get_between_dates( professional_closed_periods: QuerySet): """Should return slots between the dates.""" professional = professional_closed_periods.first().professional manager = ProfessionalClosedPeriod.objects start = arrow.utcnow().replace( hour=0, minute=0, second=0, microsecond=0, ) end = start.shift(days=10) result = manager.get_between_dates(start, end, professional) assert result.count() == 2 assert result.first().professional == professional assert manager.get_between_dates( start.shift(days=6), start.shift(days=15), professional, ).count() == 1 assert manager.get_between_dates( start.shift(days=20), start.shift(days=30), professional, ).count() == 0
def test_service_closed_period_manager_get_get_between_dates( service_closed_periods: QuerySet): """Should return slots between the dates.""" service = service_closed_periods.first().service manager = ServiceClosedPeriod.objects start = arrow.utcnow().replace( hour=0, minute=0, second=0, microsecond=0, ) end = start.shift(days=10) result = manager.get_between_dates(start, end, service) assert result.count() == 2 assert result.first().service == service assert manager.get_between_dates( start.shift(days=6), start.shift(days=15), service, ).count() == 1 assert manager.get_between_dates( start.shift(days=20), start.shift(days=30), service, ).count() == 0
def test_validate_service_price(services: QuerySet): """Should validate a service price.""" price = services.first().price price.is_price_fixed = True price.price = None with pytest.raises(ValidationError): validate_service_price(price) price.price = Money(0.34, EUR) validate_service_price(price) price.is_price_fixed = False price.start_price = None with pytest.raises(ValidationError): validate_service_price(price) price.start_price = Money(0.34, EUR) price.end_price = Money(1.5, USD) with pytest.raises(ValidationError): validate_service_price(price) price.start_price = Money(2.5, USD) with pytest.raises(ValidationError): validate_service_price(price) price.start_price = Money(0.5, USD) validate_service_price(price)
def test_calculator_calc(services: QuerySet): """Should calc the order price.""" order = Order() calc = Calculator() assert calc.calc(order) is None service = services.first() service.price.is_price_fixed = False order.service = service assert calc.calc(order) is None service.price.is_price_fixed = True service.price.price = Money(1, "USD") service.duration = 10 now = arrow.utcnow() order.start_datetime = now.datetime order.end_datetime = now.shift(minutes=10).datetime assert calc.calc(order) == service.price.price order.start_datetime = now order.end_datetime = now.shift(minutes=30) assert calc.calc(order) == service.price.price * Decimal(3)
def test_availability_slot_manager_get_get_between_dates( availability_slots: QuerySet): """Should return slots between the dates.""" professional = availability_slots.first().professional service = availability_slots.exclude(service__isnull=True).first().service manager: AvailabilitySlotManager = AvailabilitySlot.objects start = arrow.utcnow().replace( hour=0, minute=0, second=0, microsecond=0, ) end = start.shift(days=10) result = manager.get_between_dates(start, end, professional) assert result.count() == 10 assert result.first().professional == professional result = manager.get_between_dates( start, end, service.professional, service, ) assert result.count() == 10 assert result.first().service == service end = start.shift(days=100) result = manager.get_between_dates(start, end, professional) assert result.count() == 61
def get_budget_stats(qs: QuerySet) -> list: if len(qs) == 0: return [] budgets = Budget.objects.filter( id__in=set(qs.values_list("budget", flat=True))) start_date = qs.last().date end_date = qs.first().date date_range = (start_date, end_date) stats = [] for budget in budgets: budget_stats = { "id": budget.id, "name": budget.name, "initial_balance": budget.balance(Q(date__lt=start_date)), "final_balance": budget.balance(Q(date__lte=end_date)), "income": Transaction.objects.filter( budget=budget, date__range=date_range, income=True).aggregate(total=Sum("amount"))["total"] or 0, "outcome": Transaction.objects.filter( budget=budget, date__range=date_range, income=False).aggregate(total=Sum("amount"))["total"] or 0, } budget_stats["difference"] = (budget_stats["income"] + budget_stats["outcome"]) stats.append(budget_stats) return stats
def get_indexable_content(results: QuerySet): if not results: return [] # Only use the first method available res, method = results.first(), results.first().extractor if method not in ('readability', 'singlefile', 'dom', 'wget'): return [] # This should come from a plugin interface if method == 'readability': return get_file_result_content(res, 'content.txt') elif method == 'singlefile': return get_file_result_content(res, '') elif method == 'dom': return get_file_result_content(res,'',use_pwd=True) elif method == 'wget': return get_file_result_content(res,'',use_pwd=True)
def test_service_schedule_manager_get_by_days(service_schedules: QuerySet): """Should return schedules combined by weekdays.""" service = service_schedules.first().service schedules = ServiceSchedule.objects.get_by_days(service) assert len(schedules[0]) == 2 assert len(schedules[6]) == 0 for schedule in schedules[1]: assert schedule.day_of_week == 1
def test_professional_schedule_manager_get_by_days( professional_schedules: QuerySet): """Should return schedules combined by weekdays.""" professional = professional_schedules.first().professional schedules = ProfessionalSchedule.objects.get_by_days(professional) assert len(schedules[0]) == 2 assert len(schedules[6]) == 0 for schedule in schedules[1]: assert schedule.day_of_week == 1
def test_availability_slot_manager_get_overlapping_entries( availability_slots: QuerySet): """Should return overlapping slots.""" manager: AvailabilitySlotManager = AvailabilitySlot.objects slot = availability_slots.first() assert not manager.get_overlapping_entries(slot).count() slot.start_datetime = arrow.utcnow().datetime slot.end_datetime = arrow.utcnow().shift(days=10).datetime assert manager.get_overlapping_entries(slot).count()
def test_service_schedule_manager_get_overlapping_entries( service_schedules: QuerySet): """Should return overlapping schedules.""" manager = ServiceSchedule.objects schedule = service_schedules.first() assert not manager.get_overlapping_entries(schedule).count() schedule.start_time = time(3) schedule.end_time = time(23) assert manager.get_overlapping_entries(schedule).count()
def add_users(self, users_qs: QuerySet) -> None: assert isinstance(users_qs.first(), User), f"{users_qs.first()} is given" if users_qs.exists(): not_added_users_id_qs = users_qs.exclude( id__in=self.users.values_list("id", flat=True)).values("id") UserTeam.objects.bulk_create([ UserTeam(user_id=user_id["id"], team_id=self.id) for user_id in list(not_added_users_id_qs) ])
def test_availability_slot_admin_list_filter( professionals: QuerySet, admin_client: Client, ): """Should set the professional filter.""" response = admin_client.get( reverse("admin:schedule_availabilityslot_changelist")) assert response.status_code == 200 assert response.wsgi_request.GET.get( "professional__pk__exact") == professionals.first().pk
def test_schedule_save(professionals: QuerySet): """Should set a timezone during saving.""" schedule = ProfessionalSchedule() schedule.professional = professionals.first() schedule.day_of_week = 0 # type: ignore schedule.start_time = arrow.utcnow().datetime schedule.end_time = arrow.utcnow().shift(days=1).datetime schedule.save() assert schedule.timezone == get_current_timezone()
def test_order_save(user: User, services: QuerySet, mocker: MockFixture): """Should run the filler.""" order = Order() order.validators = [] order.service = services.first() order.client = user order.start_datetime = arrow.utcnow().shift(hours=2).datetime order.end_datetime = arrow.utcnow().shift(hours=4).datetime order.filler = mocker.MagicMock() order.save() order.filler.assert_called_once()
def test_availability_slot_save(services: QuerySet, professionals: QuerySet): """Should set a professional during saving.""" service = services.first() slot = AvailabilitySlot() slot.service = service slot.professional = professionals.exclude( pk=service.professional.pk).first() slot.start_datetime = arrow.utcnow().datetime slot.end_datetime = arrow.utcnow().shift(days=1).datetime slot.save() assert slot.professional == service.professional
def test_professional_closed_periods_manager_get_overlapping_entries( professional_closed_periods: QuerySet): """Should return overlapping closed periods.""" manager = ProfessionalClosedPeriod.objects period = professional_closed_periods.first() assert not manager.get_overlapping_entries(period).count() period.start_datetime = arrow.utcnow().shift(days=+1).datetime period.end_datetime = arrow.utcnow().shift(days=+15).datetime assert manager.get_overlapping_entries(period).count() period.start_datetime = arrow.utcnow().shift(days=+6).datetime period.end_datetime = arrow.utcnow().shift(days=+12).datetime assert manager.get_overlapping_entries(period).count()
def add_reference_to_field_on_related_model(cls, qs: QuerySet, **kwargs): cls.assert_is_proxy(qs) modified_qs = qs.all() if qs.order_by('related_model_name').distinct('related_model_name').count() == 1: related_model_name = qs.first().related_model_name modified_qs = modified_qs.annotate(**{ key: F('{}__{}'.format(related_model_name, value)) for key, value in kwargs.items() }) return modified_qs
def make_accepted(self: "RenewAdmin", request: WSGIRequest, queryset: QuerySet) -> None: """Custom action that update the status of renew to Accepted.""" renew_request = queryset.first() user = renew_request.user user.expired_at = renew_request.create_at + timezone.timedelta( days=365) user.save() queryset.update(status="Accepted")
def test_professional_schedule_manager_get_overlapping_entries( professional_schedules: QuerySet): """Should return overlapping schedules.""" manager = ProfessionalSchedule.objects schedule = professional_schedules.first() assert not manager.get_overlapping_entries(schedule).count() schedule.start_time = time(3) schedule.end_time = time(23) assert manager.get_overlapping_entries(schedule).count() schedule.start_time = time(16) schedule.end_time = time(23) assert manager.get_overlapping_entries(schedule).count()
def _daily_count(subjects_queryset: QuerySet): dates = [] men_count = [] women_count = [] if subjects_queryset.count(): subjects_queryset = subjects_queryset.order_by('faces__created_at') oldest_subject = subjects_queryset.first() newest_subject = subjects_queryset.last() lower_timestamp = min( [face.created_at for face in oldest_subject.faces.all()]) upper_timestamp = max( [face.created_at for face in newest_subject.faces.all()]) lower_date = timezone.localtime(lower_timestamp).date() upper_date = timezone.localtime(upper_timestamp).date() curr_date = lower_date ind = 0 while curr_date <= upper_date: next_date = curr_date + datetime.timedelta(days=1) subjects = subjects_queryset.filter( faces__created_at__date__gte=curr_date, faces__created_at__date__lt=next_date) men_count.append( len( set([ subject.id for subject in subjects if subject.pred_sex == Subject.SEX_MAN ]))) women_count.append( len( set([ subject.id for subject in subjects if subject.pred_sex == Subject.SEX_WOMAN ]))) dates.append(str(curr_date)) curr_date = next_date ind += 1 return { 'dates': dates, 'men_count': men_count, 'women_count': women_count, }
def test_closed_periods_restriction_get_closed_periods_for_slot( professional_closed_periods: QuerySet, service_closed_periods: QuerySet, ): """Should lazy load closed periods for the slot.""" professional = professional_closed_periods.first().professional service = service_closed_periods.first().service service.is_base_schedule = False slot = AvailabilitySlot() slot.professional = professional request = Request() start = arrow.utcnow().replace( hour=0, minute=0, second=0, microsecond=0, ) request.start_datetime = start request.end_datetime = start.shift(days=20) restriction = ClosedPeriodsRestriction() restriction.set_request(request) assert restriction.professionals_periods is None assert restriction.service_periods is None result = restriction._get_closed_periods_for_slot(slot) assert len(result) == 2 assert isinstance(result[0], ProfessionalClosedPeriod) assert result == restriction.professionals_periods assert restriction.service_periods is None slot.service = service assert len(result) == 2 result = restriction._get_closed_periods_for_slot(slot) assert isinstance(result[0], ServiceClosedPeriod) assert result == restriction.service_periods
def add_reference_to_field_on_related_model(cls, qs: QuerySet, **kwargs): cls.assert_is_proxy(qs) modified_qs = qs.all() if qs.order_by('related_model_name').distinct( 'related_model_name').count() == 1: related_model_name = qs.first().related_model_name modified_qs = modified_qs.annotate( **{ key: F('{}__{}'.format(related_model_name, value)) for key, value in kwargs.items() }) return modified_qs
def test_order_auto_filler_set_end_datetime(services: QuerySet): """Should set the order end.""" service = services.first() service.duration = 60 now = arrow.utcnow() order = Order() order.start_datetime = now.datetime order.service = service OrderAutoFiller(order)._set_end_datetime() assert order.end_datetime == now.shift(minutes=60).datetime end = now.shift(days=2).datetime order.end_datetime = end OrderAutoFiller(order)._set_end_datetime() assert order.end_datetime == end
def get_tag_stats(qs: QuerySet) -> list: stats = [] if len(qs) == 0: return stats tags = Tag.objects.filter(user=qs.first().budget.user) for tag in tags: transactions_with_tag = qs.filter(tags=tag) if len(transactions_with_tag) == 0: continue total = transactions_with_tag.aggregate( total=Sum("amount"))["total"] stats.append({"name": tag.name, "total": total}) stats.sort(key=operator.itemgetter("total"), reverse=True) return stats
def test_availability_slot_admin_weekday(professionals: QuerySet): """Should return a weekday for an object.""" slot = AvailabilitySlot() slot.professional = professionals.first() now = arrow.utcnow() tomorrow = now.shift(days=1) slot.start_datetime = now.datetime slot.end_datetime = now.shift(hours=1).datetime admin = AvailabilitySlotAdmin( model=AvailabilitySlot, admin_site=AdminSite(), ) assert admin.weekday(slot) == now.format("dddd") slot.end_datetime = tomorrow.datetime assert admin.weekday( slot) == f"{now.format('dddd')} - {tomorrow.format('dddd')}"
def test_order_restriction_get_orders(orders: QuerySet): """Should return the orders.""" order = orders.first() restriction = OrderRestriction() request = Request() request.start_datetime = arrow.utcnow() request.end_datetime = arrow.utcnow().shift(days=2) request.professional = order.service.professional request.service = order.service result = restriction.set_request(request)._get_orders() assert len(result) == 1 request.service = None restriction.orders = None result = restriction.set_request(request)._get_orders() assert len(result) == 2
def test_order_auto_filler_set_status(services: QuerySet): """Should set the order status.""" service = services.first() service.is_auto_order_confirmation = False order = Order() order.service = service OrderAutoFiller(order)._set_status() assert order.status == order.STATUS_NOT_CONFIRMED service.is_auto_order_confirmation = True OrderAutoFiller(order)._set_status() assert order.status == order.STATUS_CONFIRMED order.pk = 1 order.status = order.STATUS_PAID OrderAutoFiller(order)._set_status() assert order.status == order.STATUS_PAID
def attribute_class_filter(queryset: QuerySet, user: User = None) -> Tuple[QuerySet, QuerySet]: if not user: return queryset, [] # Get all of the classes that we aren't in. restricted_attribute_classes = AttributeClass.objects.exclude(users=user) attribute_class_queries = { "ExportRun": { "data_provider_task_records__provider__attribute_class__in": restricted_attribute_classes }, "RunZipFile": { "data_provider_task_records__provider__attribute_class__in": restricted_attribute_classes }, "Job": { "data_provider_tasks__provider__attribute_class__in": restricted_attribute_classes }, "DataProvider": { "attribute_class__in": restricted_attribute_classes }, "DataProviderTask": { "provider__attribute_class__in": restricted_attribute_classes }, "DataProviderTaskRecord": { "provider__attribute_class__in": restricted_attribute_classes }, } item = queryset.first() attribute_class_query = {} if item: # Get all of the objects that don't include attribute classes that we aren't in. attribute_class_query = attribute_class_queries.get( type(item).__name__, {}) filtered = queryset.filter(**attribute_class_query).distinct() queryset = queryset.exclude(**attribute_class_query).distinct() return queryset, filtered
def _check_auction_post_request_cash_requirements(auction: Auction, user_query: QuerySet, bid_value: int) -> Tuple: """ Check if auction post request requirements are fulfilled, but focus only on cash requirements. Requirements: - user must have enough cash for bid - bid must be greater than last bid value and auction starting price :param auction: aimed auction :param user_query: query of users with special uuid :param bid_value: value of new bid (try) :return: response status and information about occurred error """ data, status = {}, 0 user = user_query.first() # check user cash in wallet if user.cash < bid_value: data["summary"] = "User has not enough cash for this bet." data["userCash"] = user.cash data["bidValue"] = bid_value data["errorMessage"] = "User has less cash than minimal bid value." return data, 400 last_bid = auction.last_bid_value # check bid value correctness if (last_bid is not None and bid_value <= last_bid) or bid_value <= auction.starting_price: data["summary"] = "Wrong bid value." data["auctionStartingPrice"] = auction.starting_price data["auctionLastBidValue"] = auction.last_bid_value data["bidValue"] = bid_value data[ "errorMessage"] = "Bid must be greater than starting price and last bid value." return data, 400 return data, status