class BleachingQCMethodSUFilterSet(BaseTransectFilterSet):
sample_unit_id = BaseInFilter(method="id_lookup")
depth = RangeFilter()
observers = BaseInFilter(method="json_name_lookup")
count_genera = RangeFilter()
count_total = RangeFilter()
percent_normal = RangeFilter()
percent_pale = RangeFilter()
percent_bleached = RangeFilter()
quadrat_count = RangeFilter()
percent_hard_avg = RangeFilter()
percent_soft_avg = RangeFilter()
percent_algae_avg = RangeFilter()
class Meta:
model = BleachingQCSUView
fields = [
"depth",
"sample_unit_id",
"observers",
"label",
"quadrat_size",
"data_policy_bleachingqc",
"count_genera",
"count_total",
"percent_normal",
"percent_pale",
"percent_bleached",
"quadrat_count",
"percent_hard_avg",
"percent_soft_avg",
"percent_algae_avg",
]
class BaseSEFilterSet(AggregatedViewFilterSet):
id = BaseInFilter(method="id_lookup")
sample_event_id = BaseInFilter(method="id_lookup")
sample_date = DateFromToRangeFilter()
management_est_year = RangeFilter()
management_size = RangeFilter()
management_party = BaseInFilter(
field_name="management_parties", method="char_lookup"
)
management_compliance = BaseInFilter(method="char_lookup")
management_rule = BaseInFilter(field_name="management_rules", method="char_lookup")
current_name = BaseInFilter(method="char_lookup")
tide_name = BaseInFilter(method="char_lookup")
visibility_name = BaseInFilter(method="char_lookup")
class Meta:
fields = [
"sample_event_id",
"sample_date",
"management_est_year",
"management_size",
"management_party",
"management_compliance",
"management_rule",
"current_name",
"tide_name",
"visibility_name",
]
class BenthicPITMethodSEFilterSet(BaseTransectFilterSet):
sample_unit_count = RangeFilter()
depth_avg = RangeFilter()
class Meta:
model = BenthicPITSEView
fields = ["sample_unit_count", "depth_avg", "data_policy_benthicpit"]
class VoucherFilter(SortedFilterSet):
name = CharFilter(
label=pgettext_lazy('Voucher list name filter label', 'Name'),
lookup_expr='icontains')
type = ChoiceFilter(
name='discount_value_type',
label=pgettext_lazy(
'Sale list is sale type filter label', 'Discount type'),
choices=DISCOUNT_TYPE_CHOICES,
empty_label=pgettext_lazy('Filter empty choice label', 'All'),
widget=forms.Select)
discount_value = RangeFilter(
label=pgettext_lazy('Sale list filter label', 'Discount_value'))
date = DateFromToRangeFilter(
label=pgettext_lazy(
'Order list sorting filter label', 'Period of validity'),
name='created', widget=DateRangeWidget, method=filter_by_date_range)
limit = RangeFilter(
label=pgettext_lazy('Voucher list sorting filter', 'Limit'),
name='limit')
sort_by = OrderingFilter(
label=pgettext_lazy('Voucher list sorting filter label', 'Sort by'),
fields=SORT_BY_FIELDS_LABELS_VOUCHER.keys(),
field_labels=SORT_BY_FIELDS_LABELS_VOUCHER)
class Meta:
model = Voucher
fields = []
class BenthicPITMethodObsFilterSet(BaseTransectFilterSet):
depth = RangeFilter()
sample_unit_id = BaseInFilter(method="id_lookup")
observers = BaseInFilter(method="json_name_lookup")
transect_len_surveyed = RangeFilter()
reef_slope = BaseInFilter(method="char_lookup")
interval_size = RangeFilter()
interval = RangeFilter()
class Meta:
model = BenthicPITObsView
fields = [
"depth",
"sample_unit_id",
"observers",
"transect_len_surveyed",
"reef_slope",
"transect_number",
"interval_size",
"interval",
"benthic_category",
"benthic_attribute",
"growth_form",
"data_policy_benthicpit",
]
class BenthicLITMethodSEFilterSet(BaseSEFilterSet):
sample_unit_count = RangeFilter()
depth_avg = RangeFilter()
class Meta:
model = BenthicLITSESQLModel
fields = ["sample_unit_count", "depth_avg",]
class SimpleProductRatingFilter(SortedFilterSet):
product_id__name = CharFilter(label=pgettext_lazy(
'Product rating list filter label', 'Product Name'),
lookup_expr='icontains')
avg_rating = RangeFilter(label=pgettext_lazy(
'Product rating list filter label', 'Average Ratings'),
name='avg_rating')
total_rating = RangeFilter(label=pgettext_lazy(
'Product rating list filter label', 'Total Given'),
name='total_rating')
sort_by = OrderingFilter(label=pgettext_lazy(
'Product rating list filter label', 'Sort by'),
fields=PRODUCT_RATING_SORT_BY_FIELDS.keys(),
field_labels=PRODUCT_RATING_SORT_BY_FIELDS)
class Meta:
model = ProductRating
fields = ['product_id__name']
def get_summary_message(self):
counter = self.qs.count()
return npgettext(
'Number of matching records in the dashboard product rating list',
'Found %(counter)d matching product rating',
'Found %(counter)d matching product rating',
number=counter) % {
'counter': counter
}
class CourseFilter(FilterSet):
major = ModelChoiceFilter(queryset=Major.objects,
field_name='major',
label='Major')
catalog_number = RangeFilter(field_name='catalog_number')
title = CharFilter(field_name='title',
label='Title contains',
lookup_expr='icontains')
description = CharFilter(field_name='description',
label='Description contains',
lookup_expr='icontains')
credits_earned = RangeFilter(label='Credits')
graduate = ChoiceFilter(label='Course Level?',
choices=((True, 'Graduate'), (False, 'Undergrad')))
# need filters for...
prereqs = CharFilter(
Course.objects,
label='Has Prereq',
method='filter_requires_course',
distinct=True,
)
is_prereq = CharFilter(CoursePrerequisite.objects,
label='Is Prereq for',
method='filter_required_by')
def filter_requires_course(self, queryset, name, value):
return queryset.annotate(slug=Concat(
'prereqs__major__abbreviation',
Value('-'),
'prereqs__catalog_number',
Value(' '),
'prereqs__title',
)).filter(slug__icontains=value)
def filter_required_by(self, queryset, name, value):
return queryset.annotate(slug=Concat(
'a_prerequisite__course__major__abbreviation',
Value('-'),
'a_prerequisite__course__catalog_number',
Value(' '),
'a_prerequisite__course__title',
)).filter(slug__icontains=value)
class Meta:
model = Course
fields = [
'major', 'catalog_number', 'graduate', 'title', 'description',
'prereqs', 'is_prereq', 'credits_earned'
]
def __init__(self, *args, **kwargs):
super(CourseFilter, self).__init__(*args, **kwargs)
self.filters['major'].extra.update({'empty_label': 'Major...'})
self.filters['graduate'].extra.update(
{'empty_label': 'Course Level...'})
class CertificateFilter(FilterSet):
DATE_ATTR = {'type': 'date', 'placeholder': 'mm/dd/yyyy'}
status = MultipleChoiceFilter(
choices=Certificate.STATUS_CHOICES,
widget=CheckboxSelectMultiple(attrs={
'class': 'usa-unstyled-list',
'legend': 'Certificate Status'
}))
last_modified = DateFromToRangeFilter(widget=RangeWidget(attrs=DATE_ATTR))
date_of_sale = DateFromToRangeFilter(widget=RangeWidget(attrs=DATE_ATTR))
shipped_value = RangeFilter(widget=RangeWidget())
number_of_parcels = RangeFilter(widget=RangeWidget())
carat_weight = RangeFilter(widget=RangeWidget())
date_of_issue = DateFromToRangeFilter(widget=RangeWidget(attrs=DATE_ATTR))
date_of_expiry = DateFromToRangeFilter(widget=RangeWidget(attrs=DATE_ATTR))
licensee__name = ModelChoiceFilter(queryset=licensees)
date_of_delivery = DateFromToRangeFilter(widget=RangeWidget(
attrs=DATE_ATTR))
date_of_shipment = DateFromToRangeFilter(widget=RangeWidget(
attrs=DATE_ATTR))
date_voided = DateFromToRangeFilter(widget=RangeWidget(attrs=DATE_ATTR))
aes = CharFilter(lookup_expr='icontains')
exporter = CharFilter(lookup_expr='icontains')
exporter_address = CharFilter(lookup_expr='icontains')
consignee = CharFilter(lookup_expr='icontains')
consignee_address = CharFilter(lookup_expr='icontains')
class Meta:
model = Certificate
default_fields = ['status', 'aes', 'date_of_issue']
extra_fields = [
'licensee__name', 'country_of_origin', 'harmonized_code',
'port_of_export', 'shipped_value', 'number_of_parcels',
'carat_weight', 'date_of_expiry', 'date_of_shipment',
'date_of_delivery', 'exporter', 'exporter_address', 'consignee',
'consignee_address', 'last_modified', 'date_of_sale', 'date_voided'
]
fields = default_fields + extra_fields
@property
def default_fields(self):
return [
field for field in self.form
if field.name in self.Meta.default_fields
]
@property
def extra_fields(self):
return [
field for field in self.form
if field.name in self.Meta.extra_fields
]
class BleachingQCMethodSUFilterSet(BaseSUObsFilterSet):
count_genera = RangeFilter()
count_total = RangeFilter()
percent_normal = RangeFilter()
percent_pale = RangeFilter()
percent_bleached = RangeFilter()
quadrat_count = RangeFilter()
percent_hard_avg = RangeFilter()
percent_soft_avg = RangeFilter()
percent_algae_avg = RangeFilter()
class Meta:
model = BleachingQCSUSQLModel
fields = [
"quadrat_size",
"count_genera",
"count_total",
"percent_normal",
"percent_pale",
"percent_bleached",
"quadrat_count",
"percent_hard_avg",
"percent_soft_avg",
"percent_algae_avg",
]
class VoucherFilter(SortedFilterSet):
name = CharFilter(
label=pgettext_lazy("Voucher list name filter label", "Name"),
lookup_expr="icontains",
)
type = ChoiceFilter(
field_name="type",
label=pgettext_lazy("Voucher list type filter label", "Voucher type"),
choices=VOUCHER_TYPE_CHOICES,
empty_label=pgettext_lazy("Filter empty choice label", "All"),
widget=forms.Select,
)
discount_value_type = ChoiceFilter(
field_name="discount_value_type",
label=pgettext_lazy("Voucher list is sale type filter label",
"Discount type"),
choices=DISCOUNT_VALUE_TYPE_CHOICES,
empty_label=pgettext_lazy("Filter empty choice label", "All"),
widget=forms.Select,
)
discount_value = RangeFilter(
label=pgettext_lazy("Voucher list filter label", "Discount_value"))
date = DateFromToRangeFilter(
label=pgettext_lazy("Voucher list sorting filter label",
"Period of validity"),
field_name="created",
widget=DateRangeWidget,
method=filter_by_date_range,
)
min_spent_amount = RangeFilter(
label=pgettext_lazy("Voucher list sorting filter",
"Minimum amount spent"),
field_name="min_spent_amount",
)
sort_by = OrderingFilter(
label=pgettext_lazy("Voucher list sorting filter label", "Sort by"),
fields=SORT_BY_FIELDS_LABELS_VOUCHER.keys(),
field_labels=SORT_BY_FIELDS_LABELS_VOUCHER,
)
class Meta:
model = Voucher
fields = []
def get_summary_message(self):
counter = self.qs.count()
return npgettext(
"Number of matching records in the dashboard vouchers list",
"Found %(counter)d matching voucher",
"Found %(counter)d matching vouchers",
number=counter,
) % {
"counter": counter
}
class BeltFishMethodSEFilterSet(BaseSEFilterSet):
biomass_kgha_avg = RangeFilter()
sample_unit_count = RangeFilter()
depth_avg = RangeFilter()
class Meta:
model = BeltFishSESQLModel
fields = [
"biomass_kgha_avg",
"sample_unit_count",
"depth_avg",
]
class HabitatComplexityMethodSEFilterSet(BaseSEFilterSet):
sample_unit_count = RangeFilter()
depth_avg = RangeFilter()
score_avg_avg = RangeFilter()
class Meta:
model = HabitatComplexitySESQLModel
fields = [
"sample_unit_count",
"depth_avg",
"score_avg_avg",
]
class BeltFishMethodSUFilterSet(BaseSUObsFilterSet):
transect_len_surveyed = RangeFilter()
reef_slope = BaseInFilter(method="char_lookup")
biomass_kgha = RangeFilter()
class Meta:
model = BeltFishSUSQLModel
fields = [
"transect_len_surveyed",
"reef_slope",
"transect_number",
"biomass_kgha",
]
class BenthicPITMethodSUFilterSet(BaseSUObsFilterSet):
transect_len_surveyed = RangeFilter()
reef_slope = BaseInFilter(method="char_lookup")
interval_size = RangeFilter()
class Meta:
model = BenthicPITSUSQLModel
fields = [
"transect_len_surveyed",
"reef_slope",
"transect_number",
"interval_size",
]
class HabitatComplexityMethodSEFilterSet(BaseTransectFilterSet):
sample_unit_count = RangeFilter()
depth_avg = RangeFilter()
score_avg_avg = RangeFilter()
class Meta:
model = HabitatComplexitySEView
fields = [
"sample_unit_count",
"depth_avg",
"data_policy_habitatcomplexity",
"score_avg_avg",
]
class BeltFishMethodSEFilterSet(BaseTransectFilterSet):
biomass_kgha_avg = RangeFilter()
sample_unit_count = RangeFilter()
depth_avg = RangeFilter()
class Meta:
model = BeltFishSEView
fields = [
"biomass_kgha_avg",
"sample_unit_count",
"depth_avg",
"data_policy_beltfish",
]
class VoucherFilter(SortedFilterSet):
name = CharFilter(label=pgettext_lazy('Voucher list name filter label',
'Name'),
lookup_expr='icontains')
type = ChoiceFilter(name='discount_value_type',
label=pgettext_lazy(
'Sale list is sale type filter label',
'Discount type'),
choices=DISCOUNT_TYPE_CHOICES,
empty_label=pgettext_lazy('Filter empty choice label',
'All'),
widget=forms.Select)
discount_value = RangeFilter(
label=pgettext_lazy('Sale list filter label', 'Discount_value'))
date = DateFromToRangeFilter(label=pgettext_lazy(
'Order list sorting filter label', 'Period of validity'),
name='created',
widget=DateRangeWidget,
method='filter_by_date_range')
limit = RangeFilter(label=pgettext_lazy('Voucher list sorting filter',
'Limit'),
name='limit')
sort_by = OrderingFilter(label=pgettext_lazy(
'Voucher list sorting filter label', 'Sort by'),
fields=SORT_BY_FIELDS_LABELS_VOUCHER.keys(),
field_labels=SORT_BY_FIELDS_LABELS_VOUCHER)
class Meta:
model = Voucher
fields = []
def filter_by_date_range(self, queryset, name, value):
q = Q()
if value.start:
q = Q(start_date__gte=value.start)
if value.stop:
if value.start:
q |= Q(end_date__lte=value.stop)
else:
q = Q(end_date__lte=value.stop)
return queryset.filter(q)
def get_summary_message(self):
counter = self.qs.count()
return npgettext(
'Number of matching records in the dashboard vouchers list',
'Found %(counter)d matching voucher',
'Found %(counter)d matching vouchers',
number=counter) % {
'counter': counter
}
class BleachingQCMethodQuadratBenthicPercentObsFilterSet(BaseSUObsFilterSet):
percent_hard = RangeFilter()
percent_soft = RangeFilter()
percent_algae = RangeFilter()
class Meta:
model = BleachingQCQuadratBenthicPercentObsSQLModel
fields = [
"quadrat_size",
"quadrat_number",
"percent_hard",
"percent_soft",
"percent_algae",
]
class BleachingQCMethodColoniesBleachedObsFilterSet(BaseTransectFilterSet):
sample_unit_id = BaseInFilter(method="id_lookup")
depth = RangeFilter()
observers = BaseInFilter(method="json_name_lookup")
count_normal = RangeFilter()
count_pale = RangeFilter()
count_20 = RangeFilter()
count_50 = RangeFilter()
count_80 = RangeFilter()
count_100 = RangeFilter()
count_dead = RangeFilter()
class Meta:
model = BleachingQCColoniesBleachedObsView
fields = [
"depth",
"sample_unit_id",
"observers",
"label",
"quadrat_size",
"benthic_attribute",
"growth_form",
"data_policy_bleachingqc",
"count_normal",
"count_pale",
"count_20",
"count_50",
"count_80",
"count_100",
"count_dead",
]
class HabitatComplexityMethodSUFilterSet(BaseSUObsFilterSet):
transect_len_surveyed = RangeFilter()
reef_slope = BaseInFilter(method="char_lookup")
interval_size = RangeFilter()
score_avg = RangeFilter()
class Meta:
model = HabitatComplexitySUSQLModel
fields = [
"transect_len_surveyed",
"reef_slope",
"transect_number",
"score_avg",
]
class ActivitiesFilter(FilterSet):
activity_value = RangeFilter()
category_in = NumberInFilter(field_name='categories', lookup_expr='in')
class Meta:
model = Activities
fields = ('sdg', 'topic', 'donor_1', 'category_in', 'activity_value')
class ProductFilter(SortedFilterSet):
name = CharFilter(label=pgettext_lazy('Product list filter label', 'Name'),
lookup_expr='icontains')
categories = ModelMultipleChoiceFilter(label=pgettext_lazy(
'Product list filter label', 'Categories'),
name='categories',
queryset=Category.objects.all())
price = RangeFilter(label=pgettext_lazy('Product list filter label',
'Price'),
name='price',
widget=PriceRangeWidget)
is_published = ChoiceFilter(
label=pgettext_lazy('Product list filter label', 'Is published'),
choices=PUBLISHED_CHOICES,
empty_label=pgettext_lazy('Filter empty choice label', 'All'),
widget=forms.Select)
is_featured = ChoiceFilter(
label=pgettext_lazy('Product list is featured filter label',
'Is featured'),
choices=FEATURED_CHOICES,
empty_label=pgettext_lazy('Filter empty choice label', 'All'),
widget=forms.Select)
sort_by = OrderingFilter(label=pgettext_lazy('Product list filter label',
'Sort by'),
fields=PRODUCT_SORT_BY_FIELDS.keys(),
field_labels=PRODUCT_SORT_BY_FIELDS)
class Meta:
model = Product
fields = []
class ShippingMethodFilter(SortedFilterSet):
name = CharFilter(
label=pgettext_lazy(
'Shipping method list filter label', 'Name'),
lookup_expr="icontains")
price = RangeFilter(
label=pgettext_lazy(
'Shipping method list filter label', 'Price range'),
name='price_per_country__price')
country = ChoiceFilter(
label=pgettext_lazy('Shipping method filter label', 'Country'),
name='price_per_country__country_code',
choices=COUNTRY_CODE_CHOICES)
sort_by = OrderingFilter(
label=pgettext_lazy('Product list sorting filter label', 'Sort by'),
fields=SORT_BY_FIELDS.keys(),
field_labels=SORT_BY_FIELDS)
class Meta:
model = ShippingMethod
fields = []
def get_summary_message(self):
counter = self.qs.count()
return npgettext(
'Number of matching records in the dashboard '
'shipping methods list',
'Found %(counter)d matching shipping method',
'Found %(counter)d matching shipping methods',
number=counter) % {'counter': counter}
class SaleFilter(SortedFilterSet):
name = CharFilter(label=pgettext_lazy('Sale list filter label', 'Name'),
lookup_expr='icontains')
categories = ModelMultipleChoiceFilter(label=pgettext_lazy(
'Sale list filter label', 'Categories'),
name='categories',
queryset=Category.objects.all())
type = ChoiceFilter(label=pgettext_lazy('Sale list filter label',
'Discount type'),
choices=DISCOUNT_TYPE_CHOICES,
empty_label=pgettext_lazy('Filter empty choice label',
'All'),
widget=forms.Select)
value = RangeFilter(label=pgettext_lazy('Sale list filter label', 'Value'))
sort_by = OrderingFilter(label=pgettext_lazy('Sale list filter label',
'Sort by'),
fields=SORT_BY_FIELDS_SALE.keys(),
field_labels=SORT_BY_FIELDS_SALE)
class Meta:
model = Sale
fields = []
def get_summary_message(self):
counter = self.qs.count()
return npgettext(
'Number of matching records in the dashboard sales list',
'Found %(counter)d matching sale',
'Found %(counter)d matching sales',
number=counter) % {
'counter': counter
}
class AllFiltersFilterSet(FilterSet):
number_AllValuesFilter = AllValuesFilter(field_name='number', lookup_expr='exact')
number_AllValuesMultipleFilter_OR = AllValuesMultipleFilter(field_name='number', lookup_expr='exact', conjoined=False) # OR
number_AllValuesMultipleFilter_AND = AllValuesMultipleFilter(field_name='number', lookup_expr='exact', conjoined=True) # AND
number_BaseCSVFilterNumber = BaseCSVFilterNumber(field_name='number', lookup_expr='in')
number_BaseInFilterNumber = BaseInFilterNumber(field_name='number', lookup_expr='in')
number_BaseRangeFilterNumber = BaseRangeFilterNumber(field_name='number', lookup_expr='range')
is_true_BooleanFilter = BooleanFilter(field_name='is_true', lookup_expr='exact')
text_CharFilter = CharFilter(field_name='text', lookup_expr='exact')
number_ChoiceFilter = ChoiceFilter(field_name='number', lookup_expr='exact', choices=NUMBER_CHOICES)
date_DateFilter = DateFilter(field_name='date', lookup_expr='exact')
date_DateFromToRangeFilter = DateFromToRangeFilter(field_name='date', lookup_expr='range')
date_DateRangeFilter = DateRangeFilter(field_name='date', lookup_expr='exact')
date_time_DateTimeFilter = DateTimeFilter(field_name='date_time', lookup_expr='exact')
date_time_DateTimeFromToRangeFilter = DateTimeFromToRangeFilter(field_name='date_time', lookup_expr='range')
duration_DurationFilter = DurationFilter(field_name='duration', lookup_expr='exact')
iso_date_time_IsoDateTimeFilter = IsoDateTimeFilter(field_name='iso_date_time', lookup_expr='lt')
iso_date_time_IsoDateTimeFromToRangeFilter = IsoDateTimeFromToRangeFilter(field_name='iso_date_time', lookup_expr='range')
number_MultipleChoiceFilter_OR = MultipleChoiceFilter(field_name='number', lookup_expr='exact', conjoined=False, choices=NUMBER_CHOICES)
number_MultipleChoiceFilter_AND = MultipleChoiceFilter(field_name='number', lookup_expr='exact', conjoined=True, choices=NUMBER_CHOICES)
number_NumberFilter = NumberFilter(field_name='number', lookup_expr='exact')
number_OrderingFilter = OrderingFilter(fields=('number', 'number'))
number_RangeFilter = RangeFilter(field_name='number', lookup_expr='range')
time_TimeFilter = TimeFilter(field_name='time', lookup_expr='exact')
time_TimeRangeFilter = TimeRangeFilter(field_name='time', lookup_expr='range')
number_TypedChoiceFilter = TypedChoiceFilter(field_name='number', lookup_expr='exact', choices=NUMBER_CHOICES)
text_TypedMultipleChoiceFilter_OR = TypedMultipleChoiceFilter(field_name='number', lookup_expr='exact', conjoined=False, choices=NUMBER_CHOICES)
text_TypedMultipleChoiceFilter_AND = TypedMultipleChoiceFilter(field_name='number', lookup_expr='exact', conjoined=True, choices=NUMBER_CHOICES)
uuid_UUIDFilter = UUIDFilter(field_name='uuid', lookup_expr='exact')
number_LookupChoiceFilter = LookupChoiceFilter(field_name='number')
class Meta:
model = BenchmarkModel
exclude = ['number', 'text', 'is_true', 'date', 'date_time', 'duration']
class PostFilter(django_filters.FilterSet):
title_search = CharFilter(
field_name="post_title",
label="Search:",
lookup_expr='icontains',
widget=forms.TextInput(attrs={'class': 'form-control'}))
start_date = DateFilter(field_name="date",
label="From Date:",
lookup_expr='gte',
widget=forms.DateInput(attrs={
'type': 'date',
'class': 'form-control'
}))
end_date = DateFilter(field_name="date",
label="To Date:",
lookup_expr='lte',
widget=forms.DateInput(attrs={
'type': 'date',
'class': 'form-control'
}))
price = RangeFilter(
field_name="price",
label="Price Range:",
widget=django_filters.widgets.RangeWidget(attrs={
'placeholder': 'Price',
'class': 'form-control',
'color': 'black'
}))
class Meta:
model = gamePost
fields = []
class OrderFilter(SortedFilterSet):
id = NumberFilter(label=pgettext_lazy('Order list filter label', 'ID'))
name_or_email = CharFilter(label=pgettext_lazy('Order list filter label',
'Customer name or email'),
method=filter_by_order_customer)
created = DateFromToRangeFilter(label=pgettext_lazy(
'Order list filter label', 'Placed on'),
name='created',
widget=DateRangeWidget)
status = ChoiceFilter(label=pgettext_lazy('Order list filter label',
'Order status'),
choices=OrderStatus.CHOICES,
empty_label=pgettext_lazy(
'Filter empty choice label', 'All'),
widget=forms.Select)
payment_status = ChoiceFilter(
label=pgettext_lazy('Order list filter label', 'Payment status'),
name='payments__status',
choices=PaymentStatus.CHOICES,
empty_label=pgettext_lazy('Filter empty choice label', 'All'),
widget=forms.Select)
total_net = RangeFilter(label=pgettext_lazy('Order list filter label',
'Total'),
widget=PriceRangeWidget)
sort_by = OrderingFilter(label=pgettext_lazy('Order list filter label',
'Sort by'),
fields=SORT_BY_FIELDS,
field_labels=SORT_BY_FIELDS_LABELS)
class Meta:
model = Order
fields = []
class ItemRangeFilter(FilterSet):
rate = RangeFilter()
date = DateFromToRangeFilter()
class Meta:
model = Item
fields = ['rate', 'no', 'user', 'date']
class ArticleFilter(FilterSet):
genre_choices = (
('A', _('Accessoire')),
('V', _('Vêtement')),
('C', _('Chaussure')),
('S', _('Sous-vêtement')),
)
clients_choices = (
('H', _('Homme')),
('F', _('Femme')),
('M', _('Mixte')),
('E', _('Enfant')),
)
solde_choices = (('S', _('en solde')), )
genre_article = ChoiceFilter(choices=genre_choices,
label=_(u"Article Type"))
type_client = ChoiceFilter(choices=clients_choices, label=_('Client Type'))
solde = ChoiceFilter(choices=solde_choices)
arrivage = ModelChoiceFilter(queryset=Arrivage.objects.all())
marque = ModelChoiceFilter(queryset=Marque.objects.all())
quantity = RangeFilter()
class Meta:
model = Article
fields = {
'name': ['icontains'],
'id': ['exact'],
'quantity': ['lte', 'gte'],
}
