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