def test_coupon_creation_for_supplier(rf, admin_user):
"""
To make things little bit more simple let's use only english as
a language.
"""
shop = get_default_shop()
supplier = Supplier.objects.create(identifier=admin_user.username)
another_superuser = create_random_user(is_superuser=True, is_staff=True)
supplier2 = Supplier.objects.create(identifier=another_superuser.username)
supplier_provider = "shuup.testing.supplier_provider.UsernameSupplierProvider"
with override_settings(LANGUAGES=[("en", "en")]):
with override_settings(SHUUP_ADMIN_SUPPLIER_PROVIDER_SPEC=supplier_provider):
view = CouponEditView.as_view()
data = {"code": "OK", "active": True, "shop": shop.pk}
coupons_before = Coupon.objects.count()
request = apply_request_middleware(rf.post("/", data=data), user=admin_user)
assert get_supplier(request) == supplier
response = view(request, pk=None)
assert response.status_code in [200, 302]
assert Coupon.objects.count() == (coupons_before + 1)
new_coupon = Coupon.objects.filter(supplier=supplier).first()
assert new_coupon
# Another superuser shouldn't see this campaign
request = apply_request_middleware(rf.post("/", data=data), user=another_superuser)
assert get_supplier(request) == supplier2
with pytest.raises(Http404):
response = view(request, pk=new_coupon.pk)
def test_coupon_creation_for_supplier(rf, admin_user):
"""
To make things little bit more simple let's use only english as
a language.
"""
shop = get_default_shop()
supplier = Supplier.objects.create(identifier=admin_user.username)
another_superuser = create_random_user(is_superuser=True, is_staff=True)
supplier2 = Supplier.objects.create(identifier=another_superuser.username)
supplier_provider = "shuup.testing.supplier_provider.UsernameSupplierProvider"
with override_settings(LANGUAGES=[("en", "en")]):
with override_settings(SHUUP_ADMIN_SUPPLIER_PROVIDER_SPEC=supplier_provider):
view = CouponEditView.as_view()
data = {
"code": "OK",
"active": True,
"shop": shop.pk
}
coupons_before = Coupon.objects.count()
request = apply_request_middleware(rf.post("/", data=data), user=admin_user)
assert get_supplier(request) == supplier
response = view(request, pk=None)
assert response.status_code in [200, 302]
assert Coupon.objects.count() == (coupons_before + 1)
new_coupon = Coupon.objects.filter(supplier=supplier).first()
assert new_coupon
# Another superuser shouldn't see this campaign
request = apply_request_middleware(rf.post("/", data=data), user=another_superuser)
assert get_supplier(request) == supplier2
with pytest.raises(Http404):
response = view(request, pk=new_coupon.pk)
def get_service_providers_filters(request, payment_method=None):
shop_filter = Q(Q(shops__isnull=True) | Q(shops=get_shop(request)))
if payment_method and payment_method.pk and payment_method.supplier:
return shop_filter & Q(
Q(supplier__isnull=True) | Q(supplier=get_supplier(request))
| Q(supplier=payment_method.supplier))
return shop_filter & Q(
Q(supplier__isnull=True) | Q(supplier=get_supplier(request)))
def test_coupon_list_for_suppliers(rf, admin_user):
"""
To make things little bit more simple let's use only english as
a language.
"""
shop = get_default_shop()
superuser1 = create_random_user(is_superuser=True, is_staff=True)
supplier1 = Supplier.objects.create(identifier=superuser1.username)
superuser2 = create_random_user(is_superuser=True, is_staff=True)
supplier2 = Supplier.objects.create(identifier=superuser2.username)
supplier_provider = "shuup.testing.supplier_provider.UsernameSupplierProvider"
with override_settings(LANGUAGES=[("en", "en")]):
with override_settings(
SHUUP_ADMIN_SUPPLIER_PROVIDER_SPEC=supplier_provider):
code1 = Coupon.objects.create(code="1",
active=True,
shop=shop,
supplier=supplier1)
code2 = Coupon.objects.create(code="2",
active=True,
shop=shop,
supplier=supplier2)
view = CouponListView()
request = apply_request_middleware(rf.get("/"),
user=superuser1,
shop=shop)
assert get_supplier(request) == supplier1
view.request = request
assert code1 in view.get_queryset()
assert code2 not in view.get_queryset()
request = apply_request_middleware(rf.get("/"),
user=superuser2,
shop=shop)
assert get_supplier(request) == supplier2
view.request = request
assert code1 not in view.get_queryset()
assert code2 in view.get_queryset()
# And actual superuser not linked to any supplier can see all like he should
request = apply_request_middleware(rf.get("/"),
user=admin_user,
shop=shop)
assert get_supplier(request) is None
view.request = request
assert code1 in view.get_queryset()
assert code2 in view.get_queryset()
def test_product_campaigns_section(rf, admin_user):
shop = factories.get_default_shop()
supplier = factories.get_default_supplier()
product = factories.create_product("test",
shop=shop,
supplier=supplier,
default_price=10)
campaign1 = _create_active_campaign(shop, supplier, product)
campaign2 = _create_active_campaign(shop, None, product)
shop_staff_user = factories.create_random_user(is_staff=True)
shop.staff_members.add(shop_staff_user)
supplier_staff_user = factories.create_random_user(
username=supplier.identifier, is_staff=True)
shop.staff_members.add(supplier_staff_user)
supplier_provider = "shuup.testing.supplier_provider.UsernameSupplierProvider"
with override_settings(
SHUUP_ADMIN_SUPPLIER_PROVIDER_SPEC=supplier_provider):
request = apply_request_middleware(rf.get("/"), user=admin_user)
request.shop = shop
assert get_supplier(request) is None
context = ProductCampaignsSection.get_context_data(product, request)
assert context[shop]["basket_campaigns"].count() == 2
request = apply_request_middleware(rf.get("/"), user=shop_staff_user)
request.shop = shop
assert get_supplier(request) is None
context = ProductCampaignsSection.get_context_data(product, request)
assert context[shop]["basket_campaigns"].count() == 2
request = apply_request_middleware(rf.get("/"),
user=supplier_staff_user)
request.shop = shop
assert get_supplier(request) == supplier
context = ProductCampaignsSection.get_context_data(product, request)
assert context[shop]["basket_campaigns"].count() == 1
campaign1.supplier = None
campaign1.save()
context = ProductCampaignsSection.get_context_data(product, request)
assert context[shop]["basket_campaigns"].count() == 0
BasketCampaign.objects.update(supplier=supplier)
context = ProductCampaignsSection.get_context_data(product, request)
assert context[shop]["basket_campaigns"].count() == 2
def post(self, request, *args, **kwargs):
mapping = dict()
for field in request.POST.keys():
if field.startswith("remap["):
# remove the remap[] part
field_name = field.replace("remap[", "")[:-1]
mapping[field_name] = self.request.POST.getlist(field)
supplier = get_supplier(request)
shop = get_shop(request)
run_task(
"shuup.importer.tasks.import_file",
stored=True,
queue="data_import",
importer=request.GET["importer"],
import_mode=request.POST.get("import_mode")
or ImportMode.CREATE_UPDATE.value,
file_name=request.GET["n"],
language=request.GET.get("lang"),
shop_id=shop.pk,
supplier_id=supplier.pk if supplier else None,
user_id=request.user.pk,
mapping=mapping,
)
messages.success(request, _("The import was queued!"))
return redirect(reverse("shuup_admin:importer.import"))
def dispatch(self, request, *args, **kwargs):
self.importer_cls = get_importer(request.GET.get("importer"))
self.model_str = request.GET.get("importer")
self.lang = request.GET.get("lang")
self.supplier = get_supplier(request)
return super(ImportProcessView, self).dispatch(request, *args,
**kwargs)
def get_queryset(self):
# get coupons for this shop or for shared shops
queryset = super(CouponEditView, self).get_queryset().filter(shop=get_shop(self.request))
supplier = get_supplier(self.request)
if supplier:
queryset = queryset.filter(supplier=supplier)
return queryset
def form_valid(self, form):
order = self.object
supplier = get_supplier(self.request)
refund_lines = []
for refund in form.cleaned_data:
line = self._get_refund_line_info(order, refund, supplier)
if line:
refund_lines.append(line)
try:
order.create_refund(refund_lines,
created_by=self.request.user,
supplier=supplier)
except RefundExceedsAmountException:
messages.error(self.request,
_("Refund amount exceeds order amount."))
return self.form_invalid(form)
except InvalidRefundAmountException:
messages.error(
self.request,
_("Refund amounts should match sign on parent line."))
return self.form_invalid(form)
messages.success(self.request, _("Refund created."))
return HttpResponseRedirect(get_model_url(order))
def get_context_data(self, **kwargs):
context = super(OrderCreateRefundView, self).get_context_data(**kwargs)
context["title"] = _("Create Refund -- %s") % context["order"]
context["toolbar"] = Toolbar([
PostActionButton(
icon="fa fa-check-circle",
form_id="create_refund",
text=_("Create Refund"),
extra_css_class="btn-success",
)
], view=self)
# Allowing full refunds for suppliers would block the refunds for
# rest of the suppliers since full refund can only be created once
supplier = context["supplier"] = get_supplier(self.request)
if not supplier:
context["toolbar"].append(
URLActionButton(
url=reverse("shuup_admin:order.create-full-refund", kwargs={"pk": self.object.pk}),
icon="fa fa-dollar",
text=_("Refund Entire Order"),
extra_css_class="btn-info",
disable_reason=_("This order already has existing refunds") if self.object.has_refunds() else None
)
)
# Setting the line_numbers choices dynamically creates issues with the blank formset,
# So adding that to the context to be rendered manually
context["line_number_choices"] = self._get_line_number_choices(supplier)
lines = lines = self.object.lines.all()
if supplier:
lines = lines.filter(supplier=supplier)
context["json_line_data"] = [self._get_line_data(self.object, line) for line in lines]
return context
def process_view(self, request, view_func, view_args, view_kwargs):
# have you forgot to customize this?
assert self.onboarding_process_id
# user not authenticated
if not request.user.is_authenticated():
return
# not admin view
if not request.resolver_match.view_name or request.resolver_match.app_name != "shuup_admin":
return
# ignore this view
if request.resolver_match.view_name in self.allowed_views:
return
# ignore this view too
if request.resolver_match.view_name in settings.SHUUP_ONBOARDING_MIDDLEWARE_IGNORE_VIEWS:
return
storage = OnboardingSessionStorage(self.onboarding_process_id,
request.session)
onboarding_context = OnboardingContext(storage=storage,
shop=get_shop(request),
supplier=get_supplier(request),
user=request.user)
onboarding = get_onboarding_provider().get_onboarding(
self.onboarding_process_id, onboarding_context)
# steps missing, redirect to the onboard process
if onboarding.get_current_step():
return HttpResponseRedirect(
reverse("shuup_admin:onboarding.onboard",
kwargs=dict(process_id=self.onboarding_process_id)))
def get_queryset(self):
# get coupons for this shop or for shared shops
queryset = super(CouponEditView, self).get_queryset().filter(shop=get_shop(self.request))
supplier = get_supplier(self.request)
if supplier:
queryset = queryset.filter(supplier=supplier)
return queryset
def __init__(self, *args, **kwargs):
super(BasketCampaignForm, self).__init__(*args, **kwargs)
coupons = Coupon.objects.filter(
Q(active=True, shop=get_shop(self.request)),
Q(campaign=None) | Q(campaign=self.instance),
)
supplier = get_supplier(self.request)
if supplier:
coupons = coupons.filter(supplier=supplier)
coupon_code_choices = [('', '')] + list(
coupons.values_list("pk", "code"))
field_kwargs = dict(choices=coupon_code_choices, required=False)
field_kwargs["help_text"] = _(
"Define the required coupon for this campaign.")
field_kwargs["label"] = _("Coupon")
field_kwargs["widget"] = QuickAddCouponSelect(
editable_model="campaigns.Coupon")
if self.instance.pk and self.instance.coupon:
field_kwargs["initial"] = self.instance.coupon.pk
self.fields["coupon"] = forms.ChoiceField(**field_kwargs)
# the supplier will be, by default, the current one
if supplier:
self.fields["supplier"].widget = forms.HiddenInput()
def get_queryset(self, *args, **kwargs):
queryset = Supplier.objects.filter(shops=get_shop(self.request)).not_deleted()
supplier = get_supplier(self.request)
if supplier:
# If admin has supplier enabled allow only delete self
# althought not good view to enable for vendor
queryset = queryset.filter(id=supplier.pk)
return queryset
def get_queryset(self):
queryset = super(ProductVariationVariableValueDetailView,
self).get_queryset()
supplier = get_supplier(self.request)
if supplier:
queryset = queryset.filter(
variable__product__shop_products__suppliers=supplier)
return queryset
def get_help_context_data(cls, request):
from shuup.admin.shop_provider import get_shop
from shuup.admin.supplier_provider import get_supplier
return {
"has_media_browse_permission": has_permission(request.user, "media.browse"),
"supplier": get_supplier(request) or Supplier.objects.enabled(shop=get_shop(request)).first(),
}
def get_queryset(self):
queryset = super().get_queryset().exclude(
status=ShipmentStatus.DELETED).select_related(
"order", "order__shipping_method")
supplier = get_supplier(self.request)
if supplier:
queryset = queryset.filter(supplier=supplier)
return queryset
def get_queryset(self):
queryset = Product.objects.filter(
shop_products__shop=get_shop(self.request))
supplier = get_supplier(self.request)
if supplier:
queryset = queryset.filter(shop_products__suppliers=supplier)
return queryset.distinct()
def get_queryset(self):
qs = super(ProductEditView, self).get_queryset().filter(shop=get_shop(self.request))
supplier = get_supplier(self.request)
if supplier:
qs = qs.filter(suppliers=supplier)
return qs
def get_context_data(self, **kwargs):
context = super(ProductEditView, self).get_context_data(**kwargs)
orderability_errors = []
shop = get_shop(self.request)
if self.object.pk:
context["title"] = self.object.product.name
try:
shop_product = self.object
orderability_errors.extend([
"%s: %s" % (shop.name, msg.message)
for msg in shop_product.get_orderability_errors(
supplier=None,
quantity=shop_product.minimum_purchase_quantity,
customer=None)
])
except ObjectDoesNotExist:
orderability_errors.extend([
"Error! %s: %s" %
(shop.name, _("Product is not available."))
])
product_validator_provides = sorted(
get_provide_objects("admin_product_validator"),
key=lambda provides: provides.ordering)
context["bleach"] = bleach
validation_issues = []
for admin_product_validator in product_validator_provides:
for validation_issue in admin_product_validator.get_validation_issues(
shop_product=self.object,
shop=shop,
user=self.request.user,
supplier=get_supplier(self.request)):
if validation_issue:
validation_issues.append(validation_issue)
context["validation_issues"] = sorted(
validation_issues, key=lambda x: x.get_issue_type_priority())
context["orderability_errors"] = orderability_errors
context["product_sections"] = []
context["tour_key"] = "product"
context["tour_complete"] = is_tour_complete(get_shop(self.request),
"product",
user=self.request.user)
product_sections_provides = sorted(
get_provide_objects("admin_product_section"),
key=lambda x: x.order)
for admin_product_section in product_sections_provides:
if admin_product_section.visible_for_object(
self.object.product, self.request):
context["product_sections"].append(admin_product_section)
context[admin_product_section.
identifier] = admin_product_section.get_context_data(
self.object.product, self.request)
return context
def get_queryset(self):
queryset = super(CouponListView, self).get_queryset()
if not self.request.user.is_superuser:
queryset = queryset.filter(shop=get_shop(self.request))
supplier = get_supplier(self.request)
if supplier:
queryset = queryset.filter(supplier=supplier)
return queryset
def get(self, request, *args, **kwargs):
shop_product = self.get_object()
current_supplier = None if request.user.is_superuser else get_supplier(request)
cloner = cached_load("SHUUP_ADMIN_PRODUCT_CLONER")(request.shop, current_supplier)
copied_shop_product = cloner.clone_product(shop_product=shop_product)
messages.success(
request, _("{product_name} was successfully copied".format(product_name=copied_shop_product.product))
)
return HttpResponseRedirect(self.get_success_url(copied_shop_product))
def get_queryset(self):
queryset = super(CouponListView, self).get_queryset()
if not self.request.user.is_superuser:
queryset = queryset.filter(shop=get_shop(self.request))
supplier = get_supplier(self.request)
if supplier:
queryset = queryset.filter(supplier=supplier)
return queryset
def get_queryset(self, *args, **kwargs):
queryset = super(PageDeleteView, self).get_queryset()
queryset = queryset.for_shop(get_shop(self.request)).not_deleted()
supplier = get_supplier(self.request)
if supplier:
queryset = queryset.filter(supplier=supplier)
return queryset
def get_form(self, form_class=None):
formset = super(OrderCreateRefundView, self).get_form(form_class)
# Line orderings are zero-indexed, but shouldn't display that way
choices = self._get_line_number_choices(get_supplier(self.request))
for form in formset.forms:
form.fields["line_number"].choices = choices
formset.empty_form.fields["line_number"].choices = choices
return formset
def get_admin_snippets(place: str, request: HttpRequest):
shop = get_shop(request)
supplier = get_supplier(request)
for admin_template_injector in get_provide_objects("admin_template_injector"):
snippet = admin_template_injector.get_admin_template_snippet(
place, shop=shop, user=request.user, supplier=supplier
)
if snippet:
yield snippet
def get_form(self, form_class=None):
formset = super(OrderCreateRefundView, self).get_form(form_class)
# Line orderings are zero-indexed, but shouldn't display that way
choices = self._get_line_number_choices(get_supplier(self.request))
for form in formset.forms:
form.fields["line_number"].choices = choices
formset.empty_form.fields["line_number"].choices = choices
return formset
def get_queryset(self):
qs = (super().get_queryset().filter(
shop=get_shop(self.request),
product__kind__in=self.get_listing_product_kinds_values()))
supplier = get_supplier(self.request)
if supplier:
qs = qs.filter(suppliers=supplier)
return qs
def test_campaign_list_for_suppliers(rf, admin_user):
"""
To make things little bit more simple let's use only english as
a language.
"""
shop = get_default_shop()
superuser1 = create_random_user(is_superuser=True, is_staff=True)
supplier1 = Supplier.objects.create(identifier=superuser1.username)
superuser2 = create_random_user(is_superuser=True, is_staff=True)
supplier2 = Supplier.objects.create(identifier=superuser2.username)
supplier_provider = "shuup.testing.supplier_provider.UsernameSupplierProvider"
with override_settings(LANGUAGES=[("en", "en")]):
with override_settings(SHUUP_ADMIN_SUPPLIER_PROVIDER_SPEC=supplier_provider):
campaign1 = BasketCampaign.objects.create(name="test campaign", active=True, shop=shop, supplier=supplier1)
campaign2 = BasketCampaign.objects.create(name="test campaign2", active=True, shop=shop, supplier=supplier2)
view = BasketCampaignListView()
request = apply_request_middleware(rf.get("/"), user=superuser1, shop=shop)
assert get_supplier(request) == supplier1
view.request = request
assert campaign1 in view.get_queryset()
assert campaign2 not in view.get_queryset()
request = apply_request_middleware(rf.get("/"), user=superuser2, shop=shop)
assert get_supplier(request) == supplier2
view.request = request
assert campaign1 not in view.get_queryset()
assert campaign2 in view.get_queryset()
# And actual superuser not linked to any supplier can see all like he should
request = apply_request_middleware(rf.get("/"), user=admin_user, shop=shop)
assert get_supplier(request) is None
view.request = request
assert campaign1 in view.get_queryset()
assert campaign2 in view.get_queryset()
def get_imports_queryset(request):
# get only executions from tasks inside `data_import` queue
queryset = BackgroundTaskExecution.objects.select_related(
"task", "task__user").filter(task__queue="data_import")
if not has_permission(request.user, "importer.show-all-imports"):
shop = get_shop(request)
supplier = get_supplier(request)
queryset = queryset.filter(
Q(Q(task__shop=shop) | Q(task__shop__isnull=True)),
Q(task__supplier=supplier),
)
return queryset
def get_context_data(cls, product, request=None):
ctx = {}
shop = get_shop(request)
try:
shop_product = product.get_shop_instance(shop)
basket_campaigns = BasketCampaign.get_for_product(shop_product)
supplier = get_supplier(request)
if supplier:
basket_campaigns = basket_campaigns.filter(supplier=supplier)
ctx[shop] = {"basket_campaigns": basket_campaigns}
return ctx
except ShopProduct.DoesNotExist:
return ctx
def visible_for_object(cls, product, request=None):
if not product.pk:
return False
shop = get_shop(request)
if not shop:
return False
shop_product = product.get_shop_instance(shop)
supplier = get_supplier(request)
if not supplier:
supplier = shop_product.suppliers.first()
if not supplier:
return False
if get_supplier(
request) is None and shop_product.suppliers.count() != 1:
return False
return (product.mode in [
ProductMode.VARIABLE_VARIATION_PARENT, ProductMode.VARIATION_CHILD,
ProductMode.NORMAL
])
def post(self, request, *args, **kwargs):
instance = self.get_object()
if not instance:
return JsonResponse(
{
"error": _("Product not found"),
"code": "product-not-found"
},
status=404)
try:
combinations = json.loads(request.body)
except (json.decoder.JSONDecodeError, TypeError):
return JsonResponse(
{
"error": _("Invalid content data"),
"code": "invalid-content"
},
status=400)
# use atomic here since the serializer can create the variation variables and values
with atomic():
serializer = ProductCombinationsSerializer(
data=dict(combinations=combinations),
context=dict(product=instance,
shop=get_shop(request),
supplier=get_supplier(request)))
if not serializer.is_valid():
return JsonResponse(
{
"error": serializer.errors,
"code": "validation-fail"
},
status=400)
try:
old_language = get_language()
activate(settings.PARLER_DEFAULT_LANGUAGE_CODE)
serializer.save()
activate(old_language)
except ValidationError as exc:
return JsonResponse({
"error": exc.message,
"code": exc.code
},
status=400)
return JsonResponse(serializer.validated_data)
def _filter_query(self, request, cls, qs, shop, search_mode=None):
# the supplier provider returned a valid supplier
# make sure to filter the search by the current supplier
supplier = get_supplier(request)
if search_mode == "visible" and issubclass(cls, Category):
qs = cls.objects.all_visible(self.request.customer,
shop=self.request.shop)
elif search_mode == "enabled" and issubclass(cls, Supplier):
qs = cls.objects.enabled(shop=shop)
elif hasattr(cls.objects, "all_except_deleted"):
qs = cls.objects.all_except_deleted(shop=shop)
elif hasattr(cls.objects, "get_for_user"):
qs = cls.objects.get_for_user(self.request.user)
if issubclass(cls, Product):
qs = qs.filter(shop_products__shop=shop)
if supplier:
qs = qs.filter(shop_products__suppliers=supplier)
related_fields = [
models.OneToOneField, models.ForeignKey, models.ManyToManyField
]
# Get all relation fields and check whether this models has
# relation to Shop mode, if so, filter by the current shop
allowed_shop_fields = ["shop", "shops"]
shop_related_fields = [
field for field in cls._meta.get_fields()
if type(field) in related_fields and field.related_model == Shop
and field.name in allowed_shop_fields
]
for shop_field in shop_related_fields:
qs = qs.filter(**{shop_field.name: shop})
if supplier:
allowed_supplier_fields = ["supplier", "suppliers"]
supplier_related_fields = [
field for field in cls._meta.get_fields()
if (type(field) in related_fields and field.related_model ==
Supplier and field.name in allowed_supplier_fields)
]
for supplier_field in supplier_related_fields:
qs = qs.filter(**{supplier_field.name: supplier})
return qs
def get_queryset(self):
filter = self.get_filter()
shop = get_shop(self.request)
qs = ShopProduct.objects.filter(product__deleted=False, shop=shop)
q = Q()
for mode in filter.get("modes", []):
q |= Q(product__mode=mode)
manufacturer_ids = filter.get("manufacturers")
if manufacturer_ids:
q |= Q(product__manufacturer_id__in=manufacturer_ids)
qs = qs.filter(q)
supplier = get_supplier(self.request)
if supplier:
qs = qs.filter(suppliers=supplier)
return qs
def _filter_query(self, request, cls, qs, shop, search_mode=None):
# the supplier provider returned a valid supplier
# make sure to filter the search by the current supplier
supplier = get_supplier(request)
if search_mode == "visible" and issubclass(cls, Category):
qs = cls.objects.all_visible(self.request.customer, shop=self.request.shop)
elif search_mode == "enabled" and issubclass(cls, Supplier):
qs = cls.objects.enabled()
elif hasattr(cls.objects, "all_except_deleted"):
qs = cls.objects.all_except_deleted(shop=shop)
elif hasattr(cls.objects, "get_for_user"):
qs = cls.objects.get_for_user(self.request.user)
if issubclass(cls, Product):
qs = qs.filter(shop_products__shop=shop)
if supplier:
qs = qs.filter(shop_products__suppliers=supplier)
related_fields = [models.OneToOneField, models.ForeignKey, models.ManyToManyField]
# Get all relation fields and check whether this models has
# relation to Shop mode, if so, filter by the current shop
allowed_shop_fields = ["shop", "shops"]
shop_related_fields = [
field
for field in cls._meta.get_fields()
if type(field) in related_fields and field.related_model == Shop and field.name in allowed_shop_fields
]
for shop_field in shop_related_fields:
qs = qs.filter(**{shop_field.name: shop})
if supplier:
allowed_supplier_fields = ["supplier", "suppliers"]
supplier_related_fields = [
field for field in cls._meta.get_fields()
if (type(field) in related_fields and
field.related_model == Supplier and
field.name in allowed_supplier_fields)
]
for supplier_field in supplier_related_fields:
qs = qs.filter(**{supplier_field.name: supplier})
return qs
def __init__(self, *args, **kwargs):
self.request = kwargs.pop("request")
super(CouponForm, self).__init__(*args, **kwargs)
if self.instance.pk and self.instance.has_been_used():
self.fields["code"].readonly = True
if self.request.GET.get("mode") == "iframe":
self.fields["active"].disabled = True
self.fields["active"].widget.disabled = True
if not self.request.user.is_superuser:
self.fields["shop"].widget = forms.HiddenInput()
self.fields["shop"].required = False
if get_supplier(self.request):
self.fields["supplier"].widget = forms.HiddenInput()
self.fields["supplier"].required = False
def form_valid(self, form):
order = self.object
supplier = get_supplier(self.request)
refund_lines = []
for refund in form.cleaned_data:
line = self._get_refund_line_info(order, refund, supplier)
if line:
refund_lines.append(line)
try:
order.create_refund(refund_lines, created_by=self.request.user, supplier=supplier)
except RefundExceedsAmountException:
messages.error(self.request, _("Refund amount exceeds order amount."))
return self.form_invalid(form)
except InvalidRefundAmountException:
messages.error(self.request, _("Refund amounts should match sign on parent line."))
return self.form_invalid(form)
messages.success(self.request, _("Refund created."))
return HttpResponseRedirect(get_model_url(order))
def test_admin_campaign_edit_view_works_with_supplier(rf, admin_user):
shop = get_default_shop()
supplier = Supplier.objects.create(identifier=admin_user.username)
view_func = BasketCampaignEditView.as_view()
request = apply_request_middleware(rf.get("/"), user=admin_user)
campaign = BasketCampaign.objects.create(name="test campaign", active=True, shop=shop)
response = view_func(request, pk=campaign.pk)
assert campaign.name in response.rendered_content
response = view_func(request, pk=None)
assert response.rendered_content
soup = BeautifulSoup(response.rendered_content)
assert soup.find("select", {"id": "id_base-supplier"})
supplier_provider = "shuup.testing.supplier_provider.UsernameSupplierProvider"
with override_settings(SHUUP_ADMIN_SUPPLIER_PROVIDER_SPEC=supplier_provider):
assert get_supplier(request) == supplier
response = view_func(request, pk=None)
assert response.rendered_content
soup = BeautifulSoup(response.rendered_content)
assert not soup.find("select", {"id": "id_base-supplier"})
def __init__(self, *args, **kwargs):
super(BasketCampaignForm, self).__init__(*args, **kwargs)
coupons = Coupon.objects.filter(
Q(active=True, shop=get_shop(self.request)),
Q(campaign=None) | Q(campaign=self.instance),
)
supplier = get_supplier(self.request)
if supplier:
coupons = coupons.filter(supplier=supplier)
coupon_code_choices = [('', '')] + list(coupons.values_list("pk", "code"))
field_kwargs = dict(choices=coupon_code_choices, required=False)
field_kwargs["help_text"] = _("Define the required coupon for this campaign.")
field_kwargs["label"] = _("Coupon")
field_kwargs["widget"] = QuickAddCouponSelect(editable_model="campaigns.Coupon")
if self.instance.pk and self.instance.coupon:
field_kwargs["initial"] = self.instance.coupon.pk
self.fields["coupon"] = forms.ChoiceField(**field_kwargs)
# the supplier will be, by default, the current one
if supplier:
self.fields["supplier"].widget = forms.HiddenInput()
def clean_supplier(self):
return self.cleaned_data.get("supplier") or get_supplier(self.request)
def get_queryset(self):
queryset = super(BasketCampaignEditView, self).get_queryset()
supplier = get_supplier(self.request)
if supplier:
queryset = queryset.filter(supplier=supplier)
return queryset
def get_admin_supplier(context):
return get_supplier(context["request"])
def test_refunds_with_multiple_suppliers(rf, admin_user):
shop = get_default_shop()
supplier1 = Supplier.objects.create(identifier="1", name="supplier1")
supplier1.shops.add(shop)
supplier2 = Supplier.objects.create(identifier="2")
supplier2.shops.add(shop)
supplier3 = Supplier.objects.create(identifier="3", name="s")
supplier3.shops.add(shop)
product1 = create_product("sku1", shop=shop, default_price=10)
shop_product1 = product1.get_shop_instance(shop=shop)
shop_product1.suppliers = [supplier1, supplier2, supplier3]
product2 = create_product("sku2", shop=shop, default_price=10)
shop_product2 = product1.get_shop_instance(shop=shop)
shop_product2.suppliers = [supplier1, supplier2]
product3 = create_product("sku3", shop=shop, default_price=10, shipping_mode=ShippingMode.NOT_SHIPPED)
shop_product3 = product1.get_shop_instance(shop=shop)
shop_product3.suppliers = [supplier3]
product_quantities = {
supplier1: {
product1: 5,
product2: 6
},
supplier2: {
product1: 3,
product2: 13
},
supplier3: {
product1: 1,
product3: 50
}
}
def get_quantity(supplier, product):
return product_quantities[supplier.pk][product.pk]
order = create_empty_order(shop=shop)
order.full_clean()
order.save()
for supplier, product_data in six.iteritems(product_quantities):
for product, quantity in six.iteritems(product_data):
add_product_to_order(order, supplier, product, quantity, 5)
order.cache_prices()
order.create_payment(order.taxful_total_price)
assert order.is_paid()
# All supplier should be able to refund the order
assert order.can_create_refund()
assert order.can_create_refund(supplier1)
assert order.can_create_refund(supplier2)
assert order.can_create_refund(supplier3)
assert not order.has_refunds()
assert len(order.lines.all()) == 6
product_line = order.lines.first()
data = {
"form-0-line_number": 0,
"form-0-quantity": 1,
"form-0-amount": 1,
"form-0-restock_products": False,
"form-INITIAL_FORMS": 0,
"form-MAX_NUM_FORMS": 1000,
"form-TOTAL_FORMS": 1,
"form-MIN_NUM_FORMS": 0,
}
supplier_provider = "shuup.testing.supplier_provider.RequestSupplierProvider"
with override_settings(SHUUP_ADMIN_SUPPLIER_PROVIDER_SPEC=supplier_provider):
# Test refund view content as superuser
request = apply_request_middleware(rf.get("/", data=data), user=admin_user)
view = OrderCreateRefundView.as_view()
response = view(request, pk=order.pk)
assert response.status_code == 200
if hasattr(response, "render"):
response.render()
soup = BeautifulSoup(response.content)
_assert_order_table_row_count(soup, 6)
_assert_order_mobile_list_row_count(soup, 6)
assert _get_create_full_refund_button(soup) is not None
# Test refund view content as supplier 1
request = apply_request_middleware(rf.get("/", data=data), user=admin_user)
request.supplier = supplier1
assert get_supplier(request) == supplier1
view = OrderCreateRefundView.as_view()
response = view(request, pk=order.pk)
assert response.status_code == 200
if hasattr(response, "render"):
response.render()
soup = BeautifulSoup(response.content)
_assert_order_table_row_count(soup, 2)
_assert_order_mobile_list_row_count(soup, 2)
assert _get_create_full_refund_button(soup) is None
# Test refund view content as supplier 2 user
request = apply_request_middleware(rf.get("/", data=data), user=admin_user)
request.supplier = supplier2
assert get_supplier(request) == supplier2
view = OrderCreateRefundView.as_view()
response = view(request, pk=order.pk)
assert response.status_code == 200
if hasattr(response, "render"):
response.render()
soup = BeautifulSoup(response.content)
_assert_order_table_row_count(soup, 2)
_assert_order_mobile_list_row_count(soup, 2)
assert _get_create_full_refund_button(soup) is None
