def _make_queryset(q: QuerySet, search: dict, fields_paramname: str, exclude_paramname: str, orderby_paramname: str, distinct_paramname: str, keyval: str, keyor: str) -> Q: filters = search.get(fields_paramname) ftype = type(filters) if dict == ftype: query = _make_query(filters, keyval, keyor) if query is not None: q = q.filter(**filters) elif Q == ftype: q = q.filter(filters) filters = search.get(exclude_paramname) ftype = type(filters) if dict == ftype: query = _make_query(filters, keyval, keyor) if query is not None: q = q.exclude(**filters) elif Q == ftype: q = q.exclude(filters) filters = search.get(orderby_paramname) if type(filters) == list: q = q.order_by(*filters) else: q = q.order_by(str(filters)) filters = search.get(distinct_paramname) if type(filters) == list: q = q.distinct(*filters) else: q = q.distinct(str(filters)) return q
def test_calendar_validate_request( professionals: QuerySet, services: QuerySet, ): """Should validate a calendar request.""" request = CalendarRequest() professional = professionals.first() request.professional = professional start = arrow.utcnow() end = start.shift(hours=-1) request.start_datetime = start request.end_datetime = end with pytest.raises(CalendarValidationError) as error: validators.validate_calendar_request(request) assert "start datetime" in str(error) assert "end datetime" in str(error) end = start.shift(hours=1) request.end_datetime = end validators.validate_calendar_request(request) service = services.exclude(professional=professional).first() request.service = service with pytest.raises(CalendarValidationError) as error: validators.validate_calendar_request(request) assert "service" in str(error) request.service = request.professional.services.first() # type: ignore validators.validate_calendar_request(request)
def test_availability_request_year_processor( professionals: QuerySet, services: QuerySet, ): """Should set dates and a professional.""" service = services.first() professional = professionals.exclude(pk=service.professional.pk).first() request = Request() request.service = service request.professional = professional processor = RequestYearProcessor() new_request = processor.get(request) assert new_request.professional == service.professional assert new_request.start_datetime == arrow.utcnow().replace( hour=0, minute=0, second=0, microsecond=0, ) assert new_request.end_datetime == arrow.utcnow().replace( hour=0, minute=0, second=0, microsecond=0, ).shift(years=1)
def test_user_sent_order_create( user: User, client_with_token: Client, services: QuerySet, availability_slots: QuerySet, ): """Should be able to create a sent order object.""" service = services.exclude(professional__user=user).first() service.service_type = service.TYPE_PROFESSIONAL_LOCATION service.is_enabled = True service.save() slot = availability_slots.filter(service=service).last() response = client_with_token.post( reverse("user-orders-sent-list"), { "service": service.pk, "service_location": service.locations.first().pk, "start_datetime": slot.start_datetime.isoformat(), "note": "new sent order", "first_name": "new first name", "last_name": "new last name", "phone": "+12136210002", }, ) order = service.orders.first() assert response.status_code == 201 assert order.note == "new sent order" assert order.end_datetime == arrow.get( order.start_datetime).shift(minutes=service.duration).datetime
def test_user_sent_order_update( user: User, client_with_token: Client, orders: QuerySet, availability_slots: QuerySet, ): """Should be able to update a sent order.""" query = orders.exclude(service__professional__user=user) query.update(client=user) order = query.first() price = order.price slot = availability_slots.filter(service=order.service).last() response = client_with_token.patch( reverse("user-orders-sent-detail", args=[order.pk]), { "note": "new note", "start_datetime": slot.start_datetime.isoformat(), "end_datetime": "", "phone": "+12136210002", }, ) order.refresh_from_db() assert response.status_code == 200 assert order.client == user assert order.price != price assert order.modified_by == user assert order.end_datetime == arrow.get( order.start_datetime).shift(minutes=order.service.duration).datetime
def category_discover(request, category=None): template_name = "search/category_discover.html" if category is None: category = Category(name="Discover", slug="discover") else: category = get_object_or_404(Category, slug=category) # Do a 301-redirect for SEO purposes parents = _get_category_parent_slugs(category) if len(parents) > 0: url = reverse("category_discover", args=parents + [category.slug]) if len(request.GET): url = "%s?%s" % (url, request.GET.urlencode()) return HttpResponseRedirect(url) if category.id is None: subcategories = Category.objects search_terms = "" else: subcategories = category.get_descendants() search_terms = category.get_slug_path() # Show only categories with products in stock # # doing exclude(products=None) doesn't work because it'll still include # categories which only have out of stock products. # But you can't do exclude(products=None, products__stock=0) or any combination # like that because the Django ORM ... basically can't do the query like that # because the `product.stock != 0` needs to be a JOIN condition, then # `product.id IS NULL` as a WHERE condition, but Django puts both as WHERE # conditions. empty_categories = [cat.pk for cat in Category.objects.raw(""" SELECT c.id, c.parent_id, c.tree_id, c.name FROM marketplace_category c LEFT JOIN marketplace_product p ON(p.primary_category_id = c.id AND p.stock != 0) WHERE p.id IS NULL GROUP BY c.id """)] subcategories = (subcategories.exclude(slug__contains="adult") .order_by('-products__number_of_recent_sales', '-products__number_of_sales')) subcat_query = subcategories.query subcat_query.group_by = ['id'] subcategories = QuerySet(model=Category, query=subcat_query) subcategories = subcategories.exclude(pk__in=empty_categories) subcategories = subcategories[:16] context = { "category": category, "subcategories": subcategories, "search_terms": search_terms, 'ecomm_pagetype': 'category', } if category.id is not None: context['ecomm_category'] = category.name return render(request, template_name, context)
def test_validate_review_comment_user(admin: User, reviews: QuerySet): """Should validate the review comment user.""" comment = ReviewComment() comment.user = admin comment.review = reviews.exclude(professional__user=admin).first() with pytest.raises(ValidationError): validate_review_comment_user(comment)
def test_user_received_order_update_restricted_entry( user: User, client_with_token: Client, orders: QuerySet, ): """Should deny access to someone else"s record.""" obj: Order = orders.exclude(service__professional__user=user).first() response = client_with_token.post( reverse("user-orders-received-detail", args=[obj.pk]), {"note": "new"}) assert response.status_code == 405
def filter_queryset(self, request: Request, queryset: QuerySet, view: ViewSet) -> QuerySet: if view.action != 'list': return queryset categories = request.query_params.get('categories', '').split(',') include = [c.lower() for c in categories if c and c[0] != '-'] exclude = [c[1:].lower() for c in categories if c and c[0] == '-'] if include: queryset = queryset.filter( categories__in=list(map(str.lower, include))) if exclude: queryset = queryset.exclude( categories__in=list(map(str.lower, exclude))) return queryset
def test_review_comment_notifier( user: User, reviews: QuerySet, mocker: MockFixture, ): """Should run a notifier on save.""" mock = mocker.patch("communication.models.ReviewComment.notifier") review = reviews.exclude(professional__user=user).first() comment = ReviewComment() comment.user = user comment.review = review comment.title = "title" comment.description = "description" comment.save() assert mock.call_count == 1
def filter_and_exclude_games(user_games: QuerySet, request: HttpRequest) -> Tuple[QuerySet, QuerySet, str, str]: usergames_queryset, sort_by, order_by = filter_games(user_games, request) # Querystring takes precedence to allow explicit sorting/showing back even if cookie is set exclude = request.GET.get("exclude", None) or request.COOKIES.get(constants.USER_OPTIONS_EXCLUDE_COOKIE_NAME, None) try: exclude_kwargs = constants.EXCLUDE_FIELDS_MAPPING[exclude] # type: Optional[Dict] except KeyError: exclude = None exclude_kwargs = None if exclude: return user_games.exclude(**exclude_kwargs).order_by(*order_by), usergames_queryset, sort_by, exclude else: return usergames_queryset, usergames_queryset, sort_by, ""
def test_user_sent_order_detail( user: User, client_with_token: Client, orders: QuerySet, ): """Should return a sent order.""" query = orders.exclude(service__professional__user=user) query.update(client=user) obj = query.first() response = client_with_token.get( reverse("user-orders-sent-detail", args=[obj.pk])) data = response.json() assert response.status_code == 200 assert data["price_amount"] == str(obj.price.amount) assert data["price_currency"] == str(obj.price.currency)
def test_user_send_orders_list( user: User, client_with_token: Client, orders: QuerySet, ): """Should return a sent orders list.""" query = orders.exclude(service__professional__user=user) query.update(client=user) obj = query.first() response = client_with_token.get(reverse("user-orders-sent-list")) data = response.json() assert response.status_code == 200 assert data["count"] == query.count() assert data["results"][0]["service"] == obj.service.pk assert data["results"][0]["note"] == obj.note
def test_review_notifier( user: User, professionals: QuerySet, mocker: MockFixture, ): """Should run a notifier on save.""" mock = mocker.patch("communication.models.Review.notifier") professional = professionals.exclude(user=user).first() review = Review() review.user = user review.professional = professional review.title = "title" review.description = "description" review.rating = RatingField.GOOD review.save() assert mock.call_count == 1
def queryset(self, request: HttpRequest, queryset: QuerySet) -> QuerySet: """ Return the filtered queryset based on the value provided in the query string. :param request: The original request. :param queryset: The original queryset. :return: A filtered queryset according to :meth:`lookups`. """ return { 'superuser': queryset.filter(is_superuser=True), 'staff': queryset.filter(is_staff=True), 'scanlator': queryset.filter(groups__name='Scanlator'), 'regular': queryset.exclude(is_staff=True) }.get(self.value(), queryset)
def test_availability_request_validator( professionals: QuerySet, services: QuerySet, ): """Should validate a request.""" service = services.first() professional = professionals.exclude(pk=service.professional.pk).first() request = Request() now = arrow.utcnow() validator = RequestValidator() with pytest.raises(AvailabilityValueError) as error: validator.validate(request) assert "datetime is invalid" in str(error) request.start_datetime = now with pytest.raises(AvailabilityValueError) as error: validator.validate(request) assert "datetime is invalid" in str(error) request.end_datetime = request.start_datetime.shift(hours=-1) with pytest.raises(AvailabilityValueError) as error: validator.validate(request) assert "be less" in str(error) request.end_datetime = request.end_datetime.replace( tzinfo="America/Toronto") with pytest.raises(AvailabilityValueError) as error: validator.validate(request) assert "datetime is invalid" in str(error) request.end_datetime = request.start_datetime.shift(months=1) with pytest.raises(AvailabilityValueError) as error: validator.validate(request) assert "professional is empty" in str(error) request.professional = professional request.service = service with pytest.raises(AvailabilityValueError) as error: validator.validate(request) assert "service is incorrect" in str(error) request.professional = service.professional validator.validate(request)
def test_notify_new_review( user: User, professionals: QuerySet, mailoutbox: List[EmailMultiAlternatives], ): """Should notify about a new review.""" professional = professionals.exclude(user=user).first() review = Review() review.user = user review.professional = professional review.title = "title" review.description = "description" notify_new_review(review) assert len(mailoutbox) == 1 assert professional.user.email in mailoutbox[0].recipients() notify_new_review(review) assert len(mailoutbox) == 2
def test_notify_new_review_comment( user: User, reviews: QuerySet, mailoutbox: List[EmailMultiAlternatives], ): """Should notify about a new review comment.""" mailoutbox.clear() review = reviews.exclude(professional__user=user).first() comment = ReviewComment() comment.user = user comment.review = review comment.title = "title" comment.description = "description" notify_new_review_comment(comment) assert len(mailoutbox) == 1 assert review.user.email in mailoutbox[0].recipients() notify_new_review_comment(comment) assert len(mailoutbox) == 2
def _filter_and_exclude_games(user_games: QuerySet, request: HttpRequest) -> Tuple[QuerySet, QuerySet, str, str]: sort_by = request.GET.get("sort_by", constants.SORT_BY_GAME_NAME) try: order_by = constants.SORT_FIELDS_MAPPING[sort_by] except KeyError: order_by = constants.SORT_FIELDS_MAPPING[constants.SORT_BY_GAME_NAME] # Querystring takes precedence to allow explicit sorting/showing back even if cookie is set exclude = request.GET.get("exclude", None) or request.COOKIES.get(constants.USER_OPTIONS_EXCLUDE_COOKIE_NAME, None) exclude_kwargs = None # type: Any try: exclude_kwargs = constants.EXCLUDE_FIELDS_MAPPING[exclude] except KeyError: exclude = None usergames_queryset = user_games.order_by(*order_by) if exclude: return user_games.exclude(**exclude_kwargs).order_by(*order_by), usergames_queryset, sort_by, exclude else: return usergames_queryset, usergames_queryset, sort_by, ""
def test_availability_request_append_processor( professionals: QuerySet, services: QuerySet, ): """Should set dates and a professional.""" service = services.first() professional = professionals.exclude(pk=service.professional.pk).first() request = Request() request.service = service request.professional = professional processor = RequestAppendProcessor() new_request = processor.get(request) assert new_request.professional == service.professional assert new_request.start_datetime == arrow.utcnow().replace( hour=0, minute=0, second=0, microsecond=0, ).shift(years=1) assert new_request.end_datetime == new_request.start_datetime.shift( days=settings.AVAILABILITY_DAYS_TO_APPEND)
def test_user_sent_started_order_update( user: User, client_with_token: Client, orders: QuerySet, ): """Should deny access to someone else"s record.""" query = orders.exclude(service__professional__user=user) query.update(client=user) order = query.first() order.start_datetime = arrow.utcnow().shift(hours=-1).datetime order.end_datetime = None order.save() response = client_with_token.patch( reverse("user-orders-sent-detail", args=[order.pk]), { "note": "new note", "phone": "+12136210002", }, ) assert response.status_code == 400 assert response.json()["error"] == "Updating a started order is forbiden."
def calculate_progress_counters(unfiltered_user_games: QuerySet) -> Tuple[int, int, int, int, int, int, int]: # counters use unfiltered list unfiltered_games_count = unfiltered_user_games.count() currently_playing_games_count = unfiltered_user_games.filter(currently_playing=True).count() finished_games_count = unfiltered_user_games.exclude(year_finished__isnull=True).count() abandoned_games_count = unfiltered_user_games.filter(abandoned=True).count() completed_games_count = finished_games_count + abandoned_games_count pending_games_count = unfiltered_games_count - completed_games_count if unfiltered_games_count > 0: completed_games_progress = int(completed_games_count * 100 / unfiltered_games_count) else: completed_games_progress = 0 return ( unfiltered_games_count, currently_playing_games_count, finished_games_count, abandoned_games_count, completed_games_count, pending_games_count, completed_games_progress, )
def get_article1_and_groups_if_many_articles(self, articles: QuerySet): article1 = articles[0] articles = articles.exclude(author=article1.author, name=article1.name) groups = self.get_groups(articles) return article1, groups
def queryset(self, request: HttpRequest, queryset: QuerySet) -> QuerySet: if self.value() == "True": return queryset.exclude(fg_game__isnull=True).filter( last_sync_date=F("last_modified_date")) elif self.value() == "False": return queryset.exclude(last_sync_date=F("last_modified_date"))