class OrderStatusListView(PicotableListView): model = OrderStatus default_columns = [ Column("identifier", _("Identifier"), linked=True, filter_config=TextFilter(operator="startswith")), Column("name", _("Name"), linked=True, filter_config=TextFilter(operator="startswith")), Column("public_name", _("Public Name"), linked=False, filter_config=TextFilter(operator="startswith")), Column("role", _("Role"), linked=False, filter_config=ChoicesFilter(choices=OrderStatusRole.choices)), Column("default", _("Default"), linked=False, filter_config=ChoicesFilter([(False, _("yes")), (True, _("no"))])), Column("is_active", _("Active"), linked=False, filter_config=ChoicesFilter([(False, _("yes")), (True, _("no"))])), ]
def get_pico(rf, model=None, columns=None): get_default_shop() model = model or get_user_model() columns = columns or [ Column("id", "Id", filter_config=Filter(), display=instance_id), Column("username", "Username", sortable=False, filter_config=MultiFieldTextFilter( filter_fields=("username", "email"), operator="iregex")), Column("email", "Email", sortable=False, filter_config=TextFilter()), Column("is_superuser", "Is Superuser", display="superuser_display", filter_config=ChoicesFilter(choices=false_and_true())), Column("is_active", "Is Active", filter_config=ChoicesFilter( choices=false_and_true)), # `choices` callable Column("date_joined", "Date Joined", filter_config=DateRangeFilter()) ] request = apply_request_middleware(rf.get("/")) return Picotable(request=request, columns=columns, mass_actions=[], queryset=model.objects.all(), context=PicoContext(request))
def test_choice_filter_with_default(rf, admin_user, regular_user): columns = [ Column("id", "Id", filter_config=Filter(), display=instance_id), Column("username", "Username", sortable=False, filter_config=MultiFieldTextFilter(filter_fields=("username", "email"), operator="iregex")), Column("email", "Email", sortable=False, filter_config=TextFilter()), Column("is_superuser", "Is Superuser", display="superuser_display", filter_config=ChoicesFilter(choices=false_and_true())), Column("date_joined", "Date Joined", filter_config=DateRangeFilter()) ] is_active = [ Column("is_active", "Is Active", filter_config=ChoicesFilter(choices=false_and_true)) ] is_active_with_default = [ Column("is_active", "Is Active", filter_config=ChoicesFilter(choices=false_and_true, default=True)) ] query = {"perPage": 100, "page": 1, "sort": "+id"} pico_no_defaults = get_pico(rf, columns=(columns + is_active)) data = pico_no_defaults.get_data(query) user_data = data["items"][0] user = get_user_model().objects.get(id=user_data["id"]) assert user.is_active pico_with_defaults = get_pico(rf, columns=(columns + is_active_with_default)) data = pico_with_defaults.get_data(query) user_data = data["items"][0] user_with_defaults = get_user_model().objects.get(id=user_data["id"]) assert user_with_defaults == user user.is_active = False user.save() data = pico_no_defaults.get_data(query) user_data = data["items"][0] new_user = get_user_model().objects.get(id=user_data["id"]) assert new_user == user data = pico_with_defaults.get_data(query) user_data = data["items"][0] new_user_with_defaults = get_user_model().objects.get(id=user_data["id"]) assert new_user_with_defaults != user_with_defaults
class CategoryListView(PicotableListView): model = Category default_columns = [ Column("image", _("Image"), sortable=False, linked=True, raw=True), Column("name", _(u"Name"), sortable=False, display="format_name", linked=True, filter_config=MPTTFilter(choices="get_name_filter_choices", filter_field="id")), Column("status", _(u"Status"), filter_config=ChoicesFilter( choices=CategoryStatus.choices, default=CategoryStatus.VISIBLE.value)), Column( "visibility", _(u"Visibility"), filter_config=ChoicesFilter(choices=CategoryVisibility.choices)), ] def get_name_filter_choices(self): choices = [] shop = self.request.shop for c in Category.objects.all_except_deleted(shop=shop): name = self.format_name(c) choices.append((c.pk, name)) return choices def get_queryset(self): return Category.objects.all_except_deleted(shop=self.request.shop) def format_name(self, instance, *args, **kwargs): level = getattr(instance, instance._mptt_meta.level_attr) return ('---' * level) + ' ' + instance.name def get_object_abstract(self, instance, item): return [ { "text": "%s" % instance, "class": "header" }, { "title": _(u"Status"), "text": item.get("status") }, ]
class ShopListView(PicotableListView): model = Shop default_columns = [ Column("logo", _(u"Logo"), display="logo", class_name="text-center", raw=True, ordering=1, sortable=False), Column("name", _(u"Name"), sort_field="translations__name", display="name", filter_config=TextFilter(filter_field="translations__name", placeholder=_("Filter by name..."))), Column("domain", _(u"Domain")), Column("identifier", _(u"Identifier")), Column("status", _(u"Status"), filter_config=ChoicesFilter(choices=ShopStatus.choices)), ] def get_queryset(self): if self.request.user.is_superuser: return super(ShopListView, self).get_queryset() else: return Shop.objects.get_for_user(self.request.user) def get_toolbar(self): if WshopSettings.get_setting("WSHOP_ENABLE_MULTIPLE_SHOPS"): return super(ShopListView, self).get_toolbar() else: return Toolbar([])
def get_columns(self): for column in self.columns: if column.id == 'shop': shops = Shop.objects.get_for_user( self.request.user).prefetch_related('translations') column.filter_config = ChoicesFilter(choices=shops) break return self.columns
class UserListView(PicotableListView): model = settings.AUTH_USER_MODEL default_columns = [ Column("username", _(u"Username"), filter_config=TextFilter()), Column("email", _(u"Email"), filter_config=TextFilter()), Column("first_name", _(u"First Name"), filter_config=TextFilter()), Column("last_name", _(u"Last Name"), filter_config=TextFilter()), Column("is_active", _(u"Active"), filter_config=ChoicesFilter([(False, _("no")), (True, _("yes"))], default=True)), Column("is_staff", _(u"Staff"), filter_config=true_or_false_filter), Column("is_superuser", _(u"Superuser"), filter_config=true_or_false_filter), ] def get_model(self): return get_user_model() def get_queryset(self): model = self.get_model() qs = self.get_model().objects.all() if "date_joined" in model._meta.get_all_field_names(): qs = qs.order_by("-date_joined") return qs def get_context_data(self, **kwargs): context = super(UserListView, self).get_context_data(**kwargs) context["title"] = force_text( self.get_model()._meta.verbose_name_plural).title() return context def get_object_abstract(self, instance, item): bits = filter(None, [ _("First Name: %s") % (getattr(instance, 'first_name', None) or "\u2014"), _("Last Name: %s") % (getattr(instance, 'last_name', None) or "\u2014"), _("Active") if instance.is_active else _(u"Inactive"), _("Email: %s") % (getattr(instance, 'email', None) or "\u2014"), _("Staff") if getattr(instance, 'is_staff', None) else None, _("Superuser") if getattr(instance, 'is_superuser', None) else None ]) return [{ "text": instance.get_username() or _("User"), "class": "header" }, { "text": ", ".join([force_text(bit) for bit in bits]) }]
class CampaignListView(PicotableListView): default_columns = [ Column("name", _(u"Title"), sort_field="name", display="name", linked=True, filter_config=TextFilter(operator="startswith")), Column("start_datetime", _("Starts")), Column("end_datetime", _("Ends")), Column("active", _("Active"), filter_config=ChoicesFilter(choices=[(0, _("No")), (1, _("Yes"))])), ] def get_queryset(self): shop = self.request.shop return self.model.objects.filter(shop=shop) def start_datetime(self, instance, *args, **kwargs): if not instance.start_datetime: return "" return self._formatted_datetime(instance.start_datetime) def end_datetime(self, instance, *args, **kwargs): if not instance.end_datetime: return "" return self._formatted_datetime(instance.end_datetime) def _formatted_datetime(self, dt): return format_datetime(localtime(dt), locale=get_current_babel_locale()) def get_object_abstract(self, instance, item): return [ { "text": "%s" % (instance or _("CatalogCampaign")), "class": "header" }, ]
def _get_column(self, model, field, known_names, identifier): if not self._valid_field(field.name): return None field_name = field.verbose_name.title() if field_name in known_names: field_name = "%s %s" % (model.__name__, field_name) display = "%s__%s" % (identifier, field.name) if identifier else field.name column = Column("%s_%s" % (model.__name__.lower(), field.name), field_name, display=display) column, is_special = self.handle_special_column(field, column) if not is_special: if isinstance(field, CharField): column.filter_config = TextFilter(placeholder=field_name) if isinstance(field, EnumIntegerField): column.filter_config = ChoicesFilter(field.choices) if isinstance(field, BooleanField): column.filter_config = true_or_false_filter return column
class OrderListView(PicotableListView): model = Order default_columns = [ Column("identifier", _(u"Order"), linked=True, filter_config=TextFilter(operator="startswith")), Column("order_date", _(u"Order Date"), display="format_order_date", filter_config=DateRangeFilter()), Column("customer", _(u"Customer"), display="format_customer_name", filter_config=MultiFieldTextFilter( filter_fields=("customer__email", "customer__name", "billing_address__name", "shipping_address__name", "orderer__name"))), Column( "status", _(u"Status"), filter_config=OrderStatusChoicesFilter( choices=OrderStatus.objects.all()), ), Column("payment_status", _(u"Payment Status"), filter_config=ChoicesFilter(choices=PaymentStatus.choices)), Column("shipping_status", _(u"Shipping Status"), filter_config=ChoicesFilter(choices=ShippingStatus.choices)), Column("taxful_total_price_value", _(u"Total"), sort_field="taxful_total_price_value", display="format_taxful_total_price", class_name="text-right", filter_config=RangeFilter( field_type="number", filter_field="taxful_total_price_value")), ] mass_actions = [ "wshop.admin.modules.orders.mass_actions:CancelOrderAction", "wshop.admin.modules.orders.mass_actions:OrderConfirmationPdfAction", "wshop.admin.modules.orders.mass_actions:OrderDeliveryPdfAction", ] def get_toolbar(self): return Toolbar([ NewActionButton.for_model(Order, url=reverse("wshop_admin:order.new")), SettingsActionButton.for_model(Order, return_url="order") ]) def get_queryset(self): return super(OrderListView, self).get_queryset().exclude( deleted=True).filter(shop=self.request.shop) def format_customer_name(self, instance, *args, **kwargs): return instance.get_customer_name() or "" def format_order_date(self, instance, *args, **kwargs): return get_locally_formatted_datetime(instance.order_date) def format_taxful_total_price(self, instance, *args, **kwargs): return escape(format_money(instance.taxful_total_price)) def label(self, instance, *args, **kwargs): # format label to make it human readable return instance.label.replace("_", " ").title() def get_object_abstract(self, instance, item): return [{ "text": "%s" % instance, "class": "header" }, { "title": _(u"Total"), "text": item.get("taxful_total_price_value") }, { "title": _(u"Status"), "text": item.get("status") }]
class StocksListView(PicotableListView): template_name = "wshop/simple_supplier/admin/base_picotable.jinja" model = Product default_columns = [ Column("sku", _("SKU"), sort_field="product__sku", display="product__sku", linked=True, filter_config=TextFilter(filter_field="product__sku", placeholder=_("Filter by SKU..."))), Column("name", _("Name"), sort_field="product__translations__name", display="product__name", linked=True, filter_config=TextFilter( filter_field="product__translations__name", placeholder=_("Filter by name..."))), Column( "supplier", _("Supplier"), display="supplier", linked=False, filter_config=ChoicesFilter( Supplier.objects.filter(module_identifier="simple_supplier"))), Column("stock_information", _("Stock information"), display="get_stock_information", linked=False, sortable=False, raw=True), Column("adjust_stock", _("Adjust stock"), display="get_stock_adjustment_form", sortable=False, linked=False, raw=True) ] def __init__(self): super(StocksListView, self).__init__() self.columns = self.default_columns def get_object_abstract(self, instance, item): item.update({ "_linked_in_mobile": False, "_url": self.get_object_url(instance.product) }) return [ { "text": item.get("name"), "class": "header" }, { "title": "", "text": item.get("sku") }, { "title": "", "text": " ", "raw": item.get("stock_information") }, { "title": "", "text": " ", "raw": item.get("adjust_stock") }, ] def get_queryset(self): return StockCount.objects.filter( supplier__module_identifier="simple_supplier", product__stock_behavior=StockBehavior.STOCKED, product__deleted=False).order_by("product__id") def get_context_data(self, **kwargs): context = super(PicotableListView, self).get_context_data(**kwargs) context["toolbar"] = None context["title"] = _("Stock management") return context def get_stock_information(self, instance): return get_stock_information_html(instance.supplier, instance.product) def get_stock_adjustment_form(self, instance): return get_stock_adjustment_div(self.request, instance.supplier, instance.product)
class CartListView(PicotableListView): model = StoredBasket default_columns = [ Column("created_on", _(u"Created on"), display="format_created_date", filter_config=DateRangeFilter()), Column("updated_on", _(u"Last updated on"), display="format_updated_date", filter_config=DateRangeFilter()), Column( "finished", _("Abandoned"), display="format_abandoned_status", filter_config=ChoicesFilter([(False, _("yes")), (True, _("no"))]) ), Column("shop", _("Shop"), filter_config=ChoicesFilter(choices=Shop.objects.all())), Column("product_count", _("Product count"), filter_config=RangeFilter()), Column( "customer", _(u"Customer"), filter_config=MultiFieldTextFilter(filter_fields=("customer__email", "customer__name")) ), Column( "orderer", _(u"Orderer"), filter_config=MultiFieldTextFilter(filter_fields=("orderer__email", "orderer__name")) ), Column( "taxful_total_price", _(u"Total"), sort_field="taxful_total_price_value", display="format_taxful_total_price", class_name="text-right", filter_config=RangeFilter(field_type="number", filter_field="taxful_total_price_value") ), ] def get_queryset(self): """ Ignore potentially active carts, displaying only those not updated for at least 2 hours. """ cutoff = now() - datetime.timedelta(hours=2) filters = {"updated_on__lt": cutoff, "product_count__gte": 0, "persistent": False} return super(CartListView, self).get_queryset().filter(**filters) def format_abandoned_status(self, instance, *args, **kwargs): return "yes" if not instance.finished else "no" def format_created_date(self, instance, *args, **kwargs): return get_locally_formatted_datetime(instance.created_on) def format_updated_date(self, instance, *args, **kwargs): return get_locally_formatted_datetime(instance.updated_on) def format_taxful_total_price(self, instance, *args, **kwargs): if not instance.taxful_total_price: return "" return escape(format_money(instance.taxful_total_price)) def get_context_data(self, **kwargs): context = super(CartListView, self).get_context_data(**kwargs) context["title"] = _("Carts") return context def get_object_abstract(self, instance, item): return [ {"text": "%s" % instance, "class": "header"}, {"title": _(u"Created on"), "text": item.get("created_on")}, {"title": _(u"Last updated on"), "text": item.get("updated_on")}, {"title": _(u"Ordered"), "text": item.get("finished")}, {"title": _(u"Total"), "text": item.get("taxful_total_price")}, ]
class ContactListView(PicotableListView): model = Contact default_columns = [ Column("name", _(u"Name"), linked=True, filter_config=TextFilter()), Column("type", _(u"Type"), display="get_type_display", sortable=False, filter_config=ContactTypeFilter()), Column("email", _(u"Email"), filter_config=TextFilter()), Column("phone", _(u"Phone"), filter_config=TextFilter()), Column("is_active", _(u"Active"), filter_config=ChoicesFilter([(False, _("no")), (True, _("yes"))], default=True)), Column("n_orders", _(u"# Orders"), class_name="text-right", filter_config=RangeFilter(step=1)), Column("groups", _("Groups"), filter_config=ChoicesFilter(ContactGroup.objects.all(), "groups"), display="get_groups_display"), Column("shops", _("Shops"), filter_config=Select2Filter(Shop.objects.all()), display="get_shop_display") ] mass_actions = [ "wshop.admin.modules.contacts.mass_actions:EditContactsAction", "wshop.admin.modules.contacts.mass_actions:EditContactGroupsAction", ] def get_toolbar(self): if self.request.user.is_superuser: settings_button = SettingsActionButton.for_model( Contact, return_url="contact") else: settings_button = None return Toolbar([ NewActionButton.for_model(PersonContact, url=reverse("wshop_admin:contact.new") + "?type=person"), NewActionButton.for_model(CompanyContact, extra_css_class="btn-info", url=reverse("wshop_admin:contact.new") + "?type=company"), settings_button ]) def get_queryset(self): qs = super(ContactListView, self).get_queryset() groups = self.get_filter().get("groups") query = Q(groups__in=groups) if groups else Q() limited = (settings.WSHOP_ENABLE_MULTIPLE_SHOPS and settings.WSHOP_MANAGE_CONTACTS_PER_SHOP and not self.request.user.is_superuser) if limited: shop = self.request.shop qs = qs.filter(shops=shop) return (qs.filter(query).annotate( n_orders=Count("customer_orders")).order_by("-created_on")) def get_type_display(self, instance): if isinstance(instance, PersonContact): return _(u"Person") elif isinstance(instance, CompanyContact): return _(u"Company") else: return _(u"Contact") def get_groups_display(self, instance): if instance.groups.count(): return ", ".join( instance.groups.values_list("translations__name", flat=True)) return _("No group") def get_shop_display(self, instance): if instance.shops.count(): return ", ".join( instance.shops.values_list("translations__name", flat=True)) return _("No shop") def get_object_abstract(self, instance, item): """ :type instance: wshop.core.models.Contact """ bits = filter(None, [ item.get("type"), _("Active") if instance.is_active else _("Inactive"), _("Email: %s") % (instance.email or "\u2014"), _("Phone: %s") % (instance.phone or "\u2014"), _("%d orders") % instance.n_orders, ]) return [{ "text": instance.name or _("Contact"), "class": "header" }, { "text": ", ".join([force_text(bit) for bit in bits]) }]
class ProductListView(PicotableListView): model = ShopProduct picotable_class = ProductPicotable default_columns = [ Column("primary_image", _(u"Primary Image"), display="get_primary_image", class_name="text-center", raw=True, ordering=1, sortable=False), Column("name", _(u"Name"), sort_field="product__translations__name", display="product__name", filter_config=TextFilter( filter_field="product__translations__name", placeholder=_("Filter by name...")), ordering=2), Column("shop", _("Shop"), ordering=2), Column("sku", _(u"SKU"), display="product__sku", filter_config=RangeFilter(filter_field="product__sku"), ordering=3), Column("barcode", _(u"Barcode"), display="product__barcode", filter_config=TextFilter(placeholder=_("Filter by barcode...")), ordering=4), Column("type", _(u"Type"), display="product__type", ordering=5), Column("mode", _(u"Mode"), display="product__mode", filter_config=ChoicesFilter(ProductMode.choices), ordering=6), ] related_objects = [ ("product", "wshop.core.models:Product"), ] mass_actions = [ "wshop.admin.modules.products.mass_actions:VisibleMassAction", "wshop.admin.modules.products.mass_actions:InvisibleMassAction", "wshop.admin.modules.products.mass_actions:FileResponseAction", "wshop.admin.modules.products.mass_actions:EditProductAttributesAction", ] def get_columns(self): for column in self.columns: if column.id == 'shop': shops = Shop.objects.get_for_user( self.request.user).prefetch_related('translations') column.filter_config = ChoicesFilter(choices=shops) break return self.columns def get_primary_image(self, instance): if instance.product.primary_image: thumbnail = instance.product.primary_image.get_thumbnail() if thumbnail: return "<img src='/media/{}'>".format(thumbnail) return "<img src='%s'>" % static( "wshop_admin/img/no_image_thumbnail.png") def get_queryset(self): filter = self.get_filter() shop = self.request.shop 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) return qs def get_object_abstract(self, instance, item): return [ { "text": "%s" % instance.product, "class": "header" }, { "title": _(u"Barcode"), "text": item.get("product__barcode") }, { "title": _(u"SKU"), "text": item.get("product__sku") }, { "title": _(u"Type"), "text": item.get("product__type") }, ]