class EventFilters(CustomFilterMixin, django_filters.FilterSet):
date = DateFilter('event_start',
choices=TIME_PERIODS,
empty_label='by status')
q = django_filters.CharFilter('translations__title',
'icontains',
label='Search the directory')
service = django_filters.ModelChoiceFilter(
'services',
label='service',
empty_label='by service',
queryset=Service.objects.published().exclude(
**ADDITIONAL_EXCLUDE.get('service', {})))
category = django_filters.ModelChoiceFilter(
'categories',
label='category',
empty_label='by category',
queryset=Category.objects.exclude(
**ADDITIONAL_EXCLUDE.get('category', {})))
location = django_filters.ModelChoiceFilter(
'locations',
label='location',
empty_label='by location',
queryset=Location.objects.published().exclude(
**ADDITIONAL_EXCLUDE.get('location', {})))
section = django_filters.ModelChoiceFilter(
'app_config',
label='section',
empty_label='by section',
queryset=EventsConfig.objects.filter(show_in_listing=True).exclude(
namespace=EventsConfig.default_namespace).exclude(
**ADDITIONAL_EXCLUDE.get('section', {})))
channel = django_filters.ModelChoiceFilter(
'channel',
label='channel',
empty_label='by channel',
queryset=models.Channel.objects.exclude(
**ADDITIONAL_EXCLUDE.get('channel', {})).order_by('position'))
o = django_filters.OrderingFilter(fields=(('event_start', 'date'), ))
class Meta:
model = models.Event
fields = [
'date', 'q', 'service', 'category', 'section', 'location',
'channel'
]
def __init__(self, values, *args, **kwargs):
super(EventFilters, self).__init__(values, *args, **kwargs)
if UPDATE_SEARCH_DATA_ON_SAVE:
self.filters['q'] = SearchFilter(label='Search the directory')
selects = ['location', 'category', 'service', 'section']
if IS_THERE_COMPANIES:
self.filters['company'] = django_filters.ModelChoiceFilter(
'companies',
label='company',
empty_label='by company',
queryset=Company.objects.exclude(
**ADDITIONAL_EXCLUDE.get('company', {})).order_by('name'))
selects.append('company')
if ADD_FILTERED_CATEGORIES:
for category in ADD_FILTERED_CATEGORIES:
qs = Category.objects.filter(
translations__slug=category[0])[0].get_children().exclude(
**ADDITIONAL_EXCLUDE.get(category[0], {})).order_by(
'translations__name') if Category.objects.filter(
translations__slug=category[0]).exists(
) else Category.objects.none()
name = category[0].replace('-', '_')
self.filters[name] = django_filters.ModelChoiceFilter(
'categories', label=category[1], queryset=qs)
self.filters[name].extra.update(
{'empty_label': 'by %s' % category[1]})
selects.append(name)
self.set_empty_labels(**FILTER_EMPTY_LABELS)
for field in selects:
self.sort_choices(self.filters[field])
def set_empty_labels(self, **kwargs):
for key, value in kwargs.items():
if key in self.filters:
self.filters[key].extra['empty_label'] = value
def sort_choices(self, field):
field = field.field
if isinstance(field.choices,
django_filters.fields.ModelChoiceIterator):
choices = [(obj.pk, str(obj)) for obj in field.choices.queryset]
field.iterator = django_filters.fields.ChoiceIterator
field._set_choices(sorted(choices, key=lambda item: item[1]))
class OrderFilter(CustomFilterSet):
def __init__(self, data=None, queryset=None, *, request=None, prefix=None):
super(OrderFilter, self).__init__(data=data,
queryset=queryset,
request=request,
prefix=prefix)
dates = [
'date', 'proforma_date', 'perm_date', 'payment_date',
'payment_due_date', 'income_date', 'income_due_date'
]
for filt in self.filters:
self.filters[filt].field.widget.attrs.update(
{'class': 'form-control'})
for date in dates:
self.filters[date].field.widget.attrs['class'] += ' report_date '
self.filters['total_qty'].field.widget.attrs['placeholder'] = 'حداقل'
self.filters['order_qty'].field.widget.attrs['placeholder'] = 'حداقل'
self.filters['order_kw'].field.widget.attrs['placeholder'] = 'حداقل'
self.filters['customer'].field.widget.attrs['id'] = 'autocomplete'
total_qty = django_filters.NumberFilter(
field_name="total_qty",
method="filter_total_qty",
label="دستگاه(پیش فاکتور)",
)
customer = django_filters.CharFilter(field_name='customer__name',
label='مشتری',
lookup_expr='icontains')
customer_type = django_filters.ModelChoiceFilter(
field_name='customer__type',
label='صنعت',
lookup_expr='exact',
queryset=Type.objects.all())
agent = django_filters.BooleanFilter(field_name='customer__agent',
label='نماینده',
lookup_expr='exact')
owner = django_filters.ModelChoiceFilter(
queryset=get_user_model().objects.filter(sales_exp=True,
is_active=True),
field_name='owner',
label='کارشناس',
lookup_expr='exact')
kw = JRangeFilter(field_name='reqspec__kw',
label='بازه کیلووات',
method='AND')
voltage = django_filters.NumberFilter(field_name='reqspec__voltage',
label='ولتاژ',
method='AND')
rpm = django_filters.ModelChoiceFilter(queryset=RpmType.objects.all(),
field_name='reqspec__rpm_new',
label='سرعت',
method='AND')
spec_type = django_filters.ModelChoiceFilter(
queryset=ProjectType.objects.all(),
field_name='reqspec__type',
label='نوع پروژه',
method='AND')
im = django_filters.ModelChoiceFilter(queryset=IMType.objects.all(),
field_name='reqspec__im',
label='IM',
method='AND')
ip = django_filters.ModelChoiceFilter(queryset=IPType.objects.all(),
field_name='reqspec__ip',
label='IP',
method='AND')
ic = django_filters.ModelChoiceFilter(queryset=ICType.objects.all(),
field_name='reqspec__ic',
label='IC',
method='AND')
ie = django_filters.ModelChoiceFilter(queryset=IEType.objects.all(),
field_name='reqspec__ie',
label='IE',
method='AND')
issue_type = django_filters.ModelChoiceFilter(
queryset=IssueType.objects.all(),
field_name='xpref__issue_type',
label='دلیل عدم ارسال',
)
is_permit = django_filters.BooleanFilter(label='مجوز',
method='is_permit_method')
has_proforma = django_filters.BooleanFilter(field_name='xpref__id',
label='دارای پیش فاکتور',
lookup_expr='isnull',
exclude=True)
has_payment = django_filters.BooleanFilter(label='دارای واریزی',
method='has_payment_method')
payment_type = django_filters.ModelChoiceFilter(
queryset=PaymentType.objects.all(),
field_name='xpref__payment__type',
label='نحوه واریز',
)
has_income = django_filters.BooleanFilter(label='دارای واریزی',
method='has_income_method')
income_type = django_filters.ModelChoiceFilter(
queryset=PaymentType.objects.all(),
field_name='xpref__incomerow__income__type',
label='نحوه واریز',
)
# Requests.objects.filter(xpref__incomerow__income__type=)
date = JDateFromToRangeFilter(field_name='date_fa', label='تاریخ درخواست')
proforma_date = JDateFromToRangeFilter(field_name='xpref__date_fa',
label='تاریخ پیش فاکتور')
perm_date = JDateFromToRangeFilter(field_name='xpref__perm_date',
label='تاریخ مجوز')
payment_date = JDateFromToRangeFilter(field_name='xpref__payment__date_fa',
label='تاریخ واریز')
payment_due_date = JDateFromToRangeFilter(
field_name='xpref__payment__due_date', label='تاریخ سررسید')
income_date = JDateFromToRangeFilter(
field_name='xpref__incomerow__income__date_fa', label='تاریخ واریز')
income_due_date = JDateFromToRangeFilter(
field_name='xpref__incomerow__income__due_date', label='تاریخ سررسید')
order_qty = django_filters.NumberFilter(
label='دستگاه(درخواست)',
method='qty_min',
)
order_kw = django_filters.NumberFilter(label='کیلووات(درخواست)',
method='order_kw_min')
@staticmethod
def filter_total_qty(queryset, name, value):
ps = Xpref.filter_by_qty_count()
if ps:
queryset = queryset.filter(xpref__in=ps.filter(
qty_remaining__gte=value))
else:
queryset = Requests.objects.none()
return queryset
@staticmethod
def has_payment_method(queryset, field_name, value):
queryset = queryset.annotate(count=Count('xpref__payment__id'))
if value:
return queryset.filter(count__gt=0)
return queryset.filter(count__lte=0)
@staticmethod
def has_income_method(queryset, field_name, value):
queryset = queryset.annotate(count=Count('xpref__incomerow__id'))
if value:
return queryset.filter(count__gt=0)
return queryset.filter(count__lte=0)
@staticmethod
def is_permit_method(queryset, field_name, value):
is_perm = queryset.filter(xpref__perm=True)
if value:
queryset = is_perm
else:
queryset = queryset.exclude(id__in=is_perm)
return queryset
@staticmethod
def qty_min(queryset, field_name, value):
queryset = Requests.get_total_qty(queryset)
return queryset.filter(total_qty__gte=value)
@staticmethod
def order_kw_min(queryset, field_name, value):
queryset = Requests.get_total_kw_qs(queryset)
return queryset.filter(kw_total__gte=value)
def AND(self, queryset, field_name, value):
if not hasattr(self, "groups"):
setattr(self, "groups", {})
self.groups[field_name] = value
query = Q()
for key, value in self.groups.items():
if type(value) == slice:
if value.start is not None and value.stop is not None:
key += '__range'
value = (value.start, value.stop)
elif value.start is not None:
key += '__gte'
value = value.start
elif value.stop is not None:
key += '__lte'
value = value.stop
query &= Q(**{key: value})
return queryset.filter(query)
@property
def qs(self):
parent = super().qs
user = getattr(self.request, 'user', None)
if not user.is_superuser:
parent = parent.filter(Q(owner=user) | Q(colleagues=user))
return parent.filter(is_active=True).distinct()
class Meta:
model = Requests
fields = {'date_fa': ['exact', 'gte', 'lte'], 'number': ['contains']}
class UserFilter(django_filters.FilterSet):
labels = django_filters.ModelChoiceFilter(queryset=Label.objects.all())
class Meta:
model = User
fields = ('labels', )
class PrefixFilterSet(BaseFilterSet, TenancyFilterSet, CustomFieldModelFilterSet, CreatedUpdatedFilterSet):
q = django_filters.CharFilter(
method='search',
label='Search',
)
family = django_filters.NumberFilter(
field_name='prefix',
lookup_expr='family'
)
prefix = MultiValueCharFilter(
method='filter_prefix',
label='Prefix',
)
within = django_filters.CharFilter(
method='search_within',
label='Within prefix',
)
within_include = django_filters.CharFilter(
method='search_within_include',
label='Within and including prefix',
)
contains = django_filters.CharFilter(
method='search_contains',
label='Prefixes which contain this prefix or IP',
)
mask_length = django_filters.NumberFilter(
field_name='prefix',
lookup_expr='net_mask_length'
)
mask_length__gte = django_filters.NumberFilter(
field_name='prefix',
lookup_expr='net_mask_length__gte'
)
mask_length__lte = django_filters.NumberFilter(
field_name='prefix',
lookup_expr='net_mask_length__lte'
)
vrf_id = django_filters.ModelMultipleChoiceFilter(
queryset=VRF.objects.all(),
label='VRF',
)
vrf = django_filters.ModelMultipleChoiceFilter(
field_name='vrf__rd',
queryset=VRF.objects.all(),
to_field_name='rd',
label='VRF (RD)',
)
present_in_vrf_id = django_filters.ModelChoiceFilter(
queryset=VRF.objects.all(),
method='filter_present_in_vrf',
label='VRF'
)
present_in_vrf = django_filters.ModelChoiceFilter(
queryset=VRF.objects.all(),
method='filter_present_in_vrf',
to_field_name='rd',
label='VRF (RD)',
)
region_id = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='site__region',
lookup_expr='in',
label='Region (ID)',
)
region = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='site__region',
lookup_expr='in',
to_field_name='slug',
label='Region (slug)',
)
site_group_id = TreeNodeMultipleChoiceFilter(
queryset=SiteGroup.objects.all(),
field_name='site__group',
lookup_expr='in',
label='Site group (ID)',
)
site_group = TreeNodeMultipleChoiceFilter(
queryset=SiteGroup.objects.all(),
field_name='site__group',
lookup_expr='in',
to_field_name='slug',
label='Site group (slug)',
)
site_id = django_filters.ModelMultipleChoiceFilter(
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
field_name='site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site (slug)',
)
vlan_id = django_filters.ModelMultipleChoiceFilter(
queryset=VLAN.objects.all(),
label='VLAN (ID)',
)
vlan_vid = django_filters.NumberFilter(
field_name='vlan__vid',
label='VLAN number (1-4095)',
)
role_id = django_filters.ModelMultipleChoiceFilter(
queryset=Role.objects.all(),
label='Role (ID)',
)
role = django_filters.ModelMultipleChoiceFilter(
field_name='role__slug',
queryset=Role.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
status = django_filters.MultipleChoiceFilter(
choices=PrefixStatusChoices,
null_value=None
)
tag = TagFilter()
class Meta:
model = Prefix
fields = ['id', 'is_pool']
def search(self, queryset, name, value):
if not value.strip():
return queryset
qs_filter = Q(description__icontains=value)
try:
prefix = str(netaddr.IPNetwork(value.strip()).cidr)
qs_filter |= Q(prefix__net_contains_or_equals=prefix)
except (AddrFormatError, ValueError):
pass
return queryset.filter(qs_filter)
def filter_prefix(self, queryset, name, value):
query_values = []
for v in value:
try:
query_values.append(netaddr.IPNetwork(v))
except (AddrFormatError, ValueError):
pass
return queryset.filter(prefix__in=query_values)
def search_within(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
try:
query = str(netaddr.IPNetwork(value).cidr)
return queryset.filter(prefix__net_contained=query)
except (AddrFormatError, ValueError):
return queryset.none()
def search_within_include(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
try:
query = str(netaddr.IPNetwork(value).cidr)
return queryset.filter(prefix__net_contained_or_equal=query)
except (AddrFormatError, ValueError):
return queryset.none()
def search_contains(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
try:
# Searching by prefix
if '/' in value:
return queryset.filter(prefix__net_contains_or_equals=str(netaddr.IPNetwork(value).cidr))
# Searching by IP address
else:
return queryset.filter(prefix__net_contains=str(netaddr.IPAddress(value)))
except (AddrFormatError, ValueError):
return queryset.none()
def filter_present_in_vrf(self, queryset, name, vrf):
if vrf is None:
return queryset.none
return queryset.filter(
Q(vrf=vrf) |
Q(vrf__export_targets__in=vrf.import_targets.all())
)
class VLANFilterSet(BaseFilterSet, TenancyFilterSet, CustomFieldModelFilterSet, CreatedUpdatedFilterSet):
q = django_filters.CharFilter(
method='search',
label='Search',
)
region_id = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='site__region',
lookup_expr='in',
label='Region (ID)',
)
region = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='site__region',
lookup_expr='in',
to_field_name='slug',
label='Region (slug)',
)
site_group_id = TreeNodeMultipleChoiceFilter(
queryset=SiteGroup.objects.all(),
field_name='site__group',
lookup_expr='in',
label='Site group (ID)',
)
site_group = TreeNodeMultipleChoiceFilter(
queryset=SiteGroup.objects.all(),
field_name='site__group',
lookup_expr='in',
to_field_name='slug',
label='Site group (slug)',
)
site_id = django_filters.ModelMultipleChoiceFilter(
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
field_name='site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site (slug)',
)
group_id = django_filters.ModelMultipleChoiceFilter(
queryset=VLANGroup.objects.all(),
label='Group (ID)',
)
group = django_filters.ModelMultipleChoiceFilter(
field_name='group__slug',
queryset=VLANGroup.objects.all(),
to_field_name='slug',
label='Group',
)
role_id = django_filters.ModelMultipleChoiceFilter(
queryset=Role.objects.all(),
label='Role (ID)',
)
role = django_filters.ModelMultipleChoiceFilter(
field_name='role__slug',
queryset=Role.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
status = django_filters.MultipleChoiceFilter(
choices=VLANStatusChoices,
null_value=None
)
available_on_device = django_filters.ModelChoiceFilter(
queryset=Device.objects.all(),
method='get_for_device'
)
available_on_virtualmachine = django_filters.ModelChoiceFilter(
queryset=VirtualMachine.objects.all(),
method='get_for_virtualmachine'
)
tag = TagFilter()
class Meta:
model = VLAN
fields = ['id', 'vid', 'name']
def search(self, queryset, name, value):
if not value.strip():
return queryset
qs_filter = Q(name__icontains=value) | Q(description__icontains=value)
try:
qs_filter |= Q(vid=int(value.strip()))
except ValueError:
pass
return queryset.filter(qs_filter)
def get_for_device(self, queryset, name, value):
return queryset.get_for_device(value)
def get_for_virtualmachine(self, queryset, name, value):
return queryset.get_for_virtualmachine(value)
class ArtworkFilter(django_filters.FilterSet):
title = django_filters.CharFilter(
field_name='title',
label='Artwork Title',
lookup_expr='icontains'
)
artist = django_filters.ModelChoiceFilter(
field_name='artist',
label='Artist',
queryset = Artist.objects.all().order_by('artist_display_name'),
lookup_expr='exact'
)
art_type = django_filters.ModelChoiceFilter(
field_name='artwork_type',
label='Artwork Type',
queryset = ArtworkType.objects.all().order_by('artwork_type_name'),
lookup_expr='exact'
)
region = django_filters.ModelChoiceFilter(
field_name='region__region_name',
label = 'Region',
queryset = Region.objects.all().order_by('region_name'),
lookup_expr='exact'
)
country = django_filters.ModelChoiceFilter(
field_name='country__country_name',
label = 'Country',
queryset = Country.objects.all().order_by('country_name'),
lookup_expr='exact'
)
city = django_filters.ModelChoiceFilter(
field_name='city__city_name',
label = 'City',
queryset = City.objects.all().order_by('city_name'),
lookup_expr='exact'
)
department = django_filters.ModelChoiceFilter(
field_name='department__department_name',
label = 'MET Department',
queryset = Department.objects.all().order_by('department_name'),
lookup_expr='exact'
)
pub_domain = django_filters.CharFilter(
field_name='is_public_domain',
label='Public Domain? \n' + str(True) + '= Yes / ' + str(False) + '= No',
lookup_expr='icontains'
)
begin_date = django_filters.NumberFilter(
field_name='year_begin',
label='Begin Year',
lookup_expr='icontains'
)
end_date = django_filters.NumberFilter(
field_name='year_end',
label='End Year',
lookup_expr='icontains'
)
# category = django_filters.ModelChoiceFilter(
# field_name='category_name',
# label = 'Heritage Site Category',
# queryset = HeritageSiteCategory.objects.all().order_by('category_name'),
# lookup_expr='exact'
# )
# region = django_filters.ModelChoiceFilter(
# field_name='country_area__location__region__region_name',
# label = 'Region',
# queryset = Region.objects.all().order_by('region_name'),
# lookup_expr='exact'
# )
# sub_region = django_filters.ModelChoiceFilter(
# field_name='country_area__location__sub_region__sub_region_name',
# label = 'SubRegion',
# queryset = SubRegion.objects.all().order_by('sub_region_name'),
# lookup_expr='exact'
# )
# intermediate_region = django_filters.ModelChoiceFilter(
# field_name='country_area__location__intermediate_region__intermediate_region_name',
# label = 'IntermediateRegion',
# queryset = IntermediateRegion.objects.all().order_by('intermediate_region_name'),
# lookup_expr='exact'
# )
#WILL NEED TO INCORPORATE THIS FOR ARTIST
# country_area = django_filters.ModelChoiceFilter(
# field_name='country_area',
# label='Country/Area',
# queryset=CountryArea.objects.all().order_by('country_area_name'),
# lookup_expr='exact'
# )
# date_inscribed = django_filters.NumberFilter(
# field_name = 'date_inscribed',
# label = 'Date Inscribed',
# lookup_expr = 'exact'
# )
class Meta:
model = Artwork
# form = SearchForm
# fields [] is required, even if empty.
fields = []
class MainRequestFilter(HelpfulFilterSet):
number = django_filters.NumberFilter(
label='№',
lookup_expr='exact',
widget=NumberInput(attrs={'new_line': 'true'}))
input_datetime = django_filters.DateTimeFromToRangeFilter(
label='Дата вводда',
lookup_expr='range',
widget=MyRangeWidget(attrs={
'display': 'inline',
'class': 'datepicker-need'
}))
input_user = django_filters.ModelChoiceFilter(
label='Пользователь',
lookup_expr='exact',
queryset=Profile.objects.filter())
request_dateTime = django_filters.DateTimeFromToRangeFilter(
label='Дата подачи заявки',
lookup_expr='range',
widget=MyRangeWidget(attrs={
'display': 'inline',
'class': 'datepicker-need'
}))
request_user = django_filters.ModelChoiceFilter(
label='Подал',
lookup_expr='exact',
queryset=Profile.objects.filter(),
help_text='Можно ввести с клавиатуры')
request_outer_User = django_filters.CharFilter(label='')
receive_dateTime = django_filters.DateTimeFromToRangeFilter(
label='Дата принятия',
lookup_expr='rangdbe',
widget=MyRangeWidget(attrs={
'display': 'inline',
'class': 'datepicker-need'
}))
receive_user = django_filters.ModelChoiceFilter(
label='Принял', lookup_expr='exact', queryset=Profile.objects.filter())
close_dateTime = django_filters.DateTimeFromToRangeFilter(
label='Дата закрытия',
lookup_expr='range',
widget=MyRangeWidget(attrs={
'display': 'inline',
'class': 'datepicker-need'
}))
close_user = django_filters.ModelChoiceFilter(
label='Закрыл', lookup_expr='exact', queryset=Profile.objects.filter())
place = django_filters.ModelChoiceFilter(label='Место',
lookup_expr='exact',
queryset=Places.objects.all())
close_user__isnull = django_filters.BooleanFilter(name='close_user',
label='Только закрытые',
lookup_expr='isnull',
exclude=True)
departure__end_datetime__isnull = django_filters.BooleanFilter(
name='departure__end_datetime',
label='Только с незакрытыми выездами',
lookup_expr='isnull',
method='filter_departures_not_closed')
def filter_departures_not_closed(self, queryset, name, value):
# construct the full lookup expression.
lookup = '__'.join([name, 'isnull'])
l2 = '__'.join(['departure__id', 'isnull'])
ll = ','.join([lookup, l2])
print(value)
if value:
return queryset.filter(departure__id__isnull=False,
departure__end_datetime__isnull=True)
else:
return queryset
#return queryset.filter(**{lookup: False})
# alternatively, it may not be necessary to construct the lookup.
return queryset.filter(published_on__isnull=False)
class Meta:
model = MainRequest
fields = [
'number', 'input_datetime', 'input_user', 'request_dateTime',
'request_user'
]
filter_overrides = {
models.BooleanField: {
'filter_class': django_filters.BooleanFilter,
'extra': lambda f: {
'widget': CheckboxInput,
},
},
}
class ModelChoiceFieldFilterSet(django_filters.FilterSet):
categories = django_filters.ModelChoiceFilter(
label="Category", queryset=Category.objects.all())
class NormaFilterSet(django_filters.FilterSet):
ano = django_filters.ChoiceFilter(required=False,
label='Ano',
choices=choice_anos_com_normas)
ementa = django_filters.CharFilter(
label=_(
'Pesquisar expressões na ementa'),
help_text=_(
'"Para busca no conteúdo das normas, use a Pesquisa Textual"'),
method='filter_ementa'
)
numero = django_filters.CharFilter(
label=_('Número'),
method='filter_numero'
)
apelido = django_filters.CharFilter(lookup_expr='icontains',
label=_('Apelido'))
indexacao = django_filters.CharFilter(lookup_expr='icontains',
label=_('Indexação'))
assuntos = django_filters.ModelChoiceFilter(
queryset=AssuntoNorma.objects.all())
vigencia = django_filters.BooleanFilter(
label='Vigência', method='filter_vigencia')
o = NormaPesquisaOrderingFilter(help_text='')
class Meta(FilterOverridesMetaMixin):
model = NormaJuridica
fields = ['tipo', 'numero', 'ano', 'data', 'data_vigencia',
'data_publicacao', 'ementa', 'assuntos', 'apelido']
def __init__(self, *args, **kwargs):
super(NormaFilterSet, self).__init__(*args, **kwargs)
row1 = to_row([('tipo', 4), ('numero', 4), ('ano', 4)])
row2 = to_row([('ementa', 6), ('assuntos', 6)])
row3 = to_row([('data', 6), ('data_publicacao', 6)])
row4 = to_row([('data_vigencia', 10), ('vigencia', 2)])
row5 = to_row([('o', 4), ('indexacao', 4), ('apelido', 4)])
self.form.helper = SaplFormHelper()
self.form.helper.form_method = 'GET'
self.form.helper.layout = Layout(
Fieldset(_(
'''
Pesquisa de Norma<br>
<small>
<strong class="text-red">TODOS OS CAMPOS SÃO OPCIONAIS!</strong>
</small>
'''),
row1, row2, row3, row4, row5,
form_actions(label='Pesquisar'))
)
def filter_ementa(self, queryset, name, value):
texto = value.split()
q = Q()
for t in texto:
q &= Q(ementa__icontains=t)
return queryset.filter(q)
def filter_vigencia(self, queryset, name, value):
data_atual = timezone.now()
if value:
queryset = queryset.filter(
Q(data_vigencia__lt=data_atual) | Q(data_vigencia__isnull=True))
else:
queryset = queryset.filter(data_vigencia__gt=data_atual)
return queryset
def filter_numero(self, qs, name, value):
value = value.replace('.', '')
value = value.replace(',', '')
if len(value) > 2:
qs = qs.filter(numero__icontains=value)
else:
qs = qs.filter(numero=value)
return qs
class Participantes(django_filters.FilterSet):
login = django_filters.ModelChoiceFilter(queryset=Researcher.objects.values_list('login', flat=True).order_by('login'))
class Meta:
model = Researcher
fields=['login']
class AdicionarVariasMateriasFilterSet(MateriaLegislativaFilterSet):
o = MateriaPesquisaOrderingFilter()
tramitacao__status = django_filters.ModelChoiceFilter(
required=True,
queryset=StatusTramitacao.objects.all(),
label=_('Status da Matéria'))
class Meta:
model = MateriaLegislativa
fields = ['tramitacao__status',
'numero',
'numero_protocolo',
'ano',
'tipo',
'data_apresentacao',
'data_publicacao',
'autoria__autor__tipo',
# FIXME 'autoria__autor__partido',
'relatoria__parlamentar_id',
'local_origem_externa',
'em_tramitacao',
]
def __init__(self, *args, **kwargs):
super(MateriaLegislativaFilterSet, self).__init__(*args, **kwargs)
self.filters['tipo'].label = 'Tipo de Matéria'
self.filters['autoria__autor__tipo'].label = 'Tipo de Autor'
# self.filters['autoria__autor__partido'].label = 'Partido do Autor'
self.filters['relatoria__parlamentar_id'].label = 'Relatoria'
row1 = to_row(
[('tramitacao__status', 12)])
row2 = to_row(
[('tipo', 12)])
row3 = to_row(
[('numero', 4),
('ano', 4),
('numero_protocolo', 4)])
row4 = to_row(
[('data_apresentacao', 6),
('data_publicacao', 6)])
row5 = to_row(
[('autoria__autor', 0),
(Button('pesquisar',
'Pesquisar Autor',
css_class='btn btn-primary btn-sm'), 2),
(Button('limpar',
'limpar Autor',
css_class='btn btn-primary btn-sm'), 10)])
row6 = to_row(
[('autoria__autor__tipo', 6),
# ('autoria__autor__partido', 6)
])
row7 = to_row(
[('relatoria__parlamentar_id', 6),
('local_origem_externa', 6)])
row8 = to_row(
[('em_tramitacao', 6),
('o', 6)])
row9 = to_row(
[('ementa', 12)])
self.form.helper = FormHelper()
self.form.helper.form_method = 'GET'
self.form.helper.layout = Layout(
Fieldset(_('Pesquisa de Matéria'),
row1, row2, row3,
HTML(autor_label),
HTML(autor_modal),
row4, row5, row6, row7, row8, row9,
form_actions(label='Pesquisar'))
)
class ArtworkFilter(django_filters.FilterSet):
artwork_name = django_filters.CharFilter(
field_name='artwork_name',
label='Artwork Name',
lookup_expr='icontains'
)
accession_number = django_filters.CharFilter(
field_name='accession_number',
label='Accession Number',
lookup_expr='exact'
)
artist = django_filters.ModelChoiceFilter(
field_name='artist',
label='Artist',
queryset=Artist.objects.all().order_by('artist_name'),
lookup_expr='exact'
)
artist_role = django_filters.ModelChoiceFilter(
field_name='artist_role',
label='Artist Role',
queryset=ArtistRole.objects.all().order_by('artist_role_name'),
lookup_expr='exact'
)
date_text = django_filters.CharFilter(
field_name='date_text',
label='Date Text',
lookup_expr='icontains'
)
medium = django_filters.CharFilter(
field_name='medium',
label='Medium',
lookup_expr='icontains'
)
credit_line = django_filters.CharFilter(
field_name='credit_line',
label='Credit Line',
lookup_expr='icontains'
)
acquisition_year = django_filters.NumberFilter(
field_name='acquisition_year',
label='Year Acquisited',
lookup_expr='exact'
)
width = django_filters.NumberFilter(
field_name='width',
label='Width',
lookup_expr='exact'
)
height = django_filters.NumberFilter(
field_name='height',
label='Height',
lookup_expr='exact'
)
wdepthidth = django_filters.NumberFilter(
field_name='depth',
label='Depth',
lookup_expr='exact'
)
subject = django_filters.ModelChoiceFilter(
field_name='subject',
label='Subject',
queryset=Subject.objects.all().order_by('subject_name'),
lookup_expr='exact'
)
class Meta:
model = Artwork
# form = SearchForm
# fields [] is required, even if empty.
fields = []
class RelatoriosFilter(django_filters.FilterSet):
nome = django_filters.CharFilter(label='Nome')
orientador = django_filters.ModelChoiceFilter(
queryset=User.objects.filter(groups__name=ORIENTADOR_GROUP_NAME),
label='Orientadores')
created = django_filters.DateFilter(label='Envio')
class MovieFilter(django_filters.FilterSet):
budget = django_filters.RangeFilter(field_name='budget', label='Budget')
homepage = django_filters.CharFilter(field_name='homepage',
label='Homepage',
lookup_expr='icontains')
tmdb_id = django_filters.NumberFilter(field_name='tmdb_id',
label='DMDB ID',
lookup_expr='exact')
original_language = django_filters.CharFilter(
field_name='original_language',
label='Original Language',
lookup_expr='icontains')
original_title = django_filters.CharFilter(field_name='original_title',
label='Original Title',
lookup_expr='icontains')
overview = django_filters.CharFilter(field_name='overview',
label='Overview',
lookup_expr='icontains')
popularity = django_filters.RangeFilter(
field_name='popularity',
label='Popularity ',
)
revenue = django_filters.RangeFilter(
field_name='revenue',
label='Revenue',
)
runtime = django_filters.RangeFilter(
field_name='runtime',
label='Runtime',
)
tagline = django_filters.CharFilter(field_name='tagline',
label='Tagline',
lookup_expr='icontains')
title = django_filters.CharFilter(field_name='title',
label='Title',
lookup_expr='icontains')
vote_average = django_filters.RangeFilter(field_name='vote_average',
label='Vote Average')
vote_count = django_filters.RangeFilter(field_name='vote_count',
label='Vote Count')
genre = django_filters.ModelChoiceFilter(
field_name='genres',
label='Genre',
queryset=Genre.objects.all().order_by('genre_name'),
lookup_expr='exact')
class Meta:
model = Movie
fields = []
class DossierFilter(django_filters.FilterSet):
DOSSIER_STATUS_CHOICES = (
(Dossier.AANGENOMEN, 'Aangenomen'),
(Dossier.VERWORPEN, 'Verworpen'),
(Dossier.INGETROKKEN, 'Ingetrokken'),
(Dossier.IN_BEHANDELING, 'In behandeling'),
(Dossier.ONBEKEND, 'Onbekend'),
)
dossier_id = django_filters.CharFilter(method='dossier_id_filter',
label='')
title = django_filters.CharFilter(method='title_filter', label='')
submitter = django_filters.ModelChoiceFilter(
queryset=Person.objects.all(),
to_field_name='slug',
method='submitter_filter',
label='',
widget=ModelSelect2SlugWidget(url='person-autocomplete'))
wetsvoorstel_submitter = django_filters.ModelChoiceFilter(
queryset=Person.objects.all(),
to_field_name='slug',
method='wetsvoorstel_submitter_filter',
label='',
widget=ModelSelect2SlugWidget(url='person-autocomplete'))
wetsvoorstel_submitter_party = django_filters.ModelChoiceFilter(
queryset=PoliticalParty.objects.all(),
to_field_name='slug',
method='wetsvoorstel_submitter_party_filter',
label='',
widget=ModelSelect2SlugWidget(url='party-autocomplete'))
status = django_filters.ChoiceFilter(
choices=DOSSIER_STATUS_CHOICES,
method='status_filter',
# widget=forms.ChoiceField()
)
categories = django_filters.ModelMultipleChoiceFilter(
queryset=CategoryDossier.objects.all(),
widget=forms.CheckboxSelectMultiple(),
)
class Meta:
model = Dossier
exclude = '__all__'
def title_filter(self, queryset, name, value):
dossiers = queryset.filter(
document__title_full__icontains=value).distinct()
return dossiers
def dossier_id_filter(selfs, queryset, name, value):
return queryset.filter(dossier_id__icontains=value)
def submitter_filter(self, queryset, name, value):
dossiers = queryset.filter(
document__submitter__person=value).distinct()
return dossiers
def wetsvoorstel_submitter_filter(self, queryset, name, value):
submitters = Submitter.objects.filter(person=value)
submitter_ids = list(submitters.values_list('id', flat=True))
kamerstukken = Kamerstuk.objects.filter(
document__submitter__in=submitter_ids, type=Kamerstuk.WETSVOORSTEL)
dossier_ids = list(
kamerstukken.values_list('document__dossier_id', flat=True))
dossiers = queryset.filter(id__in=dossier_ids).distinct()
return dossiers
def wetsvoorstel_submitter_party_filter(self, queryset, name, value):
party = value
submitters = Submitter.objects.filter(party_slug=party.slug)
submitter_ids = list(submitters.values_list('id', flat=True))
kamerstukken = Kamerstuk.objects.filter(
document__submitter__in=submitter_ids, type=Kamerstuk.WETSVOORSTEL)
dossier_ids = list(
kamerstukken.values_list('document__dossier_id', flat=True))
dossiers = queryset.filter(id__in=dossier_ids).distinct()
return dossiers
def status_filter(self, queryset, name, value):
return queryset.filter(status=value)
class TaskFilter(django_filters.FilterSet):
RECORDS_TYPES = (
('', _('Todos')),
('modified', _('Modificados')),
('not_modified', _('No modificados')),
)
RECORD_STATUS = (
('', _('Todos')),
('translated', _('Traducidos')),
('not_translated', _('No traducidos'))
)
usuario = django_filters.ModelChoiceFilter(queryset=TransUser.objects.all(), required=False,
label=_('Usuario'), name='user')
content_type = django_filters.ChoiceFilter(choices=(), required=False, label=_('Clase'))
language = django_filters.ModelChoiceFilter(queryset=TransLanguage.objects.order_by('name'), required=False,
label=_('Idioma'))
record_status = MethodFilter(label=_('Estado'), widget=Select(choices=RECORD_STATUS), required=False)
record_types = MethodFilter(label=_('Tipo registro'), widget=Select(choices=RECORDS_TYPES))
object_pk = django_filters.NumberFilter(required=False, label=_('Clave'))
dates = django_filters.DateFromToRangeFilter(label=_('Rango de fechas'), required=False, name='date_modification')
class Meta:
model = TransTask
fields = ('usuario', 'language', 'content_type', 'record_types', 'record_status', 'object_pk', 'dates')
@staticmethod
def filter_record_status(queryset, value):
if value == 'translated':
return queryset.extra(
where=["object_field_value_translation IS NOT NULL AND object_field_value_translation !=''"]
)
elif value == 'not_translated':
return queryset.extra(
where=["object_field_value_translation IS NULL OR object_field_value_translation =''"]
)
return queryset
@staticmethod
def filter_record_types(queryset, value):
if value == 'modified':
return queryset.extra(
where=["to_char(date_creation, 'YY-MM-DD HH24:MI')!=to_char(date_modification, 'YY-MM-DD HH24:MI')"]
)
elif value == 'not_modified':
return queryset.extra(
where=["to_char(date_creation, 'YY-MM-DD HH24:MI')=to_char(date_modification, 'YY-MM-DD HH24:MI')"]
)
return queryset
@staticmethod
def filter_object_field_label(queryset, value):
if not value:
return queryset
obj_class, obj_field = value.split('__')
return queryset.filter(object_class=obj_class, object_field=obj_field)
def __init__(self, data=None, queryset=None, prefix=None, strict=None, user=None):
super().__init__(data, queryset, prefix, strict)
self.filters['content_type'].extra['choices'] = self.get_choices_for_models()
if not user:
return
del self.filters['usuario']
languages = user.languages.all()
if languages:
num = languages.count()
if num > 1:
self.filters['language'].extra['queryset'] = languages
elif num == 1:
del self.filters['language']
@staticmethod
def get_choices_for_models():
"""
Get the select choices for models in optgroup mode
:return:
"""
result = {}
apps = [item.model.split(' - ')[0] for item in TransModelLanguage.objects.all()]
qs = ContentType.objects.exclude(model__contains='translation').filter(app_label__in=apps).order_by(
'app_label', 'model'
)
for ct in qs:
if not issubclass(ct.model_class(), TranslatableModel):
continue
if ct.app_label not in result:
result[ct.app_label] = []
result[ct.app_label].append((
ct.id, str(ct.model_class()._meta.verbose_name_plural)
))
choices = [(str(_('Todas las clases')), (('', _('Todas las clases')),))]
for key, value in result.items():
choices.append((key, tuple([it for it in sorted(value, key=lambda el: el[1])])))
return choices
class ExperimentFilterset(filters.FilterSet):
search = filters.CharFilter(
method="filter_search",
widget=SearchWidget(
attrs={"class": "form-control", "placeholder": "Search Experiments"}
),
)
type = filters.ChoiceFilter(
empty_label="All Types",
choices=Experiment.TYPE_CHOICES,
widget=forms.Select(attrs={"class": "form-control"}),
)
status = filters.ChoiceFilter(
empty_label="All Statuses",
choices=Experiment.STATUS_CHOICES,
widget=forms.Select(attrs={"class": "form-control"}),
)
firefox_channel = filters.ChoiceFilter(
empty_label="All Channels",
choices=Experiment.CHANNEL_CHOICES[1:],
widget=forms.Select(attrs={"class": "form-control"}),
)
firefox_version = filters.ChoiceFilter(
empty_label="All Versions",
choices=Experiment.VERSION_CHOICES[1:],
widget=forms.Select(attrs={"class": "form-control"}),
method="version_filter",
)
owner = filters.ModelChoiceFilter(
empty_label="All Owners",
queryset=get_user_model().objects.all().order_by("email"),
widget=forms.Select(attrs={"class": "form-control"}),
)
archived = filters.BooleanFilter(
label="Show archived experiments", widget=forms.CheckboxInput()
)
experiment_date_field = filters.ChoiceFilter(
empty_label="No Date Restriction",
choices=[
(Experiment.EXPERIMENT_STARTS, "Experiment Starts"),
(Experiment.EXPERIMENT_PAUSES, "Experiment Pauses"),
(Experiment.EXPERIMENT_ENDS, "Experiment Ends"),
],
widget=forms.Select(attrs={"class": "form-control"}),
method="experiment_date_field_filter",
)
date_range = filters.DateFromToRangeFilter(
method="date_range_filter",
widget=DateRangeWidget(attrs={"type": "date", "class": "form-control"}),
)
in_qa = filters.BooleanFilter(
label="Show only experiments in QA",
widget=forms.CheckboxInput(),
method="in_qa_filter",
)
surveys = filters.BooleanFilter(
label="Show experiments with surveys",
widget=forms.CheckboxInput(),
method="surveys_filter",
)
subscribed = filters.BooleanFilter(
label="Show subscribed experiments",
widget=forms.CheckboxInput(),
method="subscribed_filter",
)
longrunning = filters.BooleanFilter(
label="Show long-running experiments",
widget=forms.CheckboxInput(),
method="longrunning_filter",
)
is_paused = filters.BooleanFilter(
label="Show enrollment complete experiments",
widget=forms.CheckboxInput(),
method="is_paused_filter",
)
class Meta:
model = Experiment
form = ExperimentFiltersetForm
fields = ExperimentFiltersetForm.Meta.fields
def filter_search(self, queryset, name, value):
vector = SearchVector(
"name",
"short_description",
"owner__email",
"slug",
"related_work",
"addon_experiment_id",
"pref_key",
"public_name",
"public_description",
"objectives",
"analysis",
"analysis_owner",
"engineering_owner",
"bugzilla_id",
"normandy_slug",
"data_science_bugzilla_url",
"feature_bugzilla_url",
)
query = SearchQuery(value)
return (
queryset.annotate(rank=SearchRank(vector, query), search=vector)
.filter(search=value)
.order_by("-rank")
)
def experiment_date_field_filter(self, queryset, name, value):
# this custom method isn't doing anything. There has to
# be a custom method to be able to display the select
# filter that controls which date range we show
return queryset
def version_filter(self, queryset, name, value):
return queryset.filter(
Q(firefox_min_version__lte=value, firefox_max_version__gte=value)
| Q(firefox_min_version=value)
)
def date_range_filter(self, queryset, name, value):
date_type = self.form.cleaned_data["experiment_date_field"]
experiment_date_field = {
Experiment.EXPERIMENT_STARTS: "start_date",
Experiment.EXPERIMENT_PAUSES: "enrollment_end_date",
Experiment.EXPERIMENT_ENDS: "end_date",
}[date_type]
results = []
for experiment in queryset.all():
date = getattr(experiment, experiment_date_field)
# enrollment end dates are optional, so there won't always
# be a pause date for an experiment
if date:
if value.start and date < value.start.date():
continue
if value.stop and date > value.stop.date():
continue
results.append(experiment.id)
return queryset.filter(pk__in=results)
def in_qa_filter(self, queryset, name, value):
if value:
return queryset.filter(review_qa_requested=True, review_qa=False)
return queryset
def surveys_filter(self, queryset, name, value):
if value:
return queryset.filter(survey_required=True)
return queryset
def subscribed_filter(self, queryset, name, value):
if value:
return queryset.filter(subscribers__in=[self.request.user.id])
return queryset
def longrunning_filter(self, queryset, name, value):
if value:
return (
queryset.exclude(firefox_max_version__exact="")
.annotate(
firefox_min_int=Cast(
Func(
F("firefox_min_version"),
Value(ExperimentConstants.VERSION_REGEX.pattern),
function="substring",
),
IntegerField(),
),
firefox_max_int=Cast(
Func(
F("firefox_max_version"),
Value(ExperimentConstants.VERSION_REGEX.pattern),
function="substring",
),
IntegerField(),
),
version_count=F("firefox_max_int") - F("firefox_min_int"),
)
.filter(version_count__gte=3)
)
return queryset
def is_paused_filter(self, queryset, name, value):
if value:
return queryset.filter(is_paused=True, status=Experiment.STATUS_LIVE)
return queryset
class TraineeFilter(AMYFilterSet):
search = django_filters.CharFilter(
method=filter_trainees_by_trainee_name_or_email,
label='Name or Email')
all_persons = django_filters.BooleanFilter(
label='Include all people, not only trainees',
method=filter_all_persons,
widget=widgets.CheckboxInput)
homework = django_filters.BooleanFilter(
label='Only trainees with unevaluated homework',
widget=widgets.CheckboxInput,
method=filter_trainees_by_unevaluated_homework_presence,
)
training_request = django_filters.BooleanFilter(
label='Is training request present?',
method=filter_trainees_by_training_request_presence,
)
is_instructor = django_filters.ChoiceFilter(
label='Is SWC/DC instructor?',
method=filter_trainees_by_instructor_status,
choices=[
('', 'Unknown'),
('swc-and-dc', 'Both SWC and DC'),
('swc-or-dc', 'SWC or DC '),
('swc', 'SWC instructor'),
('dc', 'DC instructor'),
('eligible', 'No, but eligible to be certified'),
('no', 'No'),
]
)
training = django_filters.ModelChoiceFilter(
queryset=Event.objects.ttt(),
method=filter_trainees_by_training,
label='Training',
widget=ModelSelect2(
url='ttt-event-lookup',
attrs=SIDEBAR_DAL_WIDTH,
),
)
order_by = NamesOrderingFilter(
fields=(
'last_login',
'email',
),
)
class Meta:
model = Person
fields = [
'search',
'all_persons',
'homework',
'is_instructor',
'training',
]
class BaseFoiRequestFilterSet(BaseSearchFilterSet):
query_fields = ['title^5', 'description^3', 'content']
q = django_filters.CharFilter(
method='auto_query',
widget=forms.TextInput(attrs={
'placeholder': _('Search requests'),
'class': 'form-control'
}),
)
FOIREQUEST_FILTER_DICT = FOIREQUEST_FILTER_DICT
status = django_filters.ChoiceFilter(
choices=FOIREQUEST_LIST_FILTER_CHOICES,
label=_('status'),
empty_label=_('any status'),
widget=DropDownStatusFilterWidget(attrs={
'label': _('status'),
'class': 'form-control'
}),
method='filter_status',
)
jurisdiction = django_filters.ModelChoiceFilter(
queryset=Jurisdiction.objects.get_visible(),
to_field_name='slug',
empty_label=_('all jurisdictions'),
widget=forms.Select(attrs={
'label': _('jurisdiction'),
'class': 'form-control'
}),
method='filter_jurisdiction')
category = django_filters.ModelChoiceFilter(
queryset=Category.objects.get_category_list(),
to_field_name='slug',
empty_label=_('all categories'),
widget=forms.Select(attrs={
'label': _('category'),
'class': 'form-control'
}),
method='filter_category')
campaign = django_filters.ModelChoiceFilter(
queryset=Campaign.objects.get_filter_list(),
to_field_name='slug',
null_value='-',
empty_label=_('all/no campaigns'),
null_label=_('no campaign'),
widget=forms.Select(attrs={
'label': _('campaign'),
'class': 'form-control'
}),
method='filter_campaign')
tag = django_filters.ModelChoiceFilter(queryset=Tag.objects.all(),
to_field_name='slug',
method='filter_tag',
widget=forms.HiddenInput())
publicbody = django_filters.ModelChoiceFilter(
queryset=PublicBody._default_manager.all(),
to_field_name='slug',
method='filter_publicbody',
widget=forms.HiddenInput())
user = django_filters.ModelChoiceFilter(
queryset=User.objects.get_public_profiles(),
to_field_name='username',
method='filter_user',
widget=forms.HiddenInput())
first = django_filters.DateFromToRangeFilter(
method='filter_first',
widget=DateRangeWidget,
)
last = django_filters.DateFromToRangeFilter(method='filter_last',
widget=DateRangeWidget)
sort = django_filters.ChoiceFilter(
choices=[
('-last', _('last message (newest first)')),
('last', _('last message (oldest first)')),
('-first', _('request date (newest first)')),
('first', _('request date (oldest first)')),
],
label=_('sort'),
empty_label=_('default sort'),
widget=forms.Select(attrs={
'label': _('sort'),
'class': 'form-control'
}),
method='add_sort',
)
class Meta:
model = FoiRequest
fields = [
'q', 'status', 'jurisdiction', 'campaign', 'category', 'tag',
'publicbody', 'first'
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if self.view is not None:
self.filters[
'status'].field.widget.get_url = self.view.make_filter_url
def auto_query(self, qs, name, value):
if value:
return qs.set_query(
Q("simple_query_string",
query=value,
fields=self.query_fields,
default_operator='and',
lenient=True))
return qs
def filter_status(self, qs, name, value):
parts = self.FOIREQUEST_FILTER_DICT[value]
func = parts[0]
status_name = parts[1]
return qs.filter(func(status_name))
def filter_jurisdiction(self, qs, name, value):
return qs.filter(jurisdiction=value.id)
def filter_campaign(self, qs, name, value):
if value == '-':
return qs.filter(
Q('bool', must_not={'exists': {
'field': 'campaign'
}}))
return qs.filter(campaign=value.id)
def filter_category(self, qs, name, value):
return qs.filter(categories=value.id)
def filter_tag(self, qs, name, value):
return qs.filter(tags=value.id)
def filter_publicbody(self, qs, name, value):
return qs.filter(publicbody=value.id)
def filter_user(self, qs, name, value):
return qs.filter(user=value.id)
def filter_first(self, qs, name, value):
range_kwargs = {}
if value.start is not None:
range_kwargs['gte'] = value.start
if value.stop is not None:
range_kwargs['lte'] = value.stop
return qs.filter(Q('range', first_message=range_kwargs))
def filter_last(self, qs, name, value):
range_kwargs = {}
if value.start is not None:
range_kwargs['gte'] = value.start
if value.stop is not None:
range_kwargs['lte'] = value.stop
return qs.filter(Q('range', last_message=range_kwargs))
def add_sort(self, qs, name, value):
if value:
return qs.add_sort('%s_message' % value)
return qs
class PersonFilter(django_filters.FilterSet):
WORKAUTHORIZATION_CHOICES = (('Citizenship', 'Citizenship'),
('Permanent Resident',
'Permanent Resident'), ('Visa', 'Visa'))
TYPERESUME_CHOICES = (('Employee', 'Employee'), ('Intern', 'Intern'),
('Prospective Employee', 'Prospective Employee'),
('Prospective Intern', 'Prospective Intern'))
TypeResume = django_filters.ChoiceFilter(name='TypeResume',
choices=TYPERESUME_CHOICES)
UploadDate = django_filters.DateFilter(name='CreationDate',input_formats=['%Y-%m-%d', '%m-%d-%Y', '%Y/%m/%d','%m/%d/%Y', '%Y%m%d', '%m%d%Y']\
, lookup_expr='icontains')
SchoolAttend = django_filters.ModelChoiceFilter(
name='persontoschool__SchoolID',
queryset=School.objects.all().order_by('Name'),
to_field_name='Name')
GraduateDate = django_filters.ModelChoiceFilter(
name='persontoschool__GradDate',
queryset=PersonToSchool.objects.values_list(
'GradDate', flat=True).distinct().order_by('GradDate'),
to_field_name='GradDate')
Major = django_filters.ModelChoiceFilter(
name='persontoschool__MajorID',
queryset=Major.objects.all().order_by('Name').distinct())
DegreeLevel = django_filters.ModelChoiceFilter(
name='persontoschool__SchoolID__DegreeLevel',
queryset=School.objects.values_list('DegreeLevel',
flat=True).distinct(),
to_field_name='DegreeLevel')
GPAlb = django_filters.NumberFilter(name='persontoschool__GPA',
lookup_expr='gte')
GPAub = django_filters.NumberFilter(name='persontoschool__GPA',
lookup_expr='lt')
Coursework = django_filters.ModelMultipleChoiceFilter(
name='persontocourse__Desc',
queryset=PersonToCourse.objects.distinct().order_by('Desc'),
widget=autocomplete.ModelSelect2Multiple(
url='RSR:Coursework-autocomplete'))
Language = django_filters.ModelMultipleChoiceFilter(
name='persontolanguage__LangID',
queryset=LanguageSpoken.objects.all(),
widget=autocomplete.ModelSelect2Multiple(
url='RSR:LanguageSpoken-autocomplete'))
Skills = django_filters.ModelMultipleChoiceFilter(
name='persontoskills__SkillsID',
queryset=Skills.objects.all().order_by('Name').distinct(),
widget=autocomplete.ModelSelect2Multiple(
url='RSR:Skills-autocomplete'))
Skills_AND = django_filters.ModelMultipleChoiceFilter(
name='persontoskills__SkillsID',
queryset=Skills.queryset.order_by('Name').distinct(),
widget=autocomplete.ModelSelect2Multiple(
url='RSR:Skills-autocomplete'),
conjoined=True)
YearOfExperienceForSkill = django_filters.ModelChoiceFilter(
name='persontoskills__YearsOfExperience',
lookup_expr='gte',
queryset=PersonToSkills.objects.values_list(
'YearsOfExperience',
flat=True).order_by('YearsOfExperience').distinct(),
to_field_name='YearsOfExperience')
ProfessionalDevelopment = django_filters.ModelMultipleChoiceFilter(
name='persontoprofessionaldevelopment__ProfID',
queryset=ProfessionalDevelopment.objects.all().order_by('Name'),
widget=autocomplete.ModelSelect2Multiple(
url='RSR:ProfessionalDevelopment-autocomplete'))
Award = django_filters.ModelMultipleChoiceFilter(
name='persontoawards__AwardID',
queryset=Awards.objects.all().order_by('Name').distinct(),
widget=autocomplete.ModelSelect2Multiple(
url='RSR:Awards-autocomplete'))
CompanyWorked = django_filters.ModelMultipleChoiceFilter(
name='persontocompany__CompanyID',
queryset=Company.objects.all().order_by('Name').distinct(),
widget=autocomplete.ModelSelect2Multiple(
url='RSR:Company-autocomplete'))
Title = django_filters.ModelMultipleChoiceFilter(
name='persontocompany__Title',
queryset=PersonToCompany.objects.order_by('Title').distinct(),
widget=autocomplete.ModelSelect2Multiple(url='RSR:Title-autocomplete'))
Volunteering = django_filters.ModelMultipleChoiceFilter(
name='persontovolunteering__VolunID',
queryset=Volunteering.objects.all().distinct().order_by('Name'),
widget=autocomplete.ModelSelect2Multiple(
url='RSR:Volunteering-autocomplete'))
Club_Hobby = django_filters.ModelChoiceFilter(
name='persontoclubshobbies_set__CHID',
queryset=Clubs_Hobbies.objects.all().distinct().order_by('Name'),
to_field_name='Name')
SecurityClearance = django_filters.ModelChoiceFilter(
name='persontoclearance__ClearanceLevel',
queryset=Clearance.objects.all().distinct())
WorkAuthorization = django_filters.ChoiceFilter(
name='WorkAuthorization', choices=WORKAUTHORIZATION_CHOICES)
Name = django_filters.ModelMultipleChoiceFilter(
name='Name',
queryset=Person.objects.all(),
widget=autocomplete.ModelSelect2Multiple(url='RSR:Name-autocomplete'))
class Meta:
model = Person
fields = [
'SchoolAttend', 'GraduateDate', 'Major', 'DegreeLevel', 'GPAlb',
'GPAub', 'Language', 'Skills', 'YearOfExperienceForSkill',
'ProfessionalDevelopment', 'Award', 'CompanyWorked', 'Title',
'SecurityClearance', 'Volunteering', 'Club_Hobby', 'TypeResume',
'UploadDate', 'Name', 'Skills_AND'
]
class PageDocumentFilterset(BaseSearchFilterSet):
query_fields = ['title^3', 'description^2', 'content']
campaign = django_filters.ModelChoiceFilter(
queryset=Campaign.objects.get_filter_list(),
to_field_name='slug',
null_value='-',
empty_label=_('all/no campaigns'),
null_label=_('no campaign'),
widget=forms.Select(
attrs={
'label': _('campaign'),
'class': 'form-control'
}
),
method='filter_campaign'
)
jurisdiction = django_filters.ModelChoiceFilter(
queryset=Jurisdiction.objects.get_visible(),
to_field_name='slug',
empty_label=_('all jurisdictions'),
widget=forms.Select(
attrs={
'label': _('jurisdiction'),
'class': 'form-control'
}
),
method='filter_jurisdiction'
)
tag = django_filters.ModelChoiceFilter(
queryset=Tag.objects.all(),
to_field_name='slug',
method='filter_tag',
widget=forms.HiddenInput()
)
publicbody = django_filters.ModelChoiceFilter(
queryset=PublicBody._default_manager.all(),
to_field_name='slug',
method='filter_publicbody',
widget=forms.HiddenInput()
)
collection = django_filters.ModelChoiceFilter(
queryset=None,
to_field_name='pk',
method='filter_collection',
widget=forms.HiddenInput()
)
portal = django_filters.ModelChoiceFilter(
queryset=DocumentPortal.objects.filter(public=True),
to_field_name='pk',
method='filter_portal',
widget=forms.HiddenInput()
)
document = django_filters.ModelChoiceFilter(
queryset=None,
to_field_name='pk',
method='filter_document',
widget=forms.HiddenInput()
)
user = django_filters.ModelChoiceFilter(
queryset=User.objects.get_public_profiles(),
to_field_name='username',
method='filter_user',
widget=forms.HiddenInput()
)
class Meta:
model = Page
fields = [
'q', 'jurisdiction', 'campaign',
'tag', 'publicbody', 'collection',
'number', 'user', 'portal'
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
request = kwargs.get('request')
if request is None:
request = self.view.request
document_qs = get_document_read_qs(request)
collection_qs = get_read_queryset(
DocumentCollection.objects.all(), request,
has_team=True, public_field='public',
scope='read:document'
)
self.filters['collection'].field.queryset = collection_qs
self.filters['document'].field.queryset = document_qs
def filter_jurisdiction(self, qs, name, value):
return qs.filter(jurisdiction=value.id)
def filter_campaign(self, qs, name, value):
if value == '-':
return qs.filter(
Q('bool', must_not={
'exists': {'field': 'campaign'}
})
)
return qs.filter(campaign=value.id)
def filter_tag(self, qs, name, value):
return qs.filter(tags=value.id)
def filter_publicbody(self, qs, name, value):
return qs.filter(publicbody=value.id)
def filter_collection(self, qs, name, value):
return qs.filter(collections=value.id)
def filter_portal(self, qs, name, value):
return qs.filter(portal=value.id)
def filter_document(self, qs, name, value):
return qs.filter(document=value.id)
def filter_user(self, qs, name, value):
return qs.filter(user=value.id)
import django_filters
from django.db.models import Q
from .models import Record, Experiment, Extraction
from lab.models import Project
import lab.filters as filters
from django.utils.timezone import now
from datetime import timedelta
filtered_project = django_filters.ModelChoiceFilter(\
queryset=Project.objects.all().exclude(\
Q(expired__exact=True)&Q(expired_date__lt=now()-timedelta(days=365))))
class RecordFilter(filters.RecordFilter):
project = filtered_project
experiment = django_filters.ModelChoiceFilter(
queryset=Experiment.objects.all(), empty_label='All Experiments')
class Meta(filters.RecordFilter.Meta):
model = Record
class RecordFilterFull(django_filters.FilterSet):
project = filtered_project
class Meta:
model = Record
fields = tuple([f.name for f in Record._meta.fields])
class IPAddressFilterSet(BaseFilterSet, TenancyFilterSet, CustomFieldModelFilterSet, CreatedUpdatedFilterSet):
q = django_filters.CharFilter(
method='search',
label='Search',
)
family = django_filters.NumberFilter(
field_name='address',
lookup_expr='family'
)
parent = django_filters.CharFilter(
method='search_by_parent',
label='Parent prefix',
)
address = MultiValueCharFilter(
method='filter_address',
label='Address',
)
mask_length = django_filters.NumberFilter(
method='filter_mask_length',
label='Mask length',
)
vrf_id = django_filters.ModelMultipleChoiceFilter(
queryset=VRF.objects.all(),
label='VRF',
)
vrf = django_filters.ModelMultipleChoiceFilter(
field_name='vrf__rd',
queryset=VRF.objects.all(),
to_field_name='rd',
label='VRF (RD)',
)
present_in_vrf_id = django_filters.ModelChoiceFilter(
queryset=VRF.objects.all(),
method='filter_present_in_vrf',
label='VRF'
)
present_in_vrf = django_filters.ModelChoiceFilter(
queryset=VRF.objects.all(),
method='filter_present_in_vrf',
to_field_name='rd',
label='VRF (RD)',
)
device = MultiValueCharFilter(
method='filter_device',
field_name='name',
label='Device (name)',
)
device_id = MultiValueNumberFilter(
method='filter_device',
field_name='pk',
label='Device (ID)',
)
virtual_machine = MultiValueCharFilter(
method='filter_virtual_machine',
field_name='name',
label='Virtual machine (name)',
)
virtual_machine_id = MultiValueNumberFilter(
method='filter_virtual_machine',
field_name='pk',
label='Virtual machine (ID)',
)
interface = django_filters.ModelMultipleChoiceFilter(
field_name='interface__name',
queryset=Interface.objects.all(),
to_field_name='name',
label='Interface (name)',
)
interface_id = django_filters.ModelMultipleChoiceFilter(
field_name='interface',
queryset=Interface.objects.all(),
label='Interface (ID)',
)
vminterface = django_filters.ModelMultipleChoiceFilter(
field_name='vminterface__name',
queryset=VMInterface.objects.all(),
to_field_name='name',
label='VM interface (name)',
)
vminterface_id = django_filters.ModelMultipleChoiceFilter(
field_name='vminterface',
queryset=VMInterface.objects.all(),
label='VM interface (ID)',
)
assigned_to_interface = django_filters.BooleanFilter(
method='_assigned_to_interface',
label='Is assigned to an interface',
)
status = django_filters.MultipleChoiceFilter(
choices=IPAddressStatusChoices,
null_value=None
)
role = django_filters.MultipleChoiceFilter(
choices=IPAddressRoleChoices
)
tag = TagFilter()
class Meta:
model = IPAddress
fields = ['id', 'dns_name']
def search(self, queryset, name, value):
if not value.strip():
return queryset
qs_filter = (
Q(dns_name__icontains=value) |
Q(description__icontains=value) |
Q(address__istartswith=value)
)
return queryset.filter(qs_filter)
def search_by_parent(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
try:
query = str(netaddr.IPNetwork(value.strip()).cidr)
return queryset.filter(address__net_host_contained=query)
except (AddrFormatError, ValueError):
return queryset.none()
def filter_address(self, queryset, name, value):
try:
return queryset.filter(address__net_in=value)
except ValidationError:
return queryset.none()
def filter_mask_length(self, queryset, name, value):
if not value:
return queryset
return queryset.filter(address__net_mask_length=value)
def filter_present_in_vrf(self, queryset, name, vrf):
if vrf is None:
return queryset.none
return queryset.filter(
Q(vrf=vrf) |
Q(vrf__export_targets__in=vrf.import_targets.all())
)
def filter_device(self, queryset, name, value):
devices = Device.objects.filter(**{'{}__in'.format(name): value})
if not devices.exists():
return queryset.none()
interface_ids = []
for device in devices:
interface_ids.extend(device.vc_interfaces.values_list('id', flat=True))
return queryset.filter(
interface__in=interface_ids
)
def filter_virtual_machine(self, queryset, name, value):
virtual_machines = VirtualMachine.objects.filter(**{'{}__in'.format(name): value})
if not virtual_machines.exists():
return queryset.none()
interface_ids = []
for vm in virtual_machines:
interface_ids.extend(vm.interfaces.values_list('id', flat=True))
return queryset.filter(
vminterface__in=interface_ids
)
def _assigned_to_interface(self, queryset, name, value):
return queryset.exclude(assigned_object_id__isnull=value)
class ListingFilter(django_filters.FilterSet):
keyword = django_filters.CharFilter(label=_('Keyword'), method=lambda qs, name, value: qs.by_keyword(value))
price = SliderFilter(label=_('Price'), min_value=0, max_value=1000, step=10, appended_text=' €', has_range=True, show_inputs=False, queryset_method='published', segment='listings.Listing.price')
locality = django_filters.ModelChoiceFilter(
label=_('Locality'),
queryset=Locality.objects.all(),
to_field_name='slug',
widget=ModelSelect2Widget(
model=Locality,
queryset=Locality.objects.all(),
search_fields=['title__icontains'],
data_view='auto-slug-json',
attrs={'data-minimum-input-length': 0}
)
)
class Meta:
model = Listing
fields = [
'keyword',
'promoted',
'locality',
'price',
'categories', 'features'
]
filter_overrides = {
models.CharField: {
'filter_class': django_filters.CharFilter,
'extra': lambda f: {
'lookup_expr': 'icontains',
},
},
models.TextField: {
'filter_class': django_filters.CharFilter,
'extra': lambda f: {
'lookup_expr': 'icontains',
},
},
models.BooleanField: {
'filter_class': PositiveBooleanFilter,
'extra': lambda f: {
'widget': forms.CheckboxInput,
},
},
}
def __init__(self, listing_type=None, lexicon=None, inheritance=False, *args, **kwargs):
super().__init__(*args, **kwargs)
self.helper = SingleSubmitFormHelper()
self.helper.form_tag = False
self.helper.disable_csrf = True
self.helper.layout = Layout(
'keyword',
'promoted',
'locality',
'price',
'duration',
'categories', 'features'
)
self.form.fields['locality'].empty_label = _('All localities')
if not Listing.objects.published().promoted().exists():
self.form.fields['promoted'].widget = HiddenInput()
if not self.form.fields['locality'].queryset.exists():
self.form.fields['locality'].widget = HiddenInput()
# categories, localities and features searched by slug
# self.filters['categories'].field_name = 'categories__slug_i18n'
self.filters['categories'].method = 'filter_categories' # search by nested categories as well
self.filters['features'].field_name = 'features__slug_i18n'
self.filters['features'].conjoined = True # changed filter logic of features
# by default, show all parent categories in the filter:
# self.form.fields['categories'].queryset = Category.objects.filter(parent=None)
# self.form.fields['categories'].queryset = Category.objects.all() # use this with TreeNodeMultipleChoiceField only
if listing_type:
# dynamic categories
listing_type_categories = Category.objects.of_listing_type(listing_type)
if listing_type_categories.exists():
self.form.fields['categories'].queryset = listing_type_categories
if listing_type_categories.exclude(parent=None).exists():
self.form.fields['categories'].queryset = listing_type_categories.exclude(parent=None)
# dynamic price segment based on listing type
segment = f'listings.{listing_type.__name__}.price'
self.filters['price'].init_segments(segment)
self.form.fields['price'] = self.filters['price'].field
# hide price if not required
if not Listing.objects.published().with_price().exists():
self.form.fields['price'].widget = HiddenInput()
# Exercise duration
try:
listing_type._meta.get_field('duration')
self._meta.fields.append('duration')
segment = f'listings.{listing_type.__name__}.duration'
field_prefix = f'{listing_type.__name__.lower()}__' if inheritance else ''
self.filters['duration'] = SliderFilter(
label=_('Duration'), min_value=5, max_value=60, step=5, appended_text='min',
has_range=True, show_inputs=False, queryset_method='published', segment=segment, field_name=f'{field_prefix}duration'
)
self.filters['duration'].init_segments(segment)
self.form.fields['duration'] = self.filters['duration'].field
except FieldDoesNotExist:
pass # do not add duration if it does not exist
else:
self.form.fields['categories'].queryset = Category.objects.all() # use this with TreeNodeMultipleChoiceField only
if not self.form.fields['categories'].queryset.exists():
self.form.fields['categories'].widget = HiddenInput()
else:
# self.form.fields['categories'] = forms.MultipleChoiceField(
# label=_('Categories'),
# choices=list(self.form.fields['categories'].queryset.values_list('slug_i18n', 'title_i18n')), # TODO: cache?
# required=False,
# widget=forms.CheckboxSelectMultiple
# )
categories_widget = self.get_widget_by_settings('categories')
categories_field = TreeNodeMultipleChoiceField if categories_widget == forms.CheckboxSelectMultiple else TreeNodeChoiceField
self.form.fields['categories'] = categories_field(
label=_('Categories'),
queryset=self.form.fields['categories'].queryset,
to_field_name='slug_i18n',
required=False,
widget=categories_widget,
level_indicator=''
)
if not self.form.fields['features'].queryset.exists():
self.form.fields['features'].widget = HiddenInput()
else:
self.form.fields['features'] = forms.MultipleChoiceField(
label=_('Features'),
choices=list(self.form.fields['features'].queryset.values_list('slug_i18n', 'title')), # TODO: cache?
required=False,
widget=forms.CheckboxSelectMultiple
)
self.hide_fields_by_settings(listing_type, lexicon)
def get_widget_by_settings(self, field):
widgets = settings.LISTING_FILTER.get('widgets', {})
# currently supported for categories only
if field != 'categories':
raise NotImplementedError("Other then 'categories' field not supported")
return getattr(forms, widgets.get(field, 'CheckboxSelectMultiple'))
def hide_fields_by_settings(self, listing_type, lexicon):
hidden_fields = settings.LISTING_FILTER.get('hidden_fields', {})
for field_name, subjects in hidden_fields.items():
if field_name not in self.form.fields:
continue
subjects = subjects or {}
listing_types = subjects.get('listing_types')
lexicons = subjects.get('lexicons')
if listing_types is None or \
(listing_type and listing_type.__name__ in listing_types):
del self.form.fields[field_name]
# self.form.fields[field_name].widget = HiddenInput()
continue
if lexicons is None or \
(lexicon and lexicon.__name__ in lexicons):
del self.form.fields[field_name]
# self.form.fields[field_name].widget = HiddenInput()
continue
def filter_categories(self, queryset, name, value):
if not value:
return queryset
if isinstance(value, Category):
return queryset.of_category(value)
return queryset.of_categories(value, deep=True)
class OrderSpecFilter(CustomFilterSet):
class Meta:
model = ReqSpec
fields = {
'type': ['exact'],
'im': ['exact'],
'ip': ['exact'],
'ic': ['exact'],
'ie': ['exact'],
'req_id__date_fa': ['exact', 'gte', 'lte'],
'req_id__xpref__date_fa': ['exact', 'gte', 'lte'],
'req_id__xpref__perm_date': ['exact', 'gte', 'lte'],
'req_id__xpref__payment__due_date': ['exact', 'gte', 'lte'],
}
def __init__(self, data=None, queryset=None, *, request=None, prefix=None):
super(OrderSpecFilter, self).__init__(data=data,
queryset=queryset,
request=request,
prefix=prefix)
dates = [
'date', 'proforma_date', 'perm_date', 'payment_date',
'payment_due_date', 'income_date', 'income_due_date'
]
for filt in self.filters:
self.filters[filt].field.widget.attrs.update(
{'class': 'form-control'})
for date in dates:
self.filters[date].field.widget.attrs['class'] += ' report_date '
self.filters['customer'].field.widget.attrs['id'] = 'autocomplete'
# self.filters['kw'].field.widget.attrs['placeholder'] = 'حداقل'
kw = JRangeFilter(field_name='kw', label='بازه کیلووات', method='AND')
rpm_new = JRangeFilter(field_name='rpm_new__rpm',
label='بازه سرعت',
method='AND')
voltage = JRangeFilter(field_name='voltage',
label='بازه ولتاژ',
method='AND')
qty = JRangeFilter(field_name='qty',
label='بازه تعداد دستگاه',
method='AND')
customer = django_filters.CharFilter(field_name='req_id__customer__name',
label='مشتری',
lookup_expr='icontains')
customer_type = django_filters.ModelChoiceFilter(
field_name='req_id__customer__type',
label='صنعت',
lookup_expr='exact',
queryset=Type.objects.all())
agent = django_filters.BooleanFilter(field_name='req_id__customer__agent',
label='نماینده',
lookup_expr='exact')
owner = django_filters.ModelChoiceFilter(
queryset=get_user_model().objects.filter(sales_exp=True,
is_active=True),
field_name='owner',
label='کارشناس',
lookup_expr='exact')
is_permit = django_filters.BooleanFilter(label='مجوز',
method='is_permit_method')
has_proforma = django_filters.BooleanFilter(field_name='req_id__xpref__id',
label='دارای پیش فاکتور',
lookup_expr='isnull',
exclude=True)
has_payment = django_filters.BooleanFilter(label='دارای واریزی',
method='has_payment_method')
payment_type = django_filters.ModelChoiceFilter(
queryset=PaymentType.objects.all(),
field_name='req_id__xpref__payment__type',
label='نحوه واریز',
)
issue_type = django_filters.ModelChoiceFilter(
queryset=IssueType.objects.all(),
field_name='req_id__xpref__issue_type',
label='دلیل عدم ارسال',
)
date = JDateFromToRangeFilter(field_name='req_id__date_fa',
label='تاریخ درخواست')
proforma_date = JDateFromToRangeFilter(field_name='req_id__xpref__date_fa',
label='تاریخ پیش فاکتور')
perm_date = JDateFromToRangeFilter(field_name='req_id__xpref__perm_date',
label='تاریخ مجوز')
payment_date = JDateFromToRangeFilter(
field_name='req_id__xpref__payment__date_fa', label='تاریخ واریز')
payment_due_date = JDateFromToRangeFilter(
field_name='req_id__xpref__payment__due_date', label='تاریخ سررسید')
has_income = django_filters.BooleanFilter(label='دارای واریزی',
method='has_income_method')
income_type = django_filters.ModelChoiceFilter(
queryset=PaymentType.objects.all(),
field_name='req_id__xpref__incomerow__income__type',
label='نحوه واریز',
)
income_date = JDateFromToRangeFilter(
field_name='req_id__xpref__incomerow__income__date_fa',
label='تاریخ واریز')
income_due_date = JDateFromToRangeFilter(
field_name='req_id__xpref__incomerow__income__due_date',
label='تاریخ سررسید')
@staticmethod
def has_income_method(queryset, field_name, value):
queryset = queryset.annotate(
count=Count('req_id__xpref__incomerow__income__id'))
# ReqSpec.objects.filter(prefspec__xpref_id__incomerow__income__id)
if value:
return queryset.filter(count__gt=0)
return queryset.filter(count__lte=0)
@staticmethod
def has_payment_method(queryset, field_name, value):
queryset = queryset.annotate(count=Count('req_id__xpref__payment__id'))
if value:
return queryset.filter(count__gt=0)
return queryset.filter(count__lte=0)
@staticmethod
def is_permit_method(queryset, field_name, value):
is_perm = queryset.filter(req_id__xpref__perm=True)
if value:
queryset = is_perm
else:
queryset = queryset.exclude(id__in=is_perm)
return queryset
def AND(self, queryset, field_name, value):
if not hasattr(self, "groups"):
setattr(self, "groups", {})
self.groups[field_name] = value
query = Q()
for key, value in self.groups.items():
if type(value) == slice:
if value.start is not None and value.stop is not None:
key += '__range'
value = (value.start, value.stop)
elif value.start is not None:
key += '__gte'
value = value.start
elif value.stop is not None:
key += '__lte'
value = value.stop
query &= Q(**{key: value})
return queryset.filter(query)
@property
def qs(self):
parent = super().qs
user = getattr(self.request, 'user', None)
if not user.is_superuser:
parent = parent.filter(
Q(req_id__owner=user) | Q(req_id__colleagues=user))
return parent.filter(is_active=True).distinct()
class InventoryItemFilterSet(BaseFilterSet, DeviceComponentFilterSet):
q = django_filters.CharFilter(
method='search',
label='Search',
)
region_id = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='device__site__region',
lookup_expr='in',
label='Region (ID)',
)
region = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='device__site__region',
lookup_expr='in',
to_field_name='slug',
label='Region (slug)',
)
site_id = django_filters.ModelMultipleChoiceFilter(
field_name='device__site',
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
field_name='device__site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site name (slug)',
)
device_id = django_filters.ModelChoiceFilter(
queryset=Device.objects.all(),
label='Device (ID)',
)
device = django_filters.ModelChoiceFilter(
queryset=Device.objects.all(),
to_field_name='name',
label='Device (name)',
)
parent_id = django_filters.ModelMultipleChoiceFilter(
queryset=InventoryItem.objects.all(),
label='Parent inventory item (ID)',
)
manufacturer_id = django_filters.ModelMultipleChoiceFilter(
queryset=Manufacturer.objects.all(),
label='Manufacturer (ID)',
)
manufacturer = django_filters.ModelMultipleChoiceFilter(
field_name='manufacturer__slug',
queryset=Manufacturer.objects.all(),
to_field_name='slug',
label='Manufacturer (slug)',
)
serial = django_filters.CharFilter(lookup_expr='iexact')
class Meta:
model = InventoryItem
fields = ['id', 'name', 'part_id', 'asset_tag', 'discovered']
def search(self, queryset, name, value):
if not value.strip():
return queryset
qs_filter = (Q(name__icontains=value) | Q(part_id__icontains=value)
| Q(serial__icontains=value)
| Q(asset_tag__icontains=value)
| Q(description__icontains=value))
return queryset.filter(qs_filter)
class LotFilter(django_filters.FilterSet):
def __init__(self, *args, **kwargs):
try:
self.ignore = kwargs.pop('ignore')
except:
self.ignore = False
super(LotFilter, self).__init__(*args, **kwargs)
# this would require the keyword recommended in the url to show recommended lots. e.g.
# /lots/?recommended
# it's turned off so that not specifying any filter will show you just the lots that are recommended for you
# try:
# self.request.GET['recommended']
# self.allRecommended = True
# except:
# self.allRecommended = False
self.allRecommended = True
try:
self.filters['auction'].queryset = Auction.objects.filter(
auctiontos__user=self.request.user).order_by('title')
except:
self.filters['auction'].queryset = Auction.objects.none()
STATUS = (
('open', 'Open'),
('closed', 'Ended'),
)
VIEWED = (
('yes', 'Only viewed'),
('no', 'Only unviewed'),
)
q = django_filters.CharFilter(
label='',
method='text_filter',
widget=TextInput(attrs={'placeholder': 'Search'}))
auction = django_filters.ModelChoiceFilter(
label='',
queryset=None,
empty_label='Any auction',
to_field_name='slug',
method='filter_by_auction_model',
)
category = django_filters.ModelChoiceFilter(
label='',
queryset=Category.objects.all().order_by('name'),
method='filter_by_category',
empty_label='Any category',
)
status = django_filters.ChoiceFilter(
label='',
choices=STATUS,
method='filter_by_status',
empty_label='Open and ended',
)
distance = django_filters.NumberFilter(
label='',
method='filter_by_distance',
widget=NumberInput(attrs={'placeholder': 'Distance (miles)'}))
ships = django_filters.ModelChoiceFilter(
label='',
queryset=Location.objects.all().order_by('name'),
method='filter_by_shipping_location',
empty_label='Ships to',
)
# this creates a list of every single user and it may get out of hand once we get into the thousands of users
#user = django_filters.ModelChoiceFilter(label='', queryset=User.objects.all(), method='filter_by_user', widget=Select(attrs={'style': 'display:none'}))
# better: just use pk of user
user = django_filters.NumberFilter(
label='',
method='filter_by_user',
widget=NumberInput(attrs={'style': 'display:none'}))
# this is a bit of a hack to allow filtering by auctions show up even if you haven't selected a pickup location
a = django_filters.CharFilter(
label='',
method='filter_by_auction',
widget=TextInput(attrs={'style': 'display:none'}))
viewed = django_filters.ChoiceFilter(
label='',
choices=VIEWED,
method='filter_by_viewed',
empty_label='All',
)
class Meta:
model = Lot
fields = {} # nothing here so no buttons show up
@property
def qs(self):
primary_queryset = super(LotFilter, self).qs
primary_queryset = primary_queryset.filter(
banned=False).order_by("-lot_number").select_related(
'species_category', 'user')
try:
# watched lots
primary_queryset = primary_queryset.annotate(
is_watched_by_req_user=Count(
'watch', filter=Q(watch__user=self.request.user.pk)))
except:
pass
# messages for owner of lot
primary_queryset = primary_queryset.annotate(owner_chats=Count(
'lothistory',
filter=Q(lothistory__seen=False, lothistory__changed_price=False),
distinct=True))
# messages for other user
primary_queryset = primary_queryset.annotate(
all_chats=Count('lothistory',
filter=Q(lothistory__changed_price=False),
distinct=True))
# distance away
try:
latitude = self.request.COOKIES['latitude']
longitude = self.request.COOKIES['longitude']
except:
latitude = 0
longitude = 0
primary_queryset = primary_queryset.annotate(
distance=distance_to(latitude, longitude))
#applyIgnoreFilter = True
try:
if self.ignore and self.request.user.is_authenticated:
allowedCategories = Category.objects.exclude(
userignorecategory__user=self.request.user)
primary_queryset = primary_queryset.filter(
species_category__in=allowedCategories)
#else:
# applyIgnoreFilter = False
except:
pass
#applyIgnoreFilter = False
if (self.allRecommended):
# no filters being used, show recommended lots
#primary_queryset = primary_queryset.exclude(user=self.request.user.pk) # don't show your own lots
# don't show viewed lots for signed in users
# try:
# primary_queryset = primary_queryset.exclude(pageview__user=self.request.user)
# except:
# pass
# local lots
try:
if self.request.user.userdata.latitude and self.request.user.userdata.local_distance:
local = True
else:
local = None
except:
local = None
# lots that can be shipped to the user's location
try:
if self.request.user.userdata.location:
shipping = True
else:
shipping = None
except:
shipping = None
# put it together and add lots that are part of an auction
# fixme - this is in desperate need of refactoring
if local and shipping:
primary_queryset = primary_queryset.filter(\
Q(shipping_locations=self.request.user.userdata.location, auction__isnull=True)|\
Q(distance__lte=self.request.user.userdata.local_distance, local_pickup=True)|\
Q(auction__auctiontos__user=self.request.user))
if local and not shipping:
primary_queryset = primary_queryset.filter(\
Q(distance__lte=self.request.user.userdata.local_distance, local_pickup=True)|\
Q(auction__auctiontos__user=self.request.user))
if not local and shipping:
primary_queryset = primary_queryset.filter(\
Q(shipping_locations=self.request.user.userdata.location, auction__isnull=True)|\
Q(auction__auctiontos__user=self.request.user))
if not local and not shipping:
try:
primary_queryset = primary_queryset.filter(
auction__auctiontos__user=self.request.user)
except:
pass
return primary_queryset
def filter_by_distance(self, queryset, name, value):
self.allRecommended = False
try:
if self.request.GET['auction']:
# if both this and auction are specified, auction wins and this does nothing
return queryset
except:
pass
try:
if self.request.user.userdata.latitude:
# seems like we need to annotate twice here
return queryset.annotate(distance=distance_to(self.request.user.userdata.latitude, self.request.user.userdata.longitude))\
.filter(distance__lte=value, auction__isnull=True, local_pickup=True)
except:
pass
return queryset
def filter_by_user(self, queryset, name, value):
self.allRecommended = False
return queryset.filter(user__pk=value)
def filter_by_category(self, queryset, name, value):
self.ignore = False
self.allRecommended = False
return queryset.filter(species_category=value)
def filter_by_auction(self, queryset, name, value):
self.allRecommended = False
try:
if self.request.GET['auction']:
# if both this and auction are specified, auction wins and this does nothing
return queryset
except:
pass
return queryset.filter(auction=Auction.objects.get(slug=value))
def filter_by_auction_model(self, queryset, name, value):
self.allRecommended = False
return queryset.filter(auction=value)
def filter_by_status(self, queryset, name, value):
self.allRecommended = False
if value == "ended":
return queryset.filter(active=False)
if value == "open":
return queryset.filter(active=True)
return queryset.filter()
def filter_by_viewed(self, queryset, name, value):
self.allRecommended = False
if not self.request.user.is_authenticated:
messages.warning(self.request, "Sign in to use this filter")
return queryset
if value == "yes":
return queryset.filter(pageview__user=self.request.user)
if value == "no":
return queryset.exclude(pageview__user=self.request.user)
return queryset.filter()
def text_filter(self, queryset, name, value):
self.allRecommended = False
if value.isnumeric():
return queryset.filter(
Q(lot_number=int(value)) | Q(lot_name__icontains=value))
else:
return queryset.filter(
Q(description__icontains=value) | Q(lot_name__icontains=value))
def filter_by_shipping_location(self, queryset, name, value):
self.allRecommended = False
try:
if self.request.GET['auction']:
# if both this and auction are specified, auction wins and this does nothing
return queryset
except:
pass
return queryset.filter(shipping_locations=value, auction__isnull=True)
class CaseFilter(FilterSet):
court = django_filters.ModelChoiceFilter(
field_name='court',
label=_('Court'),
queryset=Court.objects.all().order_by('name'),
widget=autocomplete.ModelSelect2(url='courts:autocomplete',
attrs={
'data-placeholder': _('Court'),
}),
)
court__state = django_filters.ModelChoiceFilter(
field_name='court__state',
label=_('State'),
queryset=State.objects.all().order_by('name'),
widget=autocomplete.ModelSelect2(
url='courts:state_autocomplete',
attrs={
'data-placeholder': _('State'),
},
),
)
has_reference_to_law = django_filters.NumberFilter(
field_name='has_reference_to_law',
method='filter_has_reference_to_law',
label='Has reference to',
widget=HiddenInput(),
)
def filter_has_reference_to_law(self, queryset, name, value):
"""
Filter depending on references (currently only with URL)
"""
return queryset.filter(
casereferencemarker__referencefromcase__reference__law_id=value
).distinct()
o = LazyOrderingFilter(
fields=(
('date', 'date'),
('updated_date', 'updated_date'), # not used in template
('file_number', 'file_number'),
),
field_labels={
'date': _('Publication date'),
'updated_date': _('Last modified date'),
'file_number': _('File number'),
},
initial='-date', # is overwritten in SortableFilterView
# widget=forms.HiddenInput,
)
class Meta:
model = Case
fields = []
filter_overrides = {
models.CharField: {
'filter_class': django_filters.CharFilter,
'extra': lambda f: {
'lookup_expr': 'icontains',
},
},
}
def __init__(self, **kwargs):
super().__init__(**kwargs)
class HeritageSiteFilter(django_filters.FilterSet):
site_name = django_filters.CharFilter(
field_name='site_name',
label='Heritage Site Name',
lookup_expr='icontains'
)
description = django_filters.CharFilter(
field_name='description',
label='Description',
lookup_expr='icontains'
)
heritage_site_category = django_filters.ModelChoiceFilter(
field_name='heritage_site_category',
label='Category',
queryset=HeritageSiteCategory.objects.all().order_by('category_name'),
lookup_expr='exact'
)
region = django_filters.ModelChoiceFilter(
field_name='country_area__location__region__region_name',
label='Region',
queryset=Region.objects.all().order_by('region_name'),
lookup_expr='exact'
)
sub_region = django_filters.ModelChoiceFilter(
field_name='country_area__location__sub_region__sub_region_name',
label='Subregion',
queryset=SubRegion.objects.all().order_by('sub_region_name'),
lookup_expr='exact'
)
intermediate_region = django_filters.ModelChoiceFilter(
field_name='country_area__location__intermediate_region__intermediate_region_name',
label='Intermediate Region',
queryset=IntermediateRegion.objects.all().order_by('intermediate_region_name'),
lookup_expr='exact'
)
country_area = django_filters.ModelChoiceFilter(
field_name='country_area',
label='Country/Area',
queryset=CountryArea.objects.all().order_by('country_area_name'),
lookup_expr='exact'
)
date_inscribed = django_filters.NumberFilter(
field_name='date_inscribed',
label='Date Inscribed',
lookup_expr='exact'
)
class Meta:
model = HeritageSite
# form = SearchForm
# fields [] is required, even if empty. Comment out names to prevent overriding names
# listed above.
fields = [
# 'site_name',
# 'description',
# 'heritage_site_category',
# 'country_area__location__region__region_name',
# 'country_area__location__sub_region__sub_region_name',
# 'country_area__location__intermediate_region__intermediate_region_name',
# 'country_area',
# 'date_inscribed'
]
class ScholarshipFilter(django_filters.FilterSet):
scholarship_founder = django_filters.ModelChoiceFilter(
label=FieldScholarship.FOUNDER,
queryset=Institution.objects.all(),
widget=autocomplete.ModelSelect2(url='institution-autocomplete'))
scholarship_name_text = django_filters.CharFilter(
label=FieldScholarship.NAME,
lookup_expr='icontains',
widget=forms.TextInput(attrs={'class': 'list__form--input'}))
scholarship_targets = django_filters.ModelMultipleChoiceFilter(
label=FieldScholarship.TARGETS,
queryset=TargetGroup.objects.all(),
widget=autocomplete.ModelSelect2Multiple(
url='targetgroup-autocomplete'))
scholarship_type = django_filters.ModelMultipleChoiceFilter(
label=FieldScholarship.TYPE,
queryset=ScholarshipType.objects.all(),
widget=autocomplete.ModelSelect2Multiple(
url='scholarshiptype-autocomplete'))
scholarship_city__region = django_filters.ModelChoiceFilter(
label=FieldScholarship.REGION,
queryset=Region.objects.all(),
widget=autocomplete.ModelSelect2(url='region-autocomplete'))
scholarship_city = django_filters.ModelChoiceFilter(
label=FieldScholarship.CITY,
queryset=City.objects.all(),
widget=autocomplete.ModelSelect2(url='city-autocomplete'))
scholarship_date_start = django_filters.DateFilter(
label=FieldScholarship.DATE_START,
lookup_expr='gte',
widget=forms.DateInput(
attrs={'class': 'datepicker list__form--input'}))
scholarship_date_end = django_filters.DateFilter(
label=FieldScholarship.DATE_END,
lookup_expr='lte',
widget=forms.DateInput(
attrs={'class': 'datepicker list__form--input'}))
scholarship_keywords = django_filters.ModelMultipleChoiceFilter(
label=FieldScholarship.KEYWORDS,
queryset=Tag.objects.all(),
widget=autocomplete.ModelSelect2Multiple(url='tag-autocomplete'))
scholarship_is_accepted = django_filters.BooleanFilter(
label=FieldScholarship.IS_ACCEPTED,
widget=NullBooleanSelect(attrs={'class': 'select2'}))
o = django_filters.OrderingFilter(fields=(
('scholarship_is_promoted', 'scholarship_is_promoted'),
('scholarship_date_add', 'scholarship_date_add'),
('scholarship_name_text', 'scholarship_name_text'),
('scholarship_date_end', 'scholarship_date_end'),
), )
strict = True
class Meta:
model = Scholarship
form = ScholarshipFilterForm
fields = [
'scholarship_founder', 'scholarship_name_text',
'scholarship_targets', 'scholarship_type',
'scholarship_city__region', 'scholarship_city',
'scholarship_date_start', 'scholarship_date_end',
'scholarship_keywords', 'scholarship_is_accepted'
]
