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"))
