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
