def get_object(self): basket_class = cached_load("WSHOP_BASKET_CLASS_SPEC") shop = self.request.shop uuid = get_key(self.kwargs.get(self.lookup_field, "")) storage = get_storage() if not storage.basket_exists(uuid, shop): raise exceptions.NotFound() basket = basket_class(self.request._request, basket_name=uuid) try: basket._data = basket.storage.load(basket) except BasketCompatibilityError as error: raise exceptions.ValidationError(str(error)) # ensure correct creator if not self.request.user.is_superuser: if not basket.shop == shop: raise exceptions.PermissionDenied("No permission") customer_id = (basket.customer.pk if basket.customer else None) controlled_contact_ids = self._get_controlled_contacts_by_user( self.request.user) is_staff = self.is_staff_user(shop, self.request.user) if customer_id and customer_id not in controlled_contact_ids and not is_staff: raise exceptions.PermissionDenied("No permission") return basket
def __init__(self, *args, **kwargs): super(CompanyRegistrationForm, self).__init__(*args, **kwargs) address_form_cls = cached_load('WSHOP_ADDRESS_MODEL_FORM') self.add_form_def('company', CompanyForm) self.add_form_def('billing', address_form_cls) self.add_form_def('contact_person', ContactPersonForm) self.add_form_def('user_account', UserCreationForm)
def new(self, request, *args, **kwargs): """ Create a brand new basket object """ serializer = NewBasketSerializer(data=request.data) serializer.is_valid(True) data = serializer.validated_data self.process_request(with_basket=False, shop=data.get("shop")) basket_class = cached_load("WSHOP_BASKET_CLASS_SPEC") basket = basket_class(request._request) if "customer" in data: customer = data["customer"] else: customer = get_company_contact(request.user) or get_person_contact( request.user) orderer = data.get("orderer", get_person_contact(request.user)) # set the request basket to perform the basket command self.request.basket = basket self._handle_set_customer(request=self.request._request, basket=basket, customer=customer, orderer=orderer) stored_basket = basket.save() response_data = { "uuid": "%s-%s" % (request.shop.pk, stored_basket.key) } response_data.update(self.get_serializer(basket).data) return Response(data=response_data, status=status.HTTP_201_CREATED)
def get_form(self, form_class): user = self.request.user company = get_company_contact(user) person = get_person_contact(user) form_group = FormGroup(**self.get_form_kwargs()) address_form_class = cached_load("WSHOP_ADDRESS_MODEL_FORM") form_group.add_form_def("billing", address_form_class, kwargs={ "instance": _get_default_address_for_contact( company, "default_billing_address", person) }) form_group.add_form_def("shipping", address_form_class, kwargs={ "instance": _get_default_address_for_contact( company, "default_shipping_address", person) }) form_group.add_form_def("contact", CompanyContactForm, kwargs={"instance": company}) return form_group
def get_basket(request, basket_name="basket", basket_class=None): """ Get the basket cached in the request or create and cache a new one. The basket_class is used when creating a new basket, i.e. when the request doesn't already have a basket cached with the given name. If no basket_class is given, will load a class using the `~wshop.front.settings.WSHOP_BASKET_CLASS_SPEC` setting. :type request: django.http.request.HttpRequest :type basket_name: str :type basket_class: type|None :rtype: wshop.front.basket.objects.BaseBasket """ basket = _get_basket_from_request(request, basket_name) if basket: return basket if basket_class is None: basket_class = cached_load("WSHOP_BASKET_CLASS_SPEC") basket = basket_class(request, basket_name=basket_name) _save_basket_to_request(request, basket_name, basket) return basket
def handle_update(request, basket, **kwargs): """ Handle updating a basket, i.e. deleting some lines or updating quantities. This dispatches further to whatever is declared by the `WSHOP_BASKET_UPDATE_METHODS_SPEC` configuration entry. """ methods = cached_load("WSHOP_BASKET_UPDATE_METHODS_SPEC")(request=request, basket=basket) prefix_method_dict = methods.get_prefix_to_method_map() basket_changed = False # If any POST items match a prefix defined in prefix_method_dict, call the appropriate model method. for key, value in six.iteritems(kwargs): for prefix, method in six.iteritems(prefix_method_dict): if key.startswith(prefix): line_id = key[len(prefix):] line = basket.find_line_by_line_id(line_id) field_changed = method( key=key, value=value, line=line ) basket_changed = (basket_changed or field_changed) break if basket_changed: # pragma: no branch basket.clean_empty_lines() basket.dirty = True basket.uncache()
def get_storage(): """ Retrieve a basket storage object. :return: A basket storage object :rtype: BasketStorage """ storage_class = cached_load("WSHOP_BASKET_STORAGE_CLASS_SPEC") return storage_class()
def __init__(self, *args, **kwargs): super(CompanyForm, self).__init__(*args, **kwargs) self.fields['name'].required = True self.fields['tax_number'].required = True address_form = cached_load('WSHOP_ADDRESS_MODEL_FORM')() for field in self.fields: if field not in ('name', 'tax_number', 'www'): address_formfield = address_form.fields.get(field) if address_formfield: self.fields[field].required = address_formfield.required else: del self.fields[field]
def get_supplier(self, customer=None, quantity=None, shipping_address=None): supplier_strategy = cached_load( "WSHOP_SHOP_PRODUCT_SUPPLIERS_STRATEGY") kwargs = { "shop_product": self, "customer": customer, "quantity": quantity, "shipping_address": shipping_address } return supplier_strategy().get_supplier(**kwargs)
def get_form(self, form_class): contact = get_person_contact(self.request.user) form_group = FormGroup(**self.get_form_kwargs()) address_form_class = cached_load("WSHOP_ADDRESS_MODEL_FORM") form_group.add_form_def( "billing", address_form_class, kwargs={"instance": contact.default_billing_address}) form_group.add_form_def( "shipping", address_form_class, kwargs={"instance": contact.default_shipping_address}) form_group.add_form_def("contact", PersonContactForm, kwargs={"instance": contact}) return form_group
def get_form(self, form_class): fg = FormGroup(**self.get_form_kwargs()) default_address_form_class = cached_load("WSHOP_ADDRESS_MODEL_FORM") for kind in self.address_kinds: fg.add_form_def(kind, form_class=self.address_form_classes.get( kind, default_address_form_class)) fg.add_form_def("saved_{}".format(kind), form_class=SavedAddressForm, required=False, kwargs={ "kind": kind, "owner": self.basket.customer }) if self.company_form_class and not self.request.customer: fg.add_form_def("company", self.company_form_class, required=False) return fg
def get_form(self, form_class): form_group = FormGroup(**self.get_form_kwargs()) address_kwargs = {} saved_address_kwargs = {} if self.instance: address_kwargs["instance"] = self.instance.address saved_address_kwargs["initial"] = { "role": self.instance.role, "status": self.instance.status, "title": self.instance.title, } form_group.add_form_def("address", cached_load("WSHOP_ADDRESS_MODEL_FORM"), kwargs=address_kwargs) form_group.add_form_def("saved_address", SavedAddressForm, kwargs=saved_address_kwargs) return form_group
def get_form(self, form_class=None): order = self.get_object() form_group = FormGroup(**self.get_form_kwargs()) address_form_class = cached_load("WSHOP_ADDRESS_MODEL_FORM") form_group.add_form_def("billing_address", address_form_class, kwargs={ "initial": get_data_dict(order.billing_address) if order.billing_address else {} }) form_group.add_form_def("shipping_address", address_form_class, kwargs={ "initial": get_data_dict(order.shipping_address) if order.shipping_address else {} }) return form_group
def get_form_defs(self): initial = { } # TODO: should we do this? model_to_dict(self.object, AddressForm._meta.fields) address_form_class = cached_load("WSHOP_ADDRESS_MODEL_FORM") yield FormDef(name="shipping_address", form_class=address_form_class, required=False, kwargs={ "instance": self.object.default_shipping_address, "initial": initial }) yield FormDef(name="billing_address", form_class=address_form_class, required=False, kwargs={ "instance": self.object.default_billing_address, "initial": initial }) # Using a pseudo formdef to group the two actual formdefs... yield TemplatedFormDef( name="addresses", form_class=forms.Form, required=False, template_name="wshop/admin/contacts/_edit_addresses_form.jinja")
def get_basket_command_dispatcher(request): """ :type request: django.http.request.HttpRequest :rtype: wshop.front.basket.command_dispatcher.BasketCommandDispatcher """ return cached_load("WSHOP_BASKET_COMMAND_DISPATCHER_SPEC")(request=request)
def get_shop_provider(): return cached_load("WSHOP_ADMIN_SHOP_PROVIDER_SPEC")()
def get_modules(): """ :rtype: list[wshop.admin.base.AdminModule] """ get_modules_spec = cached_load("WSHOP_GET_ADMIN_MODULES_SPEC") return get_modules_spec()
def get_basket_order_creator(request=None): return cached_load("WSHOP_BASKET_ORDER_CREATOR_SPEC")(request=request)
def as_string_list(self, locale=None): formatter = cached_load("WSHOP_ADDRESS_FORMATTER_SPEC") return formatter().address_as_string_list(self, locale)
def get_shop(request, **kwargs): return cached_load("WSHOP_REQUEST_SHOP_PROVIDER_SPEC").get_shop( request, **kwargs)
def get_basket_view(): view = cached_load("WSHOP_BASKET_VIEW_SPEC") if hasattr(view, "as_view"): # pragma: no branch view = view.as_view() return view
def get_checkout_view(): view = cached_load("WSHOP_CHECKOUT_VIEW_SPEC") if hasattr(view, "as_view"): # pragma: no branch view = view.as_view() return view