def render(self, context):
filters = []
request = context['request']
app_name = self.app_name.resolve(context)
model_name = self.model_name.resolve(context)
field_name = self.field_name.resolve(context)
if self.choices_queryset is not None:
choices_queryset = self.choices_queryset.resolve(context)
else:
choices_queryset = None
model = models.get_model(app_name, model_name)
qsm = QueryStringManager(request)
params = qsm.get_params()
if params.get('page', None):
del params['page']
field = model._meta.get_field(field_name)
if field.get_internal_type() == 'FileField':
spec = FieldAvailabilityValueFilterSpec(field, request, params, model, None)
elif self.multiselection and (field.rel is not None): # is a related field (ForeignKeyField)
spec = MultipleRelatedFilterSpec(field, request, params, model, None, choices_queryset)
else: # normal filter spec
spec = FilterSpec.create(field, request, params, model, None)
filter_context = {'title': spec.title(), 'choices' : list(spec.choices(qsm))}
tpl = loader.get_template('admin/filter.html')
return tpl.render(Context(dict(filter_context, autoescape=context.autoescape)))
def get_filters(self, request):
filter_specs = []
if self.list_filter:
filter_fields = [self.lookup_opts.get_field(field_name) for field_name in self.list_filter]
for f in filter_fields:
spec = FilterSpec.create(f, request, self.params, self.model, self.model_admin)
if spec and spec.has_output():
filter_specs.append(spec)
return filter_specs, bool(filter_specs)
def get_filters(self, request):
filter_specs = []
if self.list_filter:
filter_fields = [self.lookup_opts.get_field(field_name) for field_name in self.list_filter]
for f in filter_fields:
spec = FilterSpec.create(f, request, self.params, self.model, self.model_admin)
if spec and spec.has_output():
filter_specs.append(spec)
return filter_specs, bool(filter_specs)
def get_filters(self, request):
filter_specs = []
if self.list_filter:
lookup_opts = self.lookup_opts
for filter_name in self.list_filter:
if '__' in filter_name:
f = None
model = self.model
path = filter_name.split('__')
for field_name in path[:-1]:
f = model._meta.get_field(field_name)
model = f.rel.to
f = model._meta.get_field(path[-1])
spec = FilterSpec.create(f, request, self.params, model, self.model_admin, field_path=filter_name)
else:
f = lookup_opts.get_field(filter_name)
spec = FilterSpec.create(f, request, self.params, self.model, self.model_admin)
if spec and spec.has_output():
filter_specs.append(spec)
return filter_specs, bool(filter_specs)
def get_filters(self, request):
filter_specs = []
if self.list_filter:
for filter_name in self.list_filter:
field = get_fields_from_path(self.model, filter_name)[-1]
spec = FilterSpec.create(field, request, self.params,
self.model, self.model_admin,
field_path=filter_name)
if spec and spec.has_output():
filter_specs.append(spec)
return filter_specs, bool(filter_specs)
def get_filters(self, request):
filter_specs = []
if self.list_filter:
for filter_name in self.list_filter:
field = get_fields_from_path(self.model, filter_name)[-1]
spec = FilterSpec.create(field, request, self.params,
self.model, self.model_admin,
field_path=filter_name)
if spec and spec.has_output():
filter_specs.append(spec)
return filter_specs, bool(filter_specs)
def get_filters(self, request):
filter_specs = []
if self.list_filter:
filter_fields = []
for field_name in self.list_filter:
if '__' in field_name:
names = field_name.split('__')
field = FakeField(name = names[0], rel_fields = names)
else:
field = self.lookup_opts.get_field(field_name)
filter_fields.append(field)
for f in filter_fields:
spec = FilterSpec.create(f, request, self.params, self.model, self.model_admin)
if spec and spec.has_output():
filter_specs.append(spec)
return filter_specs, bool(filter_specs)
def get_filters(self, request):
# Esto lo modificamos para que en el filtro solo aparezcan opciones con
# datos (por ejemplo, en la vista dispositivos solo aparezcan en el
# filtro de localidad las localidades que tienen dispositivos
filter_specs = []
if self.list_filter:
for filter_name in self.list_filter:
field = get_fields_from_path(self.model, filter_name)[-1]
spec = FilterSpec.create(field, request, self.params,
self.model, self.model_admin,
field_path=filter_name)
#Salva:
if isinstance(spec, RelatedFilterSpec) and not '__' in filter_name:
spec.lookup_choices = [(x._get_pk_val(),x.__unicode__()) for x in field.rel.to.objects.annotate(num_rel=Count(self.model._meta.verbose_name)).filter(num_rel__gt=0)] #IGNORE:W0212
#Fin Modificacion
if spec and spec.has_output():
filter_specs.append(spec)
return filter_specs, bool(filter_specs)
self.lookup_val = request.GET.get(self.lookup_kwarg, None)
self.lookup_choices = f.get_choices(include_blank=False)
def title(self):
return self.lookup_title
def choices(self, cl):
yield {'selected': self.lookup_val is None,
'query_string': cl.get_query_string({}, [self.lookup_kwarg]),
'display': _('All')}
for pk_val, val in self.lookup_choices:
yield {'selected': self.lookup_val == smart_unicode(pk_val),
'query_string': cl.get_query_string({self.lookup_kwarg: pk_val}, [self.lookup_kwarg]),
'display': val}
FilterSpec.register_front(lambda f: bool(f.rel) and (not hasattr(f, 'null') or not f.null), RelatedFilterSpec)
#==============================================================================
class RelatedNullFilterSpec(FilterSpec):
def __init__(self, f, request, params, model, model_admin,
field_path=None):
super(RelatedNullFilterSpec, self).__init__(f, request, params, model, model_admin)
if isinstance(f, models.ManyToManyField):
self.lookup_title = f.rel.to._meta.verbose_name
else:
self.lookup_title = f.verbose_name
self.null_lookup_kwarg = '%s__isnull' % f.name
self.null_lookup_val = request.GET.get(self.null_lookup_kwarg, None)
rel_name = f.rel.get_related_field().name
self.lookup_kwarg = '%s__%s__exact' % (f.name, rel_name)
def __init__(self, f, request, params, model, model_admin, **kwargs):
filter_by_key = f.name+'_fk_filter_by'
filter_by_val = getattr(model_admin, filter_by_key, None)
filter_related_key = f.name+'_fk_filter_related_only'
filter_related_val = getattr(model_admin, filter_related_key, False)
filter_nf_key = f.name+'_fk_filter_display_field'
if filter_by_val:
filter_nf_val = getattr(model_admin, filter_nf_key, filter_by_val)
else:
filter_nf_val = getattr(model_admin, filter_nf_key, 'pk')
filter_crit_key = f.name+'_fk_filter_criteria_fn'
filter_crit_fn = getattr(model_admin, filter_crit_key, None)
filter_qs_key = f.name+'_fk_filter_query_string'
self.filter_qs_val = getattr(model_admin, filter_qs_key, {})
if filter_by_val:
self.fk_filter_on = True
# we call FilterSpec constructor, not RelatedFilterSpec
# constructor; RelatedFilterSpec constructor will try to
# get all the pk values on the related models, which we
# won't need.
FilterSpec.__init__(self, f, request, params, model, model_admin)
filter_name_key = f.name+'_fk_filter_name'
filter_name_val = getattr(model_admin, filter_name_key, None)
if filter_name_val is None:
self.lookup_title = f.verbose_name
else:
self.lookup_title = f.verbose_name+' '+filter_name_val
self.lookup_kwarg = f.name+'__'+filter_by_val+'__exact'
self.lookup_val = request.GET.get(self.lookup_kwarg, None)
if filter_related_val:
try:
qs = model_admin.queryset(request)
if filter_crit_fn is not None:
qs = filter_crit_fn(qs)
qs = qs.values_list((f.name + '__' + filter_by_val,
f.name + '__' + filter_nf_val)
.order_by(f.name + '__' +
filter_nf_val).distinct())
except Exception:
# Django QuerySet can't follow generic
# relationships using __, so we have to use
# f.rel.to.objects
qs = f.rel.to.objects
if filter_crit_fn is not None:
qs = filter_crit_fn(qs)
qs = qs.values_list(filter_by_val,
filter_nf_val).distinct()
else:
qs = f.rel.to.objects
if filter_crit_fn is not None:
qs = filter_crit_fn(qs)
qs = qs.values_list(filter_by_val, filter_nf_val).distinct()
self.lookup_choices = list(set(qs))
self.lookup_choices.sort(reverse=True)
# if there was a further limiting criteria, then we want
# to make sure we still display the filter even if there
# is only one option
if filter_crit_fn is not None and len(self.lookup_choices) == 1:
self.lookup_choices = self.lookup_choices+[('', ''), ]
else:
self.fk_filter_on = False
RelatedFilterSpec.__init__(self, f, request, params, model,
model_admin)
if filter_related_val:
qs = model_admin.queryset(request)
if filter_crit_fn is not None:
qs = filter_crit_fn(qs)
qs = qs.values_list((f.name+'__pk', f.name+'__'+filter_nf_val)
.order_by(f.name+'__'+filter_nf_val)
.distinct())
self.lookup_choices = list(qs)
class PermsFilterSpec(FilterSpec):
def __init__(self, f, request, params, model, model_admin):
super(PermsFilterSpec, self).__init__(f, request, params, model, model_admin)
self.lookup_title = f.verbose_name
#rel_name = f.rel.get_related_field().name
#c = f.name
#xx = f.rel.get_related_field()
self.lookup_kwarg = PERMS_VAR
self.lookup_val = request.GET.get(PERMS_VAR, None)
self.lookup_choices = UserPermission.objects.all().order_by('id')
def has_output(self):
return len(self.lookup_choices) > 1
def title(self):
return self.lookup_title
def choices(self, cl):
yield {'selected': self.lookup_val is None,
'query_string': '?',
'display': _('All')}
for up in self.lookup_choices:
yield {'selected': self.lookup_val == smart_unicode(up.id),
'query_string': cl.get_query_string({self.lookup_kwarg: up.id}),
'display': up.name}
FilterSpec.register_first(lambda f: bool(f.name == 'user_permissions'), PermsFilterSpec)
def __init__(self, f, request, params, model, model_admin):
FilterSpec.__init__(self, f, request, params, model, model_admin)
self.model = model
self.lookup_val = request.GET.get(f, None)
def __init__(self, f, request, params, model, model_admin):
field = get_fields_from_path(model, f)[-1]
FilterSpec.__init__(self, field, request, params, model, model_admin, field_path=f)
self.model = model
self.lookup_val = request.GET.get(f, None)
def __init__(self, f, request, params, model, model_admin):
filter_by_key = f.name + '_fk_filter_by'
filter_by_val = getattr(model_admin, filter_by_key, None)
filter_related_key = f.name + '_fk_filter_related_only'
filter_related_val = getattr(model_admin, filter_related_key, False)
filter_nf_key = f.name + '_fk_filter_display_field'
if filter_by_val != None:
filter_nf_val = getattr(model_admin, filter_nf_key, filter_by_val)
else:
filter_nf_val = getattr(model_admin, filter_nf_key, 'pk')
filter_crit_key = f.name + '_fk_filter_criteria_fn'
filter_crit_fn = getattr(model_admin, filter_crit_key, None)
filter_qs_key = f.name + '_fk_filter_query_string'
self.filter_qs_val = getattr(model_admin, filter_qs_key, {})
if filter_by_val != None:
self.fk_filter_on = True
# we call FilterSpec constructor, not RelatedFilterSpec
# constructor; RelatedFilterSpec constructor will try to
# get all the pk values on the related models, which we
# won't need.
FilterSpec.__init__(self, f, request, params, model, model_admin)
filter_name_key = f.name + '_fk_filter_name'
filter_name_val = getattr(model_admin, filter_name_key, None)
if filter_name_val == None:
self.lookup_title = f.verbose_name
else:
self.lookup_title = f.verbose_name + ' ' + filter_name_val
self.lookup_kwarg = f.name + '__' + filter_by_val + '__exact'
self.lookup_val = request.GET.get(self.lookup_kwarg, None)
if filter_related_val:
try:
qs = model_admin.queryset(request)
if filter_crit_fn != None:
qs = filter_crit_fn(qs)
qs = qs.values_list(
f.name + '__' + filter_by_val, f.name + '__' +
filter_nf_val).order_by(f.name + '__' +
filter_nf_val).distinct()
except Exception as e:
# Django QuerySet can't follow generic
# relationships using __, so we have to use
# f.rel.to.objects
qs = f.rel.to.objects
if filter_crit_fn != None:
qs = filter_crit_fn(qs)
qs = qs.values_list(filter_by_val,
filter_nf_val).distinct()
else:
qs = f.rel.to.objects
if filter_crit_fn != None:
qs = filter_crit_fn(qs)
qs = qs.values_list(filter_by_val, filter_nf_val).distinct()
self.lookup_choices = list(qs)
# if there was a further limiting criteria, then we want
# to make sure we still display the filter even if there
# is only one option
if filter_crit_fn != None and len(self.lookup_choices) == 1:
self.lookup_choices = self.lookup_choices + [
('', ''),
]
else:
self.fk_filter_on = False
RelatedFilterSpec.__init__(self, f, request, params, model,
model_admin)
if filter_related_val:
qs = model_admin.queryset(request)
if filter_crit_fn != None:
qs = filter_crit_fn(qs)
qs = qs.values_list(
f.name + '__pk', f.name + '__' +
filter_nf_val).order_by(f.name + '__' +
filter_nf_val).distinct()
self.lookup_choices = list(qs)
def __init__(self, f, request, params, model, model_admin):
FilterSpec.__init__(self, f, request, params, model, model_admin)
self.model = model
self.lookup_val = request.GET.get(f, None)
def choices(self, cl):
yield {
'selected': self.lookup_val is None,
'query_string': '?',
'display': _('All')
}
for up in self.lookup_choices:
yield {
'selected': self.lookup_val == smart_unicode(up.id),
'query_string': cl.get_query_string({self.lookup_kwarg:
up.id}),
'display': up.name_cn
}
FilterSpec.register_first(lambda f: bool(f.name == 'visit_begin'),
AreaFilterSpec)
class DealerTypeFilterSpec(FilterSpec):
def __init__(self, f, request, params, model, model_admin):
super(DealerTypeFilterSpec, self).__init__(f, request, params, model,
model_admin)
self.lookup_title = u'经销商'
#rel_name = f.rel.get_related_field().name
#c = f.name
#xx = f.rel.get_related_field()
self.lookup_kwarg = DEALER_TYPE_VAR
self.lookup_val = request.GET.get(DEALER_TYPE_VAR, None)
self.lookup_choices = DealerType.objects.all().order_by('id')
'display': _('All')
}
for pk_val, val in self.lookup_choices:
yield {
'selected':
self.lookup_val == smart_unicode(pk_val),
'query_string':
cl.get_query_string({self.lookup_kwarg: pk_val},
[self.lookup_kwarg]),
'display':
val
}
FilterSpec.register_front(
lambda f: bool(f.rel) and (not hasattr(f, 'null') or not f.null),
RelatedFilterSpec)
#==============================================================================
class RelatedNullFilterSpec(FilterSpec):
def __init__(self,
f,
request,
params,
model,
model_admin,
field_path=None):
super(RelatedNullFilterSpec, self).__init__(f, request, params, model,
model_admin)
if isinstance(f, models.ManyToManyField):
def create(cls, field, request, params, model, model_admin, *arg,
**kw):
return FilterSpec.create(field, request, params, model,
model_admin)
accords = models.TextField(u'Аккорды', blank=True)
translation = models.TextField(u'Перевод песни', blank=True)
accords.test_null_filter = True
translation.test_null_filter = True
"""
def __init__(self, f, request, params, model, model_admin):
super(EmptyStringFilterSpec, self).__init__(f, request, params, model, model_admin)
self.lookup_kwarg = '%s__exact' % f.name
self.lookup_kwarg2 = '%s__gt' % f.name
self.lookup_kwarg3 = '%s__isnull' % f.name
self.lookup_val = request.GET.get(self.lookup_kwarg, None)
self.lookup_val2 = request.GET.get(self.lookup_kwarg2, None)
def title(self):
return u"наличие поля '%s'" % self.field.verbose_name
def choices(self, cl):
yield {'selected': self.lookup_val2 is None and self.lookup_val is None,
'query_string': cl.get_query_string({}, [self.lookup_kwarg2, self.lookup_kwarg, self.lookup_kwarg3]),
'display': u'Все'}
yield {'selected': self.lookup_val2 == '' and self.lookup_val is None,
'query_string': cl.get_query_string({self.lookup_kwarg2: ''}, [self.lookup_kwarg, self.lookup_kwarg3]),
'display': u'Имеется'}
yield {'selected': self.lookup_val == '' and self.lookup_val2 is None,
'query_string': cl.get_query_string({self.lookup_kwarg: ''}, [self.lookup_kwarg2, self.lookup_kwarg3]),
'display': u'Отсутствует'}
FilterSpec.register_first(lambda f: hasattr(f, 'test_null_filter'), EmptyStringFilterSpec)
class NullFilterSpec(FilterSpec):
def __init__(self, f, request, params, model, model_admin, field_path=None):
super(NullFilterSpec, self).__init__(f, request, params, model, model_admin)
self.lookup_kwarg = '%s__isnull' % f.name
self.lookup_val = request.GET.get(self.lookup_kwarg, None)
def choices(self, cl):
yield {'selected': self.lookup_val is None,
'query_string': cl.get_query_string({}, [self.lookup_kwarg]),
'display': _('All')}
for k, v in ((True,_('Null')),('',_('With value'))):
yield {'selected': k == self.lookup_val,
'query_string': cl.get_query_string({self.lookup_kwarg: k}),
'display': v}
FilterSpec.register(lambda f: f.null, NullFilterSpec)
from django.db import models
class DateRangeFilterSpec(FilterSpec):
USE_OUTPUT_FUNC = True
template = 'xadmin/widgets/date_range_filter.html'
def __init__(self, f, request, params, model, model_admin, field_path=None):
super(DateRangeFilterSpec, self).__init__(f, request, params, model, model_admin)
self._from = request.GET.get('born__gte', "")
self._to = request.GET.get('born__lte', "")
def title(self):
return self.field.verbose_name
#c = f.name
#xx = f.rel.get_related_field()
self.lookup_kwarg = PERMS_VAR
self.lookup_val = request.GET.get(PERMS_VAR, None)
self.lookup_choices = UserPermission.objects.all().order_by('id')
def has_output(self):
return len(self.lookup_choices) > 1
def title(self):
return self.lookup_title
def choices(self, cl):
yield {
'selected': self.lookup_val is None,
'query_string': '?',
'display': _('All')
}
for up in self.lookup_choices:
yield {
'selected': self.lookup_val == smart_unicode(up.id),
'query_string': cl.get_query_string({self.lookup_kwarg:
up.id}),
'display': up.name
}
FilterSpec.register_first(lambda f: bool(f.name == 'user_permissions'),
PermsFilterSpec)
def has_output(self):
return len(self.lookup_choices) > 1
def title(self):
return self.lookup_title
def choices(self, cl):
yield {'selected': self.lookup_val is None,
'query_string': '?',
'display': _('All')}
for up in self.lookup_choices:
yield {'selected': self.lookup_val == smart_unicode(up.id),
'query_string': cl.get_query_string({self.lookup_kwarg: up.id}),
'display': up.name_cn}
FilterSpec.register_first(lambda f: bool(f.name == 'visit_begin'), AreaFilterSpec)
class DealerTypeFilterSpec(FilterSpec):
def __init__(self, f, request, params, model, model_admin):
super(DealerTypeFilterSpec, self).__init__(f, request, params, model, model_admin)
self.lookup_title = u'经销商'
#rel_name = f.rel.get_related_field().name
#c = f.name
#xx = f.rel.get_related_field()
self.lookup_kwarg = DEALER_TYPE_VAR
self.lookup_val = request.GET.get(DEALER_TYPE_VAR, None)
self.lookup_choices = DealerType.objects.all().order_by('id')
def has_output(self):
return len(self.lookup_choices) > 1
yield {
'selected' : self.file_exists_lookup_val is not None,
'query_string' : cl.get_query_string({self.file_exists_lookup_kwarg : ""}, [self.file_not_exists_lookup_kwarg]),
'display' : 'PreGenCSV',
}
yield {
'selected' : self.file_not_exists_lookup_val is not None,
'query_string' : cl.get_query_string({self.file_not_exists_lookup_kwarg : ""}, [self.file_exists_lookup_kwarg]),
'display' : 'HUB-Core',
}
def _register_front(cls, test, factory):
cls.filter_specs.insert(0, (test, factory))
FilterSpec.register_front = classmethod(_register_front)
FilterSpec.register_front(lambda f: isinstance(f, FileNameField), IndicatorSourceListFilter)
# Actions available in Core
def batch_debug_indicators(modeladmin, request, queryset):
""" Run selected indicators, and store output and a "debug" csv
Each call to this view generates a view batch folder. The contents of the
folder:
- [indicator name].csv for each indicator selected
- [indicator name]_debug.csv for each indicator selected
- batch.log
The indicator generation is scheduled in celery, and output is directed to
batch.log.
"""
