def applyfilters(self, variables, filterscs):
'''
This method applies the filters to the files by taking in the two list, one of which contains
the files checked to apply, the other one contains the filters checked to apply, and this
method will change the state string accordingly
'''
if GUI.fileObj == []:
for thefile in GUI.fileName:
GUI.fileObj.append(Document(thefile))
for D in GUI.fileObj:
D.generateWhole()
elif len(GUI.fileObj) != len(GUI.fileName):
lengthD = len(GUI.fileName) - len(GUI.fileObj)
for i in range(lengthD)[::-1]:
GUI.fileObj.append(Document(GUI.fileName[-(1 + i)]))
GUI.fileObj[-1].generateWhole()
empty = True
for i in range(len(variables)):
if variables[i].get() == 1:
dofil = TextFilter(GUI.fileObj[i])
dofil.apply([
self.filters[j]
for j in range(len(filterscs)) if filterscs[j].get() == 1
], GUI.fileObj[i])
empty = False
if empty == True:
self.sti = 'Nothing applied'
else:
self.sti = 'Successfully applied'
self.sti_text.set(self.sti)
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",
filter_field="translations__name"
)
),
Column(
"public_name",
_("Public Name"),
linked=False,
filter_config=TextFilter(
operator="startswith",
filter_field="translations__name"
)
),
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"))])),
]
class StocksListView(PicotableListView):
template_name = "E-Commerce/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.enabled().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": ""})
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",
supplier__enabled=True,
supplier__stock_managed=True,
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)
def applyFilter(self,method):
'''Adds filter to list of filter methods if the button pressed is not "Apply Filter". If the button is Apply Filter,
then the list of filters will subsequently be applied to the documents.'''
if method == "apply filters":
for doc in self.fileL:
newtext = TextFilter(doc.fileName, self.filtL)
newtext.apply()
doc.doc = newtext.doc
else:
if method not in self.filtL:
self.filtL.append(str(method))
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),
]
toolbar_buttons_provider_key = "user_list_toolbar_provider"
mass_actions_provider_key = "user_list_mass_actions_provider"
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 [f.name for f in model._meta.get_fields()]:
qs = qs.order_by("-date_joined")
# non superusers can't see superusers
if not self.request.user.is_superuser:
qs = qs.filter(is_superuser=False)
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 PageListView(PicotableListView):
url_identifier = "simple_cms.page"
model = Page
default_columns = [
Column(
"title",
_(u"Title"),
sort_field="translations__title",
display="title",
linked=True,
filter_config=TextFilter(
operator="startswith",
filter_field="translations__title"
)
),
Column("available_from", _(u"Available from")),
Column("available_to", _(u"Available to")),
Column("created_by", _(u"Created by")),
Column("created_on", _(u"Date created")),
]
def get_object_abstract(self, instance, item):
return [
{"text": "%s" % (instance or _("Page")), "class": "header"},
{"title": _(u"Available from"), "text": item.get("available_from")},
{"title": _(u"Available to"), "text": item.get("available_to")} if instance.available_to else None
]
def get_queryset(self):
return super(PageListView, self).get_queryset().for_shop(get_shop(self.request)).not_deleted()
class AvailabilityExceptionListView(PicotableListView):
model = AvailabilityException
url_identifier = "discounts_availability_exception"
default_columns = [
Column(
"name", _("Exception Name"), sort_field="name", display="name",
filter_config=TextFilter(filter_field="name", placeholder=_("Filter by name..."))
),
Column(
"start_datetime", _("Start Date and Time"), display="format_start_datetime", filter_config=DateRangeFilter()
),
Column(
"end_datetime", _("End Date and Time"), display="format_end_datetime", filter_config=DateRangeFilter()
)
]
def get_queryset(self):
return AvailabilityException.objects.filter(shops=get_shop(self.request))
def format_start_datetime(self, instance, *args, **kwargs):
return get_locally_formatted_datetime(instance.start_datetime) if instance.start_datetime else ""
def format_end_datetime(self, instance, *args, **kwargs):
return get_locally_formatted_datetime(instance.end_datetime) if instance.end_datetime else ""
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 CurrencyListView(PicotableListView):
model = Currency
default_columns = [
Column("name", _("Name"), display="get_currency_display", sortable=False),
Column(
"code", _(u"Code"), sort_field="code",
filter_config=TextFilter(
filter_field="code",
placeholder=_("Filter by code"),
)
),
Column(
"decimal_places",
_("Decimal places"),
display="format_decimal_places",
)
]
toolbar_buttons_provider_key = "currency_list_toolbar_provider"
mass_actions_provider_key = "currency_list_mass_actions_provider"
def format_decimal_places(self, instance):
return "{0}".format(instance.decimal_places)
def get_currency_display(self, instance):
locale = get_current_babel_locale()
return locale.currencies.get(instance.code, instance.code)
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"))])),
]
toolbar_buttons_provider_key = "campaign_list_toolbar_provider"
mass_actions_provider_key = "campaign_list_actions_provider"
def get_queryset(self):
return self.model.objects.filter(shop=get_shop(self.request))
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"},
]
class SupplierListView(PicotableListView):
model = Supplier
default_columns = [
Column(
"name",
_(u"Name"),
sort_field="name",
display="name",
filter_config=TextFilter(
filter_field="name",
placeholder=_("Filter by name...")
)
),
Column("type", _(u"Type")),
Column("module_identifier", _(u"Module"), display="get_module_display", sortable=True)
]
toolbar_buttons_provider_key = "supplier_list_toolbar_provider"
mass_actions_provider_key = "supplier_list_mass_actions_provider"
def get_queryset(self):
return Supplier.objects.filter(Q(shops=get_shop(self.request)) | Q(shops__isnull=True)).not_deleted()
def get_module_display(self, instance):
return instance.module.name or _("No %s module") % self.model._meta.verbose_name
def get_toolbar(self):
if settings.E-Commerce_ENABLE_MULTIPLE_SUPPLIERS:
return super(SupplierListView, self).get_toolbar()
else:
return Toolbar.for_view(self)
class ManufacturerListView(PicotableListView):
model = Manufacturer
default_columns = [
Column(
"logo",
_(u"Logo"),
display="logo",
class_name="text-center",
raw=True,
ordering=1,
sortable=False),
Column(
"name",
_(u"Name"),
sort_field="name",
display="name",
filter_config=TextFilter(
filter_field="name",
placeholder=_("Filter by name...")
)
),
]
toolbar_buttons_provider_key = "manufacturer_list_toolbar_provider"
mass_actions_provider_key = "manufacturer_list_mass_actions_provider"
def get_queryset(self):
return Manufacturer.objects.filter(Q(shops=get_shop(self.request)) | Q(shops__isnull=True))
class ServiceListView(PicotableListView):
model = None # Override in subclass
columns = []
base_columns = [
Column(
"name", _("Name"), sort_field="translations__name",
filter_config=TextFilter(filter_field="translations__name", placeholder=_("Filter by name..."))
),
Column(
"choice_identifier", _(u"Service choice"), display="format_service_choice",
sortable=False,
),
Column("enabled", _(u"Enabled"), filter_config=true_or_false_filter),
Column("shop", _(u"Shop"))
]
toolbar_buttons_provider_key = "service_list_toolbar_provider"
mass_actions_provider_key = "service_list_mass_actions_provider"
def get_object_abstract(self, instance, item):
return [
{"text": "%s" % instance, "class": "header"},
]
def format_service_choice(self, instance, *args, **kwargs):
if instance.provider:
for choice in instance.provider.get_service_choices():
if choice.identifier == instance.choice_identifier:
return force_text(choice.name)
def get_queryset(self):
return super(ServiceListView, self).get_queryset().filter(shop=self.request.shop)
class PermissionGroupListView(PicotableListView):
model = PermissionGroup
default_columns = [
Column(
"name",
_(u"Name"),
sort_field="name",
display="name",
filter_config=TextFilter(filter_field="name", placeholder=_("Filter by name..."))
),
]
toolbar_buttons_provider_key = "permission_group_list_toolbar_provider"
mass_actions_provider_key = "permission_group_list_mass_actions_provider"
def get_context_data(self, **kwargs):
context = super(PermissionGroupListView, self).get_context_data(**kwargs)
context["title"] = _("Permission Groups")
if self.request.user.is_superuser:
settings_button = SettingsActionButton.for_model(self.model, return_url="permission_group")
else:
settings_button = None
context["toolbar"] = Toolbar([
NewActionButton("E-Commerce_admin:permission_group.new", text=_("Create new Permission Group")),
settings_button
], view=self)
return context
def applyFilters(self):
i = 0
while i < self.numFiles:
self.tFilterDictionary[i] = TextFilter(self.docDictionary[i], self.pList[i])
self.tFilterDictionary[i].apply()
i += 1
print("Applied Filters")
class TaskListView(PicotableListView):
model = Task
default_columns = [
Column(
"name",
_("Name"),
sort_field="name",
display="name",
filter_config=TextFilter(
filter_field="name",
placeholder=_("Filter by name...")
)
),
Column(
"creator",
_("Creator"),
display="get_creator_name_display",
filter_config=TextFilter(
filter_field="creator__name",
placeholder=_("Filter by creator...")
)
),
Column("status", _("Status"), filter_config=ChoicesFilter(TaskStatus.choices), class_name="text-center"),
Column("priority", _("Priority"), display="get_priority_display", class_name="text-center"),
Column("comments", _("Comments"), sort_field="comments", display="get_comments_count", class_name="text-center")
]
toolbar_buttons_provider_key = "task_list_toolbar_provider"
mass_actions_provider_key = "task_list_actions_provider"
def get_comments_count(self, instance, **kwargs):
return instance.comments.for_contact(get_person_contact(self.request.user)).count()
def get_queryset(self):
return Task.objects.for_shop(get_shop(self.request))
def get_creator_name_display(self, instance, **kwargs):
if not len(instance.creator.name):
return "No name set (id: %d)" % instance.creator.id
return instance.creator.name
def get_priority_display(self, instance, **kwargs):
return "%s" % instance.priority
class TaxClassListView(PicotableListView):
model = TaxClass
default_columns = [
Column(
"name", _("Name"), sort_field="translations__name",
filter_config=TextFilter(
filter_field="translations__name",
placeholder=_("Filter by name..."),
),
),
]
class HappyHourListView(PicotableListView):
model = HappyHour
url_identifier = "discounts_happy_hour"
default_columns = [
Column(
"name", _("Happy Hour Name"), sort_field="name", display="name",
filter_config=TextFilter(filter_field="name", placeholder=_("Filter by name..."))
)
]
def get_queryset(self):
return HappyHour.objects.filter(shops=get_shop(self.request))
class CarouselListView(PicotableListView):
model = Carousel
default_columns = [
Column(
"name",
_("Name"),
sort_field="name",
display="name",
filter_config=TextFilter(filter_field="name", placeholder=_("Filter by name..."))
),
]
def get_queryset(self):
return super(CarouselListView, self).get_queryset().filter(shops=get_shop(self.request))
class ProductTypeListView(PicotableListView):
model = ProductType
default_columns = [
Column(
"name",
_(u"Name"),
sort_field="translations__name",
display="name",
filter_config=TextFilter(filter_field="translations__name", placeholder=_("Filter by name..."))),
Column("n_attributes", _(u"Number of Attributes")),
]
toolbar_buttons_provider_key = "product_type_list_toolbar_provider"
mass_actions_provider_key = "product_type_list_mass_actions_provider"
def get_queryset(self):
return ProductType.objects.all().annotate(n_attributes=Count("attributes"))
class TaskTypeListView(PicotableListView):
model = TaskType
default_columns = [
Column(
"name",
_("Name"),
sort_field="name",
display="name",
filter_config=TextFilter(
filter_field="translations__name",
placeholder=_("Filter by name...")
)
)
]
def get_queryset(self):
return TaskType.objects.filter(shop=get_shop(self.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, admin_user, columns=(columns + is_active))
data = pico_no_defaults.get_data(query)
superuser_field = data["columns"][3]
assert superuser_field["id"] == "is_superuser"
assert len(superuser_field["filter"]["choices"]) == 3
assert superuser_field["filter"]["defaultChoice"] == "_all"
assert superuser_field["filter"]["choices"][0][0] == superuser_field["filter"]["defaultChoice"]
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, admin_user, 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 TaxListView(PicotableListView):
model = Tax
default_columns = [
Column(
"name", _("Name"), sort_field="translations__name",
filter_config=TextFilter(
filter_field="translations__name",
placeholder=_("Filter by name..."),
),
),
Column("code", _(u"Code")),
Column("rate", _("Rate"), display=_format_rate),
# Column("amount", _(u"Amount")),
Column("enabled", _(u"Enabled"), filter_config=true_or_false_filter),
]
toolbar_buttons_provider_key = "tax_list_toolbar_provider"
mass_actions_provider_key = "tax_list_mass_actions_provider"
class ScriptListView(PicotableListView):
template_name = "notify/admin/list_script.jinja"
model = Script
default_columns = [
Column("name", _("Name"), linked=True, filter_config=TextFilter(operator="startswith")),
Column("event_identifier", _("Event"), display="get_event_identifier_text"),
Column("enabled", _("Enabled"), filter_config=true_or_false_filter),
]
toolbar_buttons_provider_key = "notify_list_toolbar_provider"
mass_actions_provider_key = "notify_list_actions_provider"
def get_object_url(self, instance):
return reverse("E-Commerce_admin:notify.script.edit", kwargs={"pk": instance.pk})
def get_event_identifier_text(self, instance):
if not hasattr(self, "_event_identifier_names"):
self._event_identifier_names = dict(get_name_map("notify_event"))
return self._event_identifier_names.get(instance.event_identifier, instance.event_identifier)
def get_toolbar(self):
return Toolbar([
URLActionButton(
text=_("New Script"), icon="fa fa-plus", extra_css_class="btn-success",
url=reverse("E-Commerce_admin:notify.script.new")
),
JavaScriptActionButton(
text=_("New From Template"), icon="fa fa-book",
onclick="showScriptTemplates()"
)
], view=self)
def get_object_abstract(self, instance, item):
return [
{"text": "%s" % instance, "class": "header"},
{"title": _("Event"), "text": item.get("event_identifier")},
{"title": _("Enabled"), "text": item.get("enabled")}
]
def get_queryset(self):
return super(ScriptListView, self).get_queryset().filter(shop=get_shop(self.request))
class ServiceProviderListView(PicotableListView):
model = ServiceProvider
default_columns = [
Column(
"name", _("Name"), sort_field="base_translations__name",
filter_config=TextFilter(
filter_field="base_translations__name",
placeholder=_("Filter by name..."))),
Column("type", _(u"Type"), display="get_type_display", sortable=False),
]
toolbar_buttons_provider_key = "service_provider_list_toolbar_provider"
mass_actions_provider_key = "service_provider_mass_actions_provider"
def get_type_display(self, instance):
return instance._meta.verbose_name.capitalize()
def get_object_abstract(self, instance, item):
return [
{"text": "%s" % instance, "class": "header"},
{"text": self.get_type_display(instance)},
]
class AttributeListView(PicotableListView):
model = Attribute
default_columns = [
Column("identifier", _("Identifier"), filter_config=TextFilter(
filter_field="identifier",
placeholder=_("Filter by identifier...")
)),
Column("name", _("Name"), sort_field="translations__name", display="name", filter_config=TextFilter(
filter_field="translations__name",
placeholder=_("Filter by name...")
)),
Column("type", _("Type"), filter_config=ChoicesFilter(AttributeType.choices)),
Column("visibility_mode", _("Visibility Mode"), filter_config=ChoicesFilter(AttributeVisibility.choices)),
Column("searchable", _("Searchable")),
Column("n_product_types", _("Used in # Product Types")),
]
toolbar_buttons_provider_key = "attribute_list_toolbar_provider"
mass_actions_provider_key = "attribute_list_mass_actions_provider"
def get_queryset(self):
return Attribute.objects.all().annotate(n_product_types=Count("product_types"))
def get_pico(rf, admin_user, model=None, columns=None):
shop = 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())
]
admin_user.is_staff = True
admin_user.save()
shop.staff_members.add(admin_user)
request = apply_request_middleware(rf.get("/"), user=admin_user)
return Picotable(
request=request,
columns=columns,
mass_actions=[],
queryset=model.objects.all(),
context=PicoContext(request)
)
class CouponCodeListView(PicotableListView):
model = CouponCode
url_identifier = "discounts_coupon_codes"
default_columns = [
Column(
"code", _("Code"), sort_field="code", display="code", linked=True,
filter_config=TextFilter(operator="startswith")
),
Column("usages", _("Usages"), display="get_usages"),
Column("usage_limit_customer", _("Usages Limit per contact")),
Column("usage_limit", _("Usage Limit")),
Column("active", _("Active")),
Column("created_by", _("Created by")),
Column("created_on", _("Date created")),
]
def get_usages(self, instance, *args, **kwargs):
return instance.usages.count()
def get_queryset(self):
return CouponCode.objects.filter(shops=get_shop(self.request))
class CouponListView(PicotableListView):
model = Coupon
default_columns = [
Column(
"code", _(u"Code"), sort_field="code", display="code", linked=True,
filter_config=TextFilter(operator="startswith")
),
Column("usages", _("Usages"), display="get_usages"),
Column("usage_limit_customer", _("Usages Limit per contact")),
Column("usage_limit", _("Usage Limit")),
Column("active", _("Active")),
Column("created_by", _(u"Created by")),
Column("created_on", _(u"Date created")),
]
def get_usages(self, instance, *args, **kwargs):
return instance.usages.count()
def get_context_data(self, **kwargs):
context = super(CouponListView, self).get_context_data(**kwargs)
if self.request.user.is_superuser:
settings_button = SettingsActionButton.for_model(self.model, return_url="coupon")
else:
settings_button = None
context["toolbar"] = Toolbar([
NewActionButton("E-Commerce_admin:coupon.new", text=_("Create new Coupon")),
settings_button
], view=self)
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_translated_column(self, model, field, known_names, identifier):
field_name = field.verbose_name.title()
if field_name in known_names:
field_name = "%s %s" % (model.__name__, field_name)
# take the first extension, usually we should not have more then one
translation_rel_name = model._parler_meta._extensions[0].rel_name
if model != self.model:
filter_field = "%s__%s__%s" % (identifier, translation_rel_name, field.name) if identifier else field.name
else:
filter_field = "%s__%s" % (translation_rel_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,
sort_field=display,
display=display,
filter_config=TextFilter(filter_field=filter_field, placeholder=field_name)
)
return self.handle_special_column(field, column)[0]
