class F(FilterSet):
username = MethodFilter()
email = MethodFilter()
class Meta:
model = User
fields = ['username']
class F(FilterSet):
username = MethodFilter()
class Meta:
model = User
fields = ['username']
def filter_username(self, queryset, value):
return queryset.filter(username__contains='ke')
class F(FilterSet):
username = MethodFilter(action='filter_username')
class Meta:
model = User
fields = ['username']
def filter_username(self, queryset, value):
return queryset.filter(username=value)
class HttpLogFilter(django_filters.FilterSet):
user = MethodFilter(action='user_filter')
status_code = MethodFilter(action='status_code_filter')
class Meta:
model = HttpLog
fields = ('user', 'status_code')
@classmethod
def user_filter(cls, queryset, username):
return queryset.filter(user__username__contains=username)
@classmethod
def status_code_filter(cls, queryset, status_code):
id_list = []
for qs in queryset:
if qs.response.has_key('status_code'):
if qs.response['status_code'] == int(status_code):
id_list.append(qs.id)
return queryset.filter(id__in=id_list)
class AutorChoiceFilterSet(SaplGenericRelationSearchFilterSet):
q = MethodFilter()
tipo = ModelChoiceFilter(queryset=TipoAutor.objects.all())
class Meta:
model = Autor
fields = ['q',
'tipo',
'nome', ]
def filter_q(self, queryset, value):
return SaplGenericRelationSearchFilterSet.filter_q(
self, queryset, value).distinct('nome').order_by('nome')
class SaplGenericRelationSearchFilterSet(FilterSet):
q = MethodFilter()
def filter_q(self, queryset, value):
query = value.split(' ')
if query:
q = Q()
for qtext in query:
if not qtext:
continue
q_fs = Q(nome__icontains=qtext)
order_by = []
for gr in generic_relations_for_model(self._meta.model):
sgr = gr[1]
for item in sgr:
if item.related_model != self._meta.model:
continue
flag_order_by = True
for field in item.fields_search:
if flag_order_by:
flag_order_by = False
order_by.append('%s__%s' % (
item.related_query_name(),
field[0])
)
# if len(field) == 3 and field[2](qtext) is not
# None:
q_fs = q_fs | Q(**{'%s__%s%s' % (
item.related_query_name(),
field[0],
field[1]): qtext if len(field) == 2
else field[2](qtext)})
q = q & q_fs
if q:
queryset = queryset.filter(q).order_by(*order_by)
return queryset
class F(FilterSet):
username = MethodFilter(action=filter_username)
class Meta:
model = User
fields = ['username']
class ContatoAgrupadoPorProcessoFilterSet(FilterSet):
filter_overrides = {
models.DateField: {
'filter_class': MethodFilter,
'extra': lambda f: {
'label': '%s (%s)' % (f.verbose_name, _('Inicial - Final')),
'widget': RangeWidgetOverride
}
}
}
AGRUPADO_POR_NADA = 'sem_agrupamento'
AGRUPADO_POR_TITULO = 'titulo'
AGRUPADO_POR_IMPORTANCIA = 'importancia'
AGRUPADO_POR_TOPICO = 'topicos__descricao'
AGRUPADO_POR_ASSUNTO = 'assuntos__descricao'
AGRUPADO_POR_STATUS = 'status__descricao'
AGRUPADO_POR_CLASSIFICACAO = 'classificacoes__descricao'
AGRUPAMENTO_CHOICE = (
(AGRUPADO_POR_NADA, _('Sem Agrupamento')),
(AGRUPADO_POR_TITULO, _('Por Título de Processos')),
(AGRUPADO_POR_IMPORTANCIA, _('Por Importância')),
(AGRUPADO_POR_TOPICO, _('Por Tópicos')),
(AGRUPADO_POR_ASSUNTO, _('Por Assuntos')),
(AGRUPADO_POR_STATUS, _('Por Status')),
(AGRUPADO_POR_CLASSIFICACAO, _('Por Classificação')),
)
search = MethodFilter()
agrupamento = MethodChoiceFilter(required=False,
choices=AGRUPAMENTO_CHOICE)
importancia = MethodMultipleChoiceFilter(required=False,
choices=IMPORTANCIA_CHOICE)
status = MethodModelMultipleChoiceFilter(
required=False, queryset=StatusProcesso.objects.all())
def filter_agrupamento(self, queryset, value):
return queryset
def filter_importancia(self, queryset, value):
if not value:
return queryset
q = None
for i in value:
q = q | Q(importancia=i) if q else Q(importancia=i)
return queryset.filter(q)
def filter_status(self, queryset, value):
if not value:
return queryset
q = None
for sta in value:
q = q | Q(status=sta) if q else Q(status=sta)
return queryset.filter(q)
def filter_data(self, queryset, value):
if not value[0] or not value[1]:
return queryset
inicial = datetime.datetime.strptime(value[0], "%d/%m/%Y").date()
final = datetime.datetime.strptime(value[1], "%d/%m/%Y").date()
if inicial > final:
inicial, final = final, inicial
range_select = Q(data__range=[inicial, final])
# Run the query.
return queryset.filter(range_select)
def filter_search(self, queryset, value):
query = normalize(value)
query = query.split(' ')
if query:
q = Q()
for item in query:
if not item:
continue
q = q & Q(search__icontains=item)
if q:
queryset = queryset.filter(q)
return queryset
class Meta:
model = Processo
fields = [
'search',
'data',
'topicos',
'importancia',
'classificacoes',
'assuntos',
'status',
]
def __init__(self,
data=None,
queryset=None,
prefix=None,
strict=None,
**kwargs):
workspace = kwargs.pop('workspace')
super(ContatoAgrupadoPorProcessoFilterSet,
self).__init__(data=data,
queryset=queryset,
prefix=prefix,
strict=strict,
**kwargs)
c1_row1 = to_row([
('search', 7),
('data', 5),
('importancia', 4),
('status', 4),
('classificacoes', 4),
('topicos', 6),
('assuntos', 6),
])
col1 = Fieldset(
_('Informações para Seleção de Processos'), c1_row1,
to_row([(SubmitFilterPrint('filter',
value=_('Filtrar'),
css_class='btn-default pull-right',
type='submit'), 12)]))
col2 = Fieldset(
_('Inf p/ Impressão'), 'agrupamento',
SubmitFilterPrint('print',
value=_('Imprimir'),
css_class='btn-primary pull-right',
type='submit'))
rows = to_row([
(col1, 9),
(col2, 3),
])
self.form.helper = FormHelper()
self.form.helper.form_method = 'GET'
self.form.helper.layout = Layout(rows, )
self.form.fields['search'].label = _('Filtrar Títulos de Processos')
self.form.fields['topicos'].widget = forms.SelectMultiple(
attrs={'size': '7'})
self.form.fields['topicos'].queryset = TopicoProcesso.objects.all()
self.form.fields['assuntos'].widget = forms.SelectMultiple(
attrs={'size': '7'})
self.form.fields['assuntos'].queryset = AssuntoProcesso.objects.filter(
workspace=workspace)
self.form.fields['importancia'].widget = forms.CheckboxSelectMultiple()
# self.form.fields['importancia'].inline_class = True
self.form.fields[
'classificacoes'].widget = forms.CheckboxSelectMultiple()
self.form.fields['status'].widget = forms.CheckboxSelectMultiple()
# self.form.fields['status'].inline_class = True
self.form.fields['status'].choices = list(
self.form.fields['status'].choices)
del self.form.fields['status'].choices[0]
self.form.fields['agrupamento'].label = _('Agrupar Contatos')
self.form.fields['agrupamento'].widget = forms.RadioSelect()
class ImpressoEnderecamentoContatoFilterSet(FilterSet):
filter_overrides = {
models.DateField: {
'filter_class': MethodFilter,
'extra': lambda f: {
'label': '%s (%s)' % (f.verbose_name, _('Inicial - Final')),
'widget': RangeWidgetOverride
}
}
}
FEMININO = 'F'
MASCULINO = 'M'
AMBOS = ''
SEXO_CHOICE = ((AMBOS, _('Ambos')), (FEMININO, _('Feminino')),
(MASCULINO, _('Masculino')))
DEPOIS_PRONOME = 'DP'
LINHA_NOME = 'LN'
DEPOIS_NOME = 'DN'
LOCAL_CARGO_CHOICE = ((DEPOIS_PRONOME,
_('Depois do Pronome '
'de tratamento')),
(LINHA_NOME, _('Antes do Nome do Contato')),
(DEPOIS_NOME,
_('Entre o Nome do Contato '
'e seu Endereço')))
FILHOS_CHOICE = [(None, _('Ambos'))] + YES_NO_CHOICES
search = MethodFilter()
sexo = ChoiceFilter(choices=SEXO_CHOICE)
tem_filhos = ChoiceFilter(choices=FILHOS_CHOICE)
idade = MethodRangeFilter(label=_('Idade entre:'),
widget=RangeWidgetNumber)
impresso = ModelChoiceFilter(required=False,
queryset=ImpressoEnderecamento.objects.all(),
action=filter_impresso)
grupo = MethodModelChoiceFilter(required=False,
queryset=GrupoDeContatos.objects.all())
imprimir_pronome = MethodChoiceFilter(choices=YES_NO_CHOICES,
initial=False)
imprimir_cargo = MethodChoiceFilter(choices=YES_NO_CHOICES, initial=False)
fontsize = MethodNumberFilter(
label=_('Tamanho da Fonte'),
initial='',
max_value=100,
min_value=0,
max_digits=3,
decimal_places=0,
)
nome_maiusculo = MethodChoiceFilter(label=_('Nome Maiúsculo'),
choices=YES_NO_CHOICES,
initial=False)
local_cargo = MethodChoiceFilter(label=_('Local para imprimir o Cargo'),
choices=LOCAL_CARGO_CHOICE,
initial=False)
def filter_fontsize(self, queryset, value):
return queryset
def filter_grupo(self, queryset, value):
queryset = queryset.filter(grupodecontatos_set=value)
return queryset
def filter_local_cargo(self, queryset, value):
return queryset
def filter_imprimir_pronome(self, queryset, value):
return queryset
def filter_imprimir_cargo(self, queryset, value):
return queryset
def filter_nome_maiusculo(self, queryset, value):
return queryset
def filter_idade(self, queryset, value):
idi = int(value.start) if value.start is not None else 0
idf = int(
value.stop) if value.stop is not None else date.today().year - 2
if idi > idf:
a = idi
idi = idf
idf = a
# lim inicial-dt.mais antiga
li = date.today() - relativedelta(years=idf + 1)
# lim final - dt. mais nova
lf = date.today() - relativedelta(years=idi)
return queryset.filter(data_nascimento__gt=li, data_nascimento__lte=lf)
def filter_search(self, queryset, value):
query = normalize(value)
query = query.split(' ')
if query:
q = Q()
for item in query:
if not item:
continue
q = q & Q(search__icontains=item)
if q:
queryset = queryset.filter(q)
return queryset
def filter_data_nascimento(self, queryset, value):
# _where = ("date_part('year', age(timestamp '%s', "
# "data_nascimento)) != date_part('year', "
# "age(timestamp '%s', data_nascimento))"
# return queryset.extra(where=_where, params=value)
if not value[0] or not value[1]:
return queryset
now = datetime.datetime.strptime(value[0], "%d/%m/%Y").date()
then = datetime.datetime.strptime(value[1], "%d/%m/%Y").date()
if now > then:
a = now
now = then
then = a
# Build the list of month/day tuples.
monthdays = [(now.month, now.day)]
while now <= then:
monthdays.append((now.month, now.day))
now += timedelta(days=1)
# Tranform each into queryset keyword args.
monthdays = (dict(
zip(("data_nascimento__month", "data_nascimento__day"), t))
for t in monthdays)
# Compose the djano.db.models.Q objects together for a single query.
query = reduce(operator.or_, (Q(**d) for d in monthdays))
# Run the query.
return queryset.extra(
select={
'month': 'extract( month from data_nascimento )',
'day': 'extract( day from data_nascimento )',
}).order_by('month', 'day', 'nome').filter(query)
class Meta:
model = Contato
fields = [
'search', 'sexo', 'tem_filhos', 'data_nascimento',
'tipo_autoridade'
]
def __init__(self,
data=None,
queryset=None,
prefix=None,
strict=None,
**kwargs):
workspace = kwargs.pop('workspace')
super(ImpressoEnderecamentoContatoFilterSet,
self).__init__(data=data,
queryset=queryset,
prefix=prefix,
strict=strict,
**kwargs)
col1 = to_row([
('search', 6),
('sexo', 3),
('tem_filhos', 3),
('data_nascimento', 6),
('idade', 6),
('tipo_autoridade', 6),
('grupo', 6),
])
col2 = to_row([
('impresso', 12),
('fontsize', 4),
('nome_maiusculo', 4),
('imprimir_pronome', 4),
('imprimir_cargo', 5),
('local_cargo', 7),
])
row = to_row([
(Fieldset(
_('Informações para Seleção de Contatos'), col1,
to_row([(SubmitFilterPrint('filter',
value=_('Filtrar'),
css_class='btn-default pull-right',
type='submit'), 12)])), 6),
(Fieldset(
_('Informações para Impressão'), col2,
to_row([(SubmitFilterPrint('print',
value=_('Imprimir'),
css_class='btn-primary pull-right',
type='submit'), 12)])), 6)
])
self.form.helper = FormHelper()
self.form.helper.form_method = 'GET'
self.form.helper.layout = Layout(row, )
self.form.fields['search'].label = _('Nome/Nome Social/Apelido')
self.form.fields['data_nascimento'].label = '%s (%s)' % (
_('Aniversário'), _('Inicial - Final'))
self.form.fields['tem_filhos'].label = _('Com filhos?')
self.form.fields['tem_filhos'].choices[0] = (None, _('Ambos'))
self.form.fields['imprimir_pronome'].widget = forms.RadioSelect()
self.form.fields['imprimir_pronome'].inline_class = True
self.form.fields['imprimir_cargo'].widget = forms.RadioSelect()
self.form.fields['imprimir_cargo'].inline_class = True
self.form.fields['nome_maiusculo'].widget = forms.RadioSelect()
self.form.fields['nome_maiusculo'].inline_class = True
self.form.fields['grupo'].queryset = GrupoDeContatos.objects.filter(
workspace=workspace)
class ContatoAgrupadoPorGrupoFilterSet(FilterSet):
search = MethodFilter()
municipio = MethodModelChoiceFilter(required=False,
queryset=Municipio.objects.all())
grupo = MethodModelMultipleChoiceFilter(
required=False, queryset=GrupoDeContatos.objects.all())
ativo = BooleanFilter()
# contato_ativo = MethodChoiceFilter(
# choices=NONE_YES_NO_CHOICES,
# initial=None)
def filter_municipio(self, queryset, value):
queryset = queryset.filter(endereco_set__municipio=value)
return queryset
def filter_grupo(self, queryset, value):
if value:
queryset = queryset.filter(grupodecontatos_set__in=value)
return queryset.order_by('grupodecontatos_set__nome', 'nome')
def filter_ativo(self, queryset, value):
if value is not None:
queryset = queryset.filter(ativo=value)
return queryset
# def filter_contato_ativo(self, queryset, value):
# if value is not None:
# queryset = queryset.filter(ativo=value)
#
# return queryset
class Meta:
model = Contato
def __init__(self,
data=None,
queryset=None,
prefix=None,
strict=None,
**kwargs):
workspace = kwargs.pop('workspace')
super(ContatoAgrupadoPorGrupoFilterSet,
self).__init__(data=data,
queryset=queryset,
prefix=prefix,
strict=strict,
**kwargs)
c1_row1 = to_row([
('municipio', 7),
('grupo', 7),
('ativo', 7),
])
col1 = Fieldset(
_('Informações para Seleção de Contados'), c1_row1,
to_row([(SubmitFilterPrint('filter',
value=_('Filtrar'),
css_class='btn-default pull-right',
type='submit'), 12)]))
col2 = Fieldset(
_('Inf p/ Impressão'),
SubmitFilterPrint('print',
value=_('Imprimir'),
css_class='btn-primary pull-right',
type='submit'))
rows = to_row([
(col1, 9),
(col2, 3),
])
self.form.helper = FormHelper()
self.form.helper.form_method = 'GET'
self.form.helper.layout = Layout(rows, )
self.form.fields['grupo'].queryset = GrupoDeContatos.objects.filter(
workspace=workspace)
self.form.fields['municipio'].queryset = Municipio.objects.all()
class AutoresPossiveisFilterSet(FilterSet):
data_relativa = DateFilter(method='filter_data_relativa')
tipo = MethodFilter()
class Meta:
model = Autor
fields = ['data_relativa', 'tipo', ]
def filter_data_relativa(self, queryset, name, value):
return queryset
def filter_tipo(self, queryset, value):
try:
tipo = TipoAutor.objects.get(pk=value)
except:
raise serializers.ValidationError(_('Tipo de Autor inexistente.'))
qs = queryset.filter(tipo=tipo)
return qs
@property
def qs(self):
qs = super().qs
data_relativa = self.form.cleaned_data['data_relativa'] \
if 'data_relativa' in self.form.cleaned_data else None
tipo = self.form.cleaned_data['tipo'] \
if 'tipo' in self.form.cleaned_data else None
if not tipo and not data_relativa:
return qs
if tipo:
# não precisa de try except, já foi validado em filter_tipo
tipo = TipoAutor.objects.get(pk=tipo)
if not tipo.content_type:
return qs
filter_for_model = 'filter_%s' % tipo.content_type.model
if not hasattr(self, filter_for_model):
return qs
if not data_relativa:
data_relativa = timezone.now()
return getattr(self, filter_for_model)(qs, data_relativa).distinct()
def filter_parlamentar(self, queryset, data_relativa):
# não leva em conta afastamentos
legislatura_relativa = Legislatura.objects.filter(
data_inicio__lte=data_relativa,
data_fim__gte=data_relativa).first()
q = Q(
parlamentar_set__mandato__data_inicio_mandato__lte=data_relativa,
parlamentar_set__mandato__data_fim_mandato__isnull=True) | Q(
parlamentar_set__mandato__data_inicio_mandato__lte=data_relativa,
parlamentar_set__mandato__data_fim_mandato__gte=data_relativa)
if legislatura_relativa.atual():
q = q & Q(parlamentar_set__ativo=True)
return queryset.filter(q)
def filter_comissao(self, queryset, data_relativa):
return queryset.filter(
Q(comissao_set__data_extincao__isnull=True,
comissao_set__data_fim_comissao__isnull=True) |
Q(comissao_set__data_extincao__gte=data_relativa,
comissao_set__data_fim_comissao__isnull=True) |
Q(comissao_set__data_extincao__gte=data_relativa,
comissao_set__data_fim_comissao__isnull=True) |
Q(comissao_set__data_extincao__isnull=True,
comissao_set__data_fim_comissao__gte=data_relativa) |
Q(comissao_set__data_extincao__gte=data_relativa,
comissao_set__data_fim_comissao__gte=data_relativa),
comissao_set__data_criacao__lte=data_relativa)
def filter_frente(self, queryset, data_relativa):
return queryset.filter(
Q(frente_set__data_extincao__isnull=True) |
Q(frente_set__data_extincao__gte=data_relativa),
frente_set__data_criacao__lte=data_relativa)
def filter_bancada(self, queryset, data_relativa):
return queryset.filter(
Q(bancada_set__data_extincao__isnull=True) |
Q(bancada_set__data_extincao__gte=data_relativa),
bancada_set__data_criacao__lte=data_relativa)
def filter_bloco(self, queryset, data_relativa):
return queryset.filter(
Q(bloco_set__data_extincao__isnull=True) |
Q(bloco_set__data_extincao__gte=data_relativa),
bloco_set__data_criacao__lte=data_relativa)
def filter_orgao(self, queryset, data_relativa):
# na implementação, não havia regras a implementar para orgao
return queryset
