def is_url_valid(self, language_code, field_name, url):
"""
Ensure URL given is unique.
Check through the pages translation model objects to make
sure that the url given doesn't already exist.
Possible failure cases:
for new page:
* URL already exists
for existing page:
* URL (other than owned by existing page) exists
* URL exists in other languages of existing page
"""
pages_ids = Page.objects.for_shop(get_shop(self.request)).values_list(
"id", flat=True)
qs = self._get_translation_model().objects.filter(
url=url, master_id__in=pages_ids)
if not self.instance.pk:
if qs.exists():
return False
other_qs = qs.exclude(master=self.instance)
if other_qs.exists():
return False
own_qs = qs.filter(master=self.instance).exclude(
language_code=language_code)
if own_qs.exists():
return False
return True
def handle_upload(self):
request = self.request
shop = get_shop(request)
try:
folder_id = int(request.POST.get("folder_id") or request.GET.get("folder_id") or 0)
path = request.POST.get("path") or request.GET.get("path") or None
if folder_id != 0:
folder = _get_folder_query(shop).get(pk=folder_id)
elif path:
folder = get_or_create_folder(shop, path)
else:
folder = None # Root folder upload. How bold!
except Exception as exc:
return JsonResponse({"error": "Invalid folder: %s" % force_text(exc)})
try:
upload_file = request.FILES["file"]
if upload_file.content_type.startswith("image/"):
filer_file = filer_image_from_upload(request, path=folder, upload_data=upload_file)
_ensure_media_file(shop, filer_file)
else:
filer_file = filer_file_from_upload(request, path=folder, upload_data=upload_file)
_ensure_media_file(shop, filer_file)
except Exception as exc:
return JsonResponse({"error": force_text(exc)})
return JsonResponse({
"file": _filer_file_to_json_dict(filer_file),
"message": _("%(file)s uploaded to %(folder)s") % {
"file": filer_file.label,
"folder": get_folder_name(folder)
}
})
def __init__(self, **kwargs):
self.request = kwargs.pop("request")
kwargs.setdefault("required_languages",
()) # No required languages here
super(PageForm, self).__init__(**kwargs)
self.fields["parent"].queryset = Page.objects.filter(
shop=get_shop(self.request))
def post(self, request):
"""
Create the Script from template directly if the template does not have a bound form.
If the script template has a bound form, redirect to the template configuration view.
If no script template is found, redirect to the script list.
"""
identifier = request.POST.get("id", None)
script_template_class = get_identifier_to_object_map(SCRIPT_TEMPLATES_PROVIDE_CATEGORY).get(identifier)
if script_template_class:
script_template = script_template_class()
# the template has a form for configuration.. lets redirect to the correct view
if script_template.get_form():
return redirect("wshop_admin:notify.script-template-config", id=identifier)
else:
shop = get_shop(request)
script = script_template.create_script(shop)
if script:
script.template = identifier
script.save(update_fields=["template"])
messages.success(request, _("Script created from template!"))
return redirect("wshop_admin:notify.script.list")
else:
messages.error(request, _("Template Script not found!"))
return redirect("wshop_admin:notify.script.list")
def handle_get_folder(self, data):
shop = get_shop(self.request)
try:
folder_id = int(data.get("id", 0))
if folder_id:
folder = _get_folder_query(shop).get(pk=folder_id)
subfolders = folder.get_children().filter(_get_folder_query_filter(shop))
files = _get_file_query(shop, folder)
else:
folder = None
subfolders = _get_folder_query(shop).filter(parent=None)
files = _get_file_query(shop).filter(folder=None)
except ObjectDoesNotExist:
return JsonResponse({
"folder": None,
"error": "Folder does not exist"
})
if self.filter == "images":
files = files.instance_of(Image)
return JsonResponse({"folder": {
"id": folder.id if folder else 0,
"name": get_folder_name(folder),
"files": [_filer_file_to_json_dict(file) for file in files if file.is_public],
"folders": [
# Explicitly pass empty list of children to avoid recursion
_filer_folder_to_json_dict(subfolder, children=())
for subfolder in subfolders.order_by("name")
]
}})
def handle_post_delete_folder(self, data):
shop = get_shop(self.request)
folder = _get_folder_query(shop).get(pk=data["id"])
if _is_folder_shared(folder):
message = _("Can not delete shared folder.")
return JsonResponse({"success": False, "message": message})
new_selected_folder_id = folder.parent_id
message = delete_folder(folder)
return JsonResponse({"success": True, "message": message, "newFolderId": new_selected_folder_id})
def handle_post_rename_file(self, data):
shop = get_shop(self.request)
file = _get_file_query(shop).get(pk=data["id"])
if _is_file_shared(file):
message = _("Can not rename shared file.")
return JsonResponse({"success": False, "message": message})
file.name = data["name"]
file.save(update_fields=("name",))
return JsonResponse({"success": True, "message": _("File renamed.")})
def mark_notification_read_view(self, request, pk):
shop = get_shop(request)
if request.method == "POST":
try:
notif = NotificationModel.objects.for_user(
request.user).filter(shop=shop).get(pk=pk)
except ObjectDoesNotExist:
return JsonResponse({"error": "no such notification"})
notif.mark_read(request.user)
return JsonResponse({"ok": True})
return JsonResponse({"error": "POST only"})
def populate(self):
super(CarouselConfigForm, self).populate()
self.fields["carousel"] = XThemeModelChoiceField(
label=_("Carousel"),
queryset=Carousel.objects.filter(shops=get_shop(self.request)),
required=False,
)
self.fields["active"] = BooleanField(
label=_("Active"),
required=False,
)
def handle_post_delete_file(self, data):
shop = get_shop(self.request)
file = _get_file_query(shop).get(pk=data["id"])
if _is_file_shared(file):
message = _("Can not delete shared file.")
return JsonResponse({"success": False, "message": message})
try:
file.delete()
except IntegrityError as ie:
raise Problem(str(ie))
return JsonResponse({"success": True, "message": _("File deleted.")})
def __init__(self, request, **kwargs):
self.request = request
super(CategoryBaseForm, self).__init__(**kwargs)
# Exclude `DELETED`. We don't want people to use that field to set a category as deleted.
filter_form_field_choices(self.fields["status"], (CategoryStatus.DELETED.value,), invert=True)
# Exclude current category from parents, because it cannot be its own child anyways
category_queryset = Category.objects.filter(shops=get_shop(request)).exclude(status=CategoryStatus.DELETED)
self.fields["parent"].queryset = category_queryset
self.fields["parent"].choices = [(None, "----")] + [
(category.pk, category.name) for category in category_queryset.exclude(id=kwargs["instance"].pk)
]
def form_valid(self, form):
"""
Create the script from the template using the configuration from the form.
"""
shop = get_shop(self.request)
script_template = self._get_script_template_class()()
script = script_template.create_script(shop, form)
if script:
script.template = self.kwargs["id"]
script.save(update_fields=["template"])
messages.success(self.request, _("Script created from template!"))
return redirect("wshop_admin:notify.script.list")
def test_product_module_search(rf, admin_user):
get_default_shop()
request = apply_request_middleware(rf.get("/"), user=admin_user)
with replace_modules([CategoryModule, ImportAdminModule, ProductModule,
ProductTypeModule, ManufacturerModule, PaymentMethodModule, ShippingMethodModule]):
with admin_only_urls():
default_product = get_default_product()
model_url = get_model_url(default_product, shop=get_shop(request))
sku = default_product.sku
assert any(sr.url == model_url for sr in get_search_results(request, query=sku)) # Queries work
assert any(sr.is_action for sr in get_search_results(request, query=sku[:5])) # Actions work
assert empty_iterable(get_search_results(request, query=sku[:2])) # Short queries don't
def save(self, commit=True):
is_superuser = getattr(self.request.user, "is_superuser", False)
# do not let any user to change shared Manufacturers
if self.instance.pk and self.instance.shops.count(
) == 0 and not is_superuser:
raise forms.ValidationError(
_("You have no permission to change a shared Manufacturer."))
instance = super(ManufacturerForm, self).save(commit)
# if shops field is not available and it is a new manufacturer, set the current shop
if not settings.WSHOP_ENABLE_MULTIPLE_SHOPS or "shops" not in self.fields:
instance.shops.add(get_shop(self.request))
return instance
def handle_post_new_folder(self, data):
shop = get_shop(self.request)
parent_id = int(data.get("parent", 0))
if parent_id > 0:
parent = _get_folder_query(shop).get(pk=parent_id)
else:
parent = None
name = data["name"]
folder = Folder.objects.create(name=name)
if parent:
folder.move_to(parent, "last-child")
folder.save()
_ensure_media_folder(shop, folder)
return JsonResponse({"success": True, "folder": _filer_folder_to_json_dict(folder, ())})
def get_notifications(self, request):
shop = get_shop(request)
notif_qs = NotificationModel.objects.unread_for_user(
request.user).filter(shop=shop).order_by("-id")[:15]
for notif in notif_qs:
if notif.priority == Priority.HIGH:
kind = "warning"
elif notif.priority == Priority.CRITICAL:
kind = "danger"
else:
kind = "info"
yield Notification(text=notif.message,
url=notif.url,
kind=kind,
dismissal_url=reverse(
"wshop_admin:notify.mark-read",
kwargs={"pk": notif.pk}),
datetime=notif.created_on)
def handle_post_move_file(self, data):
shop = get_shop(self.request)
file = _get_file_query(shop).get(pk=data["file_id"])
if _is_file_shared(file):
message = _("Can not move shared file.")
return JsonResponse({"success": False, "message": message})
folder_id = int(data["folder_id"])
if folder_id:
folder = _get_folder_query(shop).get(pk=data["folder_id"])
else:
folder = None
old_folder = file.folder
file.folder = folder
file.save(update_fields=("folder",))
return JsonResponse({
"success": True,
"message": _("%(file)s moved from %(old)s to %(new)s.") % {
"file": file,
"old": get_folder_name(old_folder),
"new": get_folder_name(folder)
}
})
def form_valid(self, form):
self.object = form[self.name].save()
self.object.shops.add(get_shop(self.request))
return self.object
def get_queryset(self):
return super(ScriptEditView, self).get_queryset().filter(shop=get_shop(self.request))
def get_form_kwargs(self):
kwargs = super(ScriptEditView, self).get_form_kwargs()
kwargs["shop"] = get_shop(self.request)
return kwargs
def get_queryset(self):
return super(PageListView,
self).get_queryset().for_shop(get_shop(self.request))
def save(self, commit=True):
if not hasattr(self.instance, "shop") or not self.instance.shop:
self.instance.shop = get_shop(self.request)
return super(PageForm, self).save(commit)
def process_view(self, request, view_func, view_args, view_kwargs):
# we only care about Wshop Admin requests
if request.resolver_match.app_name == "wshop_admin":
shop = get_shop(request)
if shop:
request.shop = shop
def get_queryset(self):
return super(CarouselListView,
self).get_queryset().filter(shops=get_shop(self.request))
def get_queryset(self):
return Manufacturer.objects.filter(
Q(shops=get_shop(self.request)) | Q(shops__isnull=True))
def handle_get_folders(self, data):
shop = get_shop(self.request)
root_folders = get_cached_trees(Folder._tree_manager.filter(_get_folder_query_filter(shop)))
return JsonResponse({"rootFolder": _filer_folder_to_json_dict(None, root_folders)})
