Merge master

.travis.yml

@@ -14,6 +14,7 @@ before_script:
   - cp sapl/.env_test sapl/.env
   - psql -c "CREATE USER sapl WITH PASSWORD 'sapl'" -U postgres;
   - psql -c "CREATE DATABASE sapl OWNER sapl;" -U postgres
+  - ./check_migrations.sh
 
 script:
   - ./manage.py migrate

check_migrations.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# TODO: Após migrar para Django 1.10 usar
+#
+#       ./manage.py makemigrations --check --dry-run
+#
+# ATENÇÃO: a chamada atual termina com exit 1 se NÃO HÁ migração a ser aplicada
+#          ou seja, termina com "erro" se está tudo bem!
+#          A chamada do django 1.10 INVERTE ISSO.
+#
+# https://docs.djangoproject.com/en/1.10/ref/django-admin/#cmdoption-makemigrations-check
+
+python manage.py makemigrations --dry-run --exit
+
+MIGRATIONS=$?
+
+NC='\033[0m'
+
+if [ $MIGRATIONS -eq 0 ]; then
+    RED='\033[0;31m'
+    echo
+    echo -e "${RED}ALGUMAS ALTERAÇÕES EXIGEM MIGRAÇÃO.${NC}"
+    echo -e "${RED}RODE 'python manage.py makemigrations' ANTES DE SUBMETER SEU CÓDIGO...${NC}"
+    echo
+    exit 1
+fi

create_admin.py

@@ -1,28 +1,34 @@
 import os
 import sys
+
 import django
-from sapl import settings
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "sapl.settings")
 
+
 def create_superuser():
     from django.contrib.auth.models import User
 
     username = "admin"
-    password = os.environ['ADMIN_PASSWORD'] if 'ADMIN_PASSWORD' in os.environ else None
+    password = os.environ[
+        'ADMIN_PASSWORD'] if 'ADMIN_PASSWORD' in os.environ else None
     email = os.environ['ADMIN_EMAIL'] if 'ADMIN_EMAIL' in os.environ else ''
 
     if User.objects.filter(username=username).exists():
-        print("[SUPERUSER] User %s already exists. Exiting without change." % username)
+        print("[SUPERUSER] User %s already exists."
+              " Exiting without change." % username)
         sys.exit('ADMIN_USER_EXISTS')
     else:
         if not password:
-            print("[SUPERUSER] Environment variable $ADMIN_PASSWORD for user %s was not set. Leaving..." % username)
+            print(
+                "[SUPERUSER] Environment variable $ADMIN_PASSWORD"
+                " for user %s was not set. Leaving..." % username)
             sys.exit('MISSING_ADMIN_PASSWORD')
 
         print("[SUPERUSER] Creating superuser...")
 
-        u = User.objects.create_superuser(username=username, password=password, email=email)
+        u = User.objects.create_superuser(
+            username=username, password=password, email=email)
         u.save()
 
         print("[SUPERUSER] Done.")

docker-compose.yml

@@ -10,7 +10,7 @@ sapldb:
   ports:
     - "5532:5432"
 sapl:
-  image: interlegis/sapl:3.1.18-BETA
+  image: interlegis/sapl:3.1.21-BETA
   volumes:
     - sapl_data:/var/interlegis/sapl/data
     - sapl_media:/var/interlegis/sapl/media

fix_qa.sh

@@ -8,4 +8,5 @@
 # Uma forma simples de fazer isso é adicionando antes suas mudanças à
 # "staging area" do git, com `git add .` e após usar o script `git diff`.
 
-isort --recursive --skip='migrations' --skip='templates' --skip='ipython_log.py' .
+isort --recursive --skip='migrations' --skip='templates' --skip='ipython_log.py*' .
+autopep8 --in-place --recursive . --exclude='migrations,ipython_log.py*'

genkey.py

@@ -2,7 +2,9 @@ import random
 
 
 def generate_secret():
-    return ''.join([random.SystemRandom().choice('abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)') for i in range(50)])
+    return (''.join([random.SystemRandom().choice(
+        'abcdefghijklmnopqrst'
+        'uvwxyz0123456789!@#$%^&*(-_=+)') for i in range(50)]))
 
 if __name__ == '__main__':
     print(generate_secret())

requirements/dev-requirements.txt

@@ -1,6 +1,6 @@
 -r test-requirements.txt
 autopep8==1.2.4
-beautifulsoup4==4.4.1
+beautifulsoup4==4.6.0
 django-debug-toolbar==1.5
 ipdb==0.10.1
 pip-review==0.4

requirements/requirements.txt

@@ -32,4 +32,5 @@ pysolr==3.6.0
 python-magic==0.4.12
 gunicorn==19.6.0
 django-reversion==2.0.8
+WeasyPrint==0.30
 whoosh==2.7.4

sapl/api/forms.py

@@ -1,9 +1,9 @@
-from django.db.models import Q, F
+from django.db.models import Q
 from django.forms.fields import CharField, MultiValueField
 from django.forms.widgets import MultiWidget, TextInput
 from django.utils import timezone
 from django.utils.translation import ugettext_lazy as _
-from django_filters.filters import MethodFilter, ModelChoiceFilter, DateFilter
+from django_filters.filters import DateFilter, MethodFilter, ModelChoiceFilter
 from rest_framework import serializers
 from rest_framework.compat import django_filters
 from rest_framework.filters import FilterSet

sapl/api/serializers.py

@@ -64,14 +64,18 @@ class SessaoPlenariaSerializer(serializers.ModelSerializer):
     txtSiglaOrgao = serializers.SerializerMethodField('get_sigla_orgao')
     txtApelido = serializers.SerializerMethodField('get_name')
     txtNomeOrgao = serializers.SerializerMethodField('get_nome_orgao')
-    codEstadoReuniao = serializers.SerializerMethodField('get_estadoSessaoPlenaria')
+    codEstadoReuniao = serializers.SerializerMethodField(
+        'get_estadoSessaoPlenaria')
     txtTipoReuniao = serializers.SerializerMethodField('get_tipo_sessao')
     txtObjeto = serializers.SerializerMethodField('get_assunto_sessao')
     txtLocal = serializers.SerializerMethodField('get_endereco_orgao')
-    bolReuniaoConjunta = serializers.SerializerMethodField('get_reuniao_conjunta')
-    bolHabilitarEventoInterativo = serializers.SerializerMethodField('get_iterativo')
+    bolReuniaoConjunta = serializers.SerializerMethodField(
+        'get_reuniao_conjunta')
+    bolHabilitarEventoInterativo = serializers.SerializerMethodField(
+        'get_iterativo')
     idYoutube = serializers.SerializerMethodField('get_url')
-    codEstadoTransmissaoYoutube = serializers.SerializerMethodField('get_estadoTransmissaoYoutube')
+    codEstadoTransmissaoYoutube = serializers.SerializerMethodField(
+        'get_estadoTransmissaoYoutube')
     datReuniaoString = serializers.SerializerMethodField('get_date')
 
     # Constantes SessaoPlenaria (de 1-9) (apenas 3 serão usados)
@@ -106,7 +110,6 @@ class SessaoPlenariaSerializer(serializers.ModelSerializer):
 
     def __init__(self, *args, **kwargs):
         super(SessaoPlenariaSerializer, self).__init__(args, kwargs)
-        casa = CasaLegislativa.objects.first()
 
     def get_pk_sessao(self, obj):
         return obj.pk
@@ -146,6 +149,7 @@ class SessaoPlenariaSerializer(serializers.ModelSerializer):
                 return self.TRANSMISSAO_EM_ANDAMENTO
         else:
             return self.SEM_TRANSMISSAO
+
     def get_assunto_sessao(self, obj):
         pauta_sessao = ''
         ordem_dia = OrdemDia.objects.filter(sessao_plenaria=obj.pk)

sapl/api/urls.py

@@ -2,9 +2,9 @@ from django.conf import settings
 from django.conf.urls import include, url
 from rest_framework.routers import DefaultRouter
 
-from sapl.api.views import (AutorListView, MateriaLegislativaViewSet,
-                            ModelChoiceView, SessaoPlenariaViewSet,
-                            AutoresPossiveisListView, AutoresProvaveisListView)
+from sapl.api.views import (AutoresPossiveisListView, AutoresProvaveisListView,
+                            AutorListView, MateriaLegislativaViewSet,
+                            ModelChoiceView, SessaoPlenariaViewSet)
 
 from .apps import AppConfig
 

sapl/api/views.py

@@ -7,10 +7,10 @@ from rest_framework.generics import ListAPIView
 from rest_framework.mixins import ListModelMixin, RetrieveModelMixin
 from rest_framework.permissions import (AllowAny, IsAuthenticated,
                                         IsAuthenticatedOrReadOnly)
-from rest_framework.viewsets import GenericViewSet, ModelViewSet
+from rest_framework.viewsets import GenericViewSet
 
-from sapl.api.forms import AutorChoiceFilterSet, AutorSearchForFieldFilterSet,\
-    AutoresPossiveisFilterSet
+from sapl.api.forms import (AutorChoiceFilterSet, AutoresPossiveisFilterSet,
+                            AutorSearchForFieldFilterSet)
 from sapl.api.serializers import (AutorChoiceSerializer, AutorSerializer,
                                   ChoiceSerializer,
                                   MateriaLegislativaSerializer,
@@ -173,8 +173,6 @@ class AutoresProvaveisListView(ListAPIView):
     serializer_class = ChoiceSerializer
 
     def get_queryset(self):
-        queryset = ListAPIView.get_queryset(self)
-
         params = {'content_type__isnull': False}
 
         tipo = ''

sapl/base/forms.py

@@ -1,3 +1,4 @@
+import django_filters
 from crispy_forms.bootstrap import FieldWithButtons, InlineRadios, StrictButton
 from crispy_forms.helper import FormHelper
 from crispy_forms.layout import HTML, Button, Div, Field, Fieldset, Layout, Row
@@ -7,14 +8,12 @@ from django.contrib.auth import get_user_model
 from django.contrib.auth.forms import (AuthenticationForm, PasswordResetForm,
                                        SetPasswordForm)
 from django.contrib.auth.models import Group, User
-from django.contrib.auth.password_validation import validate_password
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.db import models, transaction
 from django.forms import ModelForm
-from django.utils.translation import string_concat
 from django.utils.translation import ugettext_lazy as _
-import django_filters
+from django.utils.translation import string_concat
 
 from sapl.base.models import Autor, TipoAutor
 from sapl.crispy_layout_mixin import (SaplFormLayout, form_actions, to_column,
@@ -24,20 +23,12 @@ from sapl.sessao.models import SessaoPlenaria
 from sapl.settings import MAX_IMAGE_UPLOAD_SIZE
 from sapl.utils import (RANGE_ANOS, ChoiceWithoutValidationField,
                         ImageThumbnailFileInput, RangeWidgetOverride,
-                        autor_label, autor_modal, models_with_gr_for_model)
+                        autor_label, autor_modal, models_with_gr_for_model,
+                        qs_override_django_filter)
 
 from .models import AppConfig, CasaLegislativa
 
-
 ACTION_CREATE_USERS_AUTOR_CHOICE = [
-    ('C', _('Criar novo Usuário')),
-    ('A', _('Associar um usuário existente')),
-    ('N', _('Autor sem Usuário de Acesso ao Sapl')),
-]
-
-
-ACTION_CREATE_USERS_AUTOR_CHOICE = [
-    ('C', _('Criar novo Usuário')),
     ('A', _('Associar um usuário existente')),
     ('N', _('Autor sem Usuário de Acesso ao Sapl')),
 ]
@@ -256,42 +247,7 @@ class AutorForm(ModelForm):
             if self.instance.user:
                 qs_user = qs_user.exclude(pk=self.instance.user.pk)
 
-        if cd['action_user'] == 'C':
-            param_username = {get_user_model().USERNAME_FIELD: cd['username']}
-            if User.objects.filter(**param_username).exists():
-                raise ValidationError(
-                    _('Já existe usuário com o username "%s". '
-                      'Para utilizar esse username você deve selecionar '
-                      '"Associar um usuário existente".') % cd['username'])
-
-            if ('senha' not in cd or 'senha_confirma' not in cd or
-                    not cd['senha'] or not cd['senha_confirma']):
-                raise ValidationError(_(
-                    'A senha e sua confirmação devem ser informadas.'))
-            msg = _('As senhas não conferem.')
-            self.valida_igualdade(cd['senha'], cd['senha_confirma'], msg)
-
-            try:
-                validate_password(self.cleaned_data['senha'])
-            except ValidationError as error:
-                raise ValidationError(error)
-
-            if ('email' not in cd or 'confirma_email' not in cd or
-                    not cd['email'] or not cd['confirma_email']):
-                raise ValidationError(_(
-                    'O email e sua confirmação devem ser informados.'))
-            msg = _('Os emails não conferem.')
-            self.valida_igualdade(cd['email'], cd['confirma_email'], msg)
-
-            if not settings.DEBUG:
-                if qs_user.filter(email=cd['email']).exists():
-                    raise ValidationError(_('Este email já foi cadastrado.'))
-
-                if qs_autor.filter(user__email=cd['email']).exists():
-                    raise ValidationError(
-                        _('Já existe um Autor com este email.'))
-
-        elif cd['action_user'] == 'A':
+        if cd['action_user'] == 'A':
             param_username = {get_user_model().USERNAME_FIELD: cd['username']}
             if not User.objects.filter(**param_username).exists():
                 raise ValidationError(
@@ -362,22 +318,7 @@ class AutorForm(ModelForm):
             if not u.is_active:
                 u.is_active = settings.DEBUG
                 u.save()
-        elif self.cleaned_data['action_user'] == 'C':
-
-            param_username = {
-                get_user_model().USERNAME_FIELD: self.cleaned_data['username']}
-
-            if get_user_model().USERNAME_FIELD != 'email':
-                param_username['email'] = self.cleaned_data['email']
 
-            u = get_user_model().objects.create(**param_username)
-
-            u.set_password(self.cleaned_data['senha'])
-            # Define usuário como ativo em ambiente de desenvolvimento
-            # pode logar sem a necessidade de passar pela validação de email
-            # troque par False para testar o envio de email em desenvolvimento
-            u.is_active = settings.DEBUG
-            u.save()
         autor.user = u
 
         if not autor.tipo.content_type:
@@ -501,6 +442,10 @@ class RelatorioPresencaSessaoFilterSet(django_filters.FilterSet):
                      row1, form_actions(save_label='Pesquisar'))
         )
 
+    @property
+    def qs(self):
+        return qs_override_django_filter(self)
+
 
 class RelatorioHistoricoTramitacaoFilterSet(django_filters.FilterSet):
 

sapl/base/migrations/0008_auto_20170814_1409.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.13 on 2017-08-14 14:09
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('base', '0007_auto_20170808_0850'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='appconfig',
+            name='sequencia_numeracao',
+            field=models.CharField(choices=[('A', 'Sequencial por ano'), ('L', 'Sequencial por legislatura'), ('U', 'Sequencial único')], default='A', max_length=1, verbose_name='Sequência de numeração'),
+        ),
+    ]

sapl/base/models.py

@@ -1,16 +1,16 @@
+import reversion
 from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType
 from django.db import models
 from django.utils.translation import ugettext_lazy as _
-import reversion
 
 from sapl.utils import UF, YES_NO_CHOICES, get_settings_auth_user_model
 
-
 TIPO_DOCUMENTO_ADMINISTRATIVO = (('O', _('Ostensivo')),
                                  ('R', _('Restritivo')))
 
 SEQUENCIA_NUMERACAO = (('A', _('Sequencial por ano')),
+                       ('L', _('Sequencial por legislatura')),
                        ('U', _('Sequencial único')))
 
 

sapl/base/templatetags/common_tags.py

@@ -5,6 +5,7 @@ from sapl.base.models import AppConfig
 from sapl.materia.models import DocumentoAcessorio, MateriaLegislativa
 from sapl.norma.models import NormaJuridica
 from sapl.parlamentares.models import Filiacao
+from sapl.utils import filiacao_data
 
 register = template.Library()
 
@@ -117,6 +118,7 @@ def str2intabs(value):
     except:
         return ''
 
+
 @register.filter
 def has_iframe(request):
 
@@ -180,3 +182,13 @@ def urldetail_content_type(obj, value):
 def urldetail(obj):
     return '%s:%s_detail' % (
         obj._meta.app_config.name, obj._meta.model_name)
+
+
+@register.filter
+def filiacao_data_filter(parlamentar, data_inicio):
+    return filiacao_data(parlamentar, data_inicio)
+
+
+@register.filter
+def filiacao_intervalo_filter(parlamentar, date_range):
+    return filiacao_data(parlamentar, date_range[0], date_range[1])

sapl/base/tests/test_form.py

@@ -0,0 +1,20 @@
+from django.utils.translation import ugettext_lazy as _
+
+from sapl.base.forms import CasaLegislativaForm
+
+
+def test_valida_campos_obrigatorios_casa_legislativa_form():
+    form = CasaLegislativaForm(data={})
+
+    assert not form.is_valid()
+
+    errors = form.errors
+
+    assert errors['nome'] == [_('Este campo é obrigatório.')]
+    assert errors['sigla'] == [_('Este campo é obrigatório.')]
+    assert errors['endereco'] == [_('Este campo é obrigatório.')]
+    assert errors['cep'] == [_('Este campo é obrigatório.')]
+    assert errors['municipio'] == [_('Este campo é obrigatório.')]
+    assert errors['uf'] == [_('Este campo é obrigatório.')]
+
+    assert len(errors) == 6

sapl/base/tests/teststub_urls.py

@@ -3,8 +3,9 @@ from django.views.generic.base import TemplateView
 
 from sapl.urls import urlpatterns as original_patterns
 
-urlpatterns = original_patterns + patterns('', url(r'^zzzz$',
+ptrn = patterns('',
+                url(r'^zzzz$',
                     TemplateView.as_view(
-                                               template_name='index.html'),
-                                           name='zzzz')
-                                           )
+                        template_name='index.html'), name='zzzz'))
+
+urlpatterns = original_patterns + ptrn

sapl/base/urls.py

@@ -16,8 +16,7 @@ from .views import (AppConfigCrud, CasaLegislativaCrud, HelpView,
                     RelatorioMateriasPorAnoAutorTipoView,
                     RelatorioMateriasPorAutorView,
                     RelatorioMateriasTramitacaoView,
-                    RelatorioPresencaSessaoView,
-                    SaplSearchView)
+                    RelatorioPresencaSessaoView, SaplSearchView)
 
 app_name = AppConfig.name
 

sapl/base/views.py

@@ -4,25 +4,26 @@ from django.contrib.auth import get_user_model
 from django.contrib.auth.mixins import PermissionRequiredMixin
 from django.contrib.auth.models import Group
 from django.contrib.auth.tokens import default_token_generator
+from django.core.exceptions import ObjectDoesNotExist
 from django.core.mail import send_mail
 from django.core.urlresolvers import reverse
-from django.db.models import Count, Q
+from django.db.models import Count
 from django.http import HttpResponseRedirect
 from django.utils.encoding import force_bytes
 from django.utils.http import urlsafe_base64_decode, urlsafe_base64_encode
 from django.utils.translation import ugettext_lazy as _
 from django.views.generic.base import TemplateView
 from django_filters.views import FilterView
-
 from haystack.views import SearchView
 
 from sapl.base.forms import AutorForm, AutorFormForAdmin, TipoAutorForm
 from sapl.base.models import Autor, TipoAutor
 from sapl.crud.base import CrudAux
-from sapl.materia.models import MateriaLegislativa, TipoMateriaLegislativa
-from sapl.parlamentares.models import Parlamentar
-from sapl.sessao.models import PresencaOrdemDia, SessaoPlenaria
-from sapl.utils import sapl_logger
+from sapl.materia.models import (Autoria, MateriaLegislativa,
+                                 TipoMateriaLegislativa)
+from sapl.sessao.models import (PresencaOrdemDia, SessaoPlenaria,
+                                SessaoPlenariaPresenca)
+from sapl.utils import parlamentares_ativos, sapl_logger
 
 from .forms import (CasaLegislativaForm, ConfiguracoesAppForm,
                     RelatorioAtasFilterSet,
@@ -209,15 +210,6 @@ class RelatorioPresencaSessaoView(FilterView):
     filterset_class = RelatorioPresencaSessaoFilterSet
     template_name = 'base/RelatorioPresencaSessao_filter.html'
 
-    def calcular_porcentagem_presenca(self,
-                                      parlamentares,
-                                      total_sessao,
-                                      total_ordemdia):
-        for p in parlamentares:
-            p.sessao_porc = round(p.sessao_count * 100 / total_sessao, 1)
-            p.ordemdia_porc = round(p.ordemdia_count * 100 / total_ordemdia, 1)
-        return parlamentares
-
     def get_context_data(self, **kwargs):
         context = super(RelatorioPresencaSessaoView,
                         self).get_context_data(**kwargs)
@@ -234,37 +226,68 @@ class RelatorioPresencaSessaoView(FilterView):
 
             sufixo = 'sessao_plenaria__data_inicio__range'
             param0 = {'%s' % sufixo: _range}
-            param1 = {'presencaordemdia__%s' % sufixo: _range}
-            param2 = {'sessaoplenariapresenca__%s' % sufixo: _range}
-
-            pls = Parlamentar.objects.filter(
-                (Q(**param1) | Q(presencaordemdia__isnull=True)) &
-                (Q(**param2) | Q(sessaoplenariapresenca__isnull=True))
-            ).annotate(
-                sessao_count=Count(
-                    'sessaoplenariapresenca__sessao_plenaria',
-                    distinct=True),
-                ordemdia_count=Count(
-                    'presencaordemdia__sessao_plenaria',
-                    distinct=True),
-                sessao_porc=Count(0),
-                ordemdia_porc=Count(0)
-            ).exclude(
-                sessao_count=0,
-                ordemdia_count=0)
+
+            # Parlamentares com Mandato no intervalo de tempo (Ativos)
+            parlamentares_qs = parlamentares_ativos(
+                _range[0], _range[1]).order_by('nome_parlamentar')
+            parlamentares_id = parlamentares_qs.values_list(
+                'id', flat=True)
+
+            # Presenças de cada Parlamentar em Sessões
+            presenca_sessao = SessaoPlenariaPresenca.objects.filter(
+                parlamentar_id__in=parlamentares_id,
+                sessao_plenaria__data_inicio__range=_range).values_list(
+                'parlamentar_id').annotate(
+                sessao_count=Count('id'))
+
+            # Presenças de cada Ordem do Dia
+            presenca_ordem = PresencaOrdemDia.objects.filter(
+                parlamentar_id__in=parlamentares_id,
+                sessao_plenaria__data_inicio__range=_range).values_list(
+                'parlamentar_id').annotate(
+                sessao_count=Count('id'))
 
             total_ordemdia = PresencaOrdemDia.objects.filter(
                 **param0).distinct('sessao_plenaria__id').order_by(
                 'sessao_plenaria__id').count()
 
-            self.calcular_porcentagem_presenca(
-                pls,
-                context['object_list'].count(),
-                total_ordemdia)
+            total_sessao = context['object_list'].count()
 
+            # Completa o dicionario as informacoes parlamentar/sessao/ordem
+            parlamentares_presencas = []
+            for i, p in enumerate(parlamentares_qs):
+                parlamentares_presencas.append({
+                    'parlamentar': p,
+                    'sessao_porc': 0,
+                    'ordemdia_porc': 0
+                })
+                try:
+                    sessao_count = presenca_sessao.get(parlamentar_id=p.id)[1]
+                except ObjectDoesNotExist:
+                    sessao_count = 0
+                try:
+                    ordemdia_count = presenca_ordem.get(parlamentar_id=p.id)[1]
+                except ObjectDoesNotExist:
+                    ordemdia_count = 0
+
+                parlamentares_presencas[i].update({
+                    'sessao_count': sessao_count,
+                    'ordemdia_count': ordemdia_count
+                })
+
+                if total_sessao != 0:
+                    parlamentares_presencas[i].update(
+                        {'sessao_porc': round(
+                            sessao_count * 100 / total_sessao, 2)})
+                if total_ordemdia != 0:
+                    parlamentares_presencas[i].update(
+                        {'ordemdia_porc': round(
+                            ordemdia_count * 100 / total_ordemdia, 2)})
+
+            context['date_range'] = _range
             context['total_ordemdia'] = total_ordemdia
             context['total_sessao'] = context['object_list'].count()
-            context['parlamentares'] = pls
+            context['parlamentares'] = parlamentares_presencas
             context['periodo'] = (
                 self.request.GET['data_inicio_0'] +
                 ' - ' + self.request.GET['data_inicio_1'])
@@ -322,6 +345,46 @@ class RelatorioMateriasPorAnoAutorTipoView(FilterView):
     filterset_class = RelatorioMateriasPorAnoAutorTipoFilterSet
     template_name = 'base/RelatorioMateriasPorAnoAutorTipo_filter.html'
 
+    def get_materias_autor_ano(self, ano):
+
+        autorias = Autoria.objects.filter(materia__ano=ano).values(
+            'autor',
+            'materia__tipo__sigla',
+            'materia__tipo__descricao').annotate(
+                total=Count('materia__tipo')).order_by(
+                    'autor',
+                    'materia__tipo')
+
+        autores_ids = set([i['autor'] for i in autorias])
+
+        autores = dict((a.id, a) for a in Autor.objects.filter(
+            id__in=autores_ids))
+
+        relatorio = []
+        visitados = set()
+        curr = None
+
+        for a in autorias:
+            # se mudou autor, salva atual, caso existente, e reinicia `curr`
+            if a['autor'] not in visitados:
+                if curr:
+                    relatorio.append(curr)
+
+                curr = {}
+                curr['autor'] = autores[a['autor']]
+                curr['materia'] = []
+                curr['total'] = 0
+
+                visitados.add(a['autor'])
+
+            # atualiza valores
+            curr['materia'].append((a['materia__tipo__descricao'], a['total']))
+            curr['total'] += a['total']
+        # adiciona o ultimo
+        relatorio.append(curr)
+
+        return relatorio
+
     def get_filterset_kwargs(self, filterset_class):
         super(RelatorioMateriasPorAnoAutorTipoView,
               self).get_filterset_kwargs(filterset_class)
@@ -346,6 +409,12 @@ class RelatorioMateriasPorAnoAutorTipoView(FilterView):
         qr = self.request.GET.copy()
         context['filter_url'] = ('&' + qr.urlencode()) if len(qr) > 0 else ''
 
+        if 'ano' in self.request.GET and self.request.GET['ano']:
+            ano = int(self.request.GET['ano'])
+            context['relatorio'] = self.get_materias_autor_ano(ano)
+        else:
+            context['relatorio'] = []
+
         return context
 
 

sapl/comissoes/views.py

@@ -82,21 +82,23 @@ class ComissaoCrud(Crud):
     public = [RP_LIST, RP_DETAIL, ]
 
     class BaseMixin(Crud.BaseMixin):
-        list_field_names = ['nome', 'sigla', 'tipo', 'data_criacao', 'data_extincao', 'ativa']
+        list_field_names = ['nome', 'sigla', 'tipo',
+                            'data_criacao', 'data_extincao', 'ativa']
         ordering = '-ativa', 'sigla'
 
     class ListView(Crud.ListView):
+
         @xframe_options_exempt
         def get(self, request, *args, **kwargs):
             return super().get(request, *args, **kwargs)
 
     class DetailView(Crud.DetailView):
+
         @xframe_options_exempt
         def get(self, request, *args, **kwargs):
             return super().get(request, *args, **kwargs)
 
 
-
 class MateriasTramitacaoListView(ListView):
     template_name = "comissoes/materias_em_tramitacao.html"
     paginate_by = 10

sapl/compilacao/compilacao_data_tables.sql

@@ -16,24 +16,24 @@ INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html
 INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (104, 'Disposições Finais', 'disp_finais', '', 'Disposições Finais', 0, '', '<br>', '', '<br>', '', '', false, 'N', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
 INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (111, 'Anexo', 'anexo', '', 'Anexo ', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
 INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (112, 'Parte', 'parte', '', 'Parte ', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
-INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (113, 'Livro', 'livro', '', 'Livro ', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
-INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (114, 'Título', 'titulo', '', 'Título ', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
-INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (115, 'Capítulo', 'capitulo', '', 'Capítulo ', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', 'A', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (113, 'Livro', 'livro', '', 'LIVRO ', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (114, 'Título', 'titulo', '', 'TÍTULO ', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (115, 'Capítulo', 'capitulo', '', 'CAPÍTULO ', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', 'A', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
 INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (116, 'Seção', 'secao', '', 'Seção ', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
-INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (117, 'SubSeção', 'subsecao', '', 'SubSeção ', 0, '', '<br>', '', '<br>', '<br>', '', false, '1', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
-INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (119, 'Artigo', 'artigo', '', 'Art. ', 9, '.', '&nbsp;&ndash;&nbsp;', '', '', '', '', true, '1', 'A', '1', '1', '1', '1', '-', '-', '-', '-', '-', true, false);
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (117, 'Subseção', 'subsecao', '', 'Subseção ', 0, '', '<br>', '', '<br>', '<br>', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (119, 'Artigo', 'artigo', '', 'Art. ', 9, '.', '&nbsp;', '', '', '', '', true, '1', 'A', '1', '1', '1', '1', '-', '-', '-', '-', '-', true, false);
 INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (120, 'Caput', 'caput', '', '', 0, '', '', '', '', '', '', false, 'N', 'N', 'N', 'N', 'N', 'N', '-', '-', '-', '-', '-', false, false);
-INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (121, 'Parágrafo', 'paragrafo indent', '', '§ ;Parágrafo Único ', 9, '', '&nbsp;&ndash;&nbsp;', '', '', '', '', false, '1', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (121, 'Parágrafo', 'paragrafo indent', '', '§ ;Parágrafo único ', 9, '', '&nbsp;', '', '', '', '', false, '1', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
 INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (122, 'Inciso', 'inciso indent', '', '', 0, '', '&nbsp;&ndash;&nbsp;', '', '', '', '', false, 'I', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
-INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (123, 'Alinea', 'alinea indent', '', '', 0, ')', '&nbsp;&ndash;&nbsp;', '', '', '', '', false, 'a', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
-INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (124, 'Item', 'item indent', '', '', 0, '', '&nbsp;&ndash;&nbsp;', '', '', '', '', false, '1', '1', '1', '1', '1', '1', '.', '.', '.', '.', '.', false, false);
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (123, 'Alinea', 'alinea indent', '', '', 0, ')', '&nbsp;', '', '', '', '', false, 'a', '1', '1', '1', '1', '1', '-', '-', '-', '-', '-', false, false);
+INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (124, 'Item', 'item indent', '', '', 0, '', '&nbsp;', '', '', '', '', false, '1', '1', '1', '1', '1', '1', '.', '.', '.', '.', '.', false, false);
 INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (125, 'Texto Não Estruturado', 'texto_n_estruturado', '', '', 0, '', '', '', '', '', '', true, 'N', 'N', 'N', 'N', 'N', 'N', '-', '-', '-', '-', '-', false, false);
 INSERT INTO compilacao_tipodispositivo (id, nome, class_css, rotulo_prefixo_html, rotulo_prefixo_texto, rotulo_ordinal, rotulo_sufixo_texto, rotulo_sufixo_html, texto_prefixo_html, texto_sufixo_html, nota_automatica_prefixo_html, nota_automatica_sufixo_html, contagem_continua, formato_variacao0, formato_variacao1, formato_variacao2, formato_variacao3, formato_variacao4, formato_variacao5, rotulo_separador_variacao01, rotulo_separador_variacao12, rotulo_separador_variacao23, rotulo_separador_variacao34, rotulo_separador_variacao45, dispositivo_de_articulacao, dispositivo_de_alteracao) VALUES (126, 'Justificativa', 'justificativa', '', '', 0, '', '', '', '<div class="titulo">Justificativa</div>', '', '', true, 'N', 'N', 'N', 'N', 'N', 'N', '-', '-', '-', '-', '-', false, false);
 
 SELECT pg_catalog.setval('compilacao_tipodispositivo_id_seq', 126, true);
 
 
-delete from compilacao_tipodispositivorelationship;
+#delete from compilacao_tipodispositivorelationship;
 SELECT pg_catalog.setval('compilacao_tipodispositivorelationship_id_seq', 1, false);
 INSERT INTO compilacao_tipodispositivorelationship (filho_permitido_id, pai_id, filho_de_insercao_automatica, perfil_id, quantidade_permitida, permitir_variacao) VALUES (112, 1, false, 2, -1, true);
 INSERT INTO compilacao_tipodispositivorelationship (filho_permitido_id, pai_id, filho_de_insercao_automatica, perfil_id, quantidade_permitida, permitir_variacao) VALUES (114, 1, false, 2, -1, true);

sapl/compilacao/forms.py

@@ -1,7 +1,8 @@
 from datetime import timedelta
 
 from crispy_forms.bootstrap import (Alert, FieldWithButtons, FormActions,
-                                    InlineRadios, StrictButton)
+                                    InlineCheckboxes, InlineRadios,
+                                    StrictButton)
 from crispy_forms.helper import FormHelper
 from crispy_forms.layout import (HTML, Button, Column, Div, Field, Fieldset,
                                  Layout, Row, Submit)
@@ -859,6 +860,21 @@ class DispositivoEdicaoVigenciaForm(ModelForm):
             ('fim_vigencia', 3),
             ('inicio_eficacia', 3),
             ('fim_eficacia', 3), ])
+
+        inst = kwargs['instance']
+        while inst.auto_inserido and inst.dispositivo_pai:
+            inst = inst.dispositivo_pai
+
+        if (inst.dispositivos_vigencias_set.exists()):
+            row_datas.fields.append(
+                Alert(
+                    css_class='alert-info col-md-12',
+                    content='<strong>%s</strong> %s' % (
+                        _('Atenção!'),
+                        _('O Dispositivo em edição define vigência de outros '
+                          'dispositivos. Alterar as datas de vigência '
+                          'alterará as datas de vigência dos dispositivos '
+                          'vigêntes por este em edição.'))))
         layout.append(
             Fieldset(_('Datas de Controle de Vigência'),
                      row_datas,
@@ -909,17 +925,26 @@ class DispositivoEdicaoVigenciaForm(ModelForm):
         super(DispositivoEdicaoVigenciaForm, self).save()
 
         data = self.cleaned_data
+        instance = self.instance
+        inst = instance
 
-        extensao = 'extensao' in data and data['extensao'] == 'True'
+        while instance.auto_inserido and instance.dispositivo_pai:
+            dp = instance.dispositivo_pai
+            dp.inicio_vigencia = instance.inicio_vigencia
+            dp.inicio_eficacia = instance.inicio_eficacia
+            dp.fim_vigencia = instance.fim_vigencia
+            dp.fim_eficacia = instance.fim_vigencia
+            dp.save()
 
-        if extensao:
-            dv = data['dispositivo_vigencia']
+            instance = dp
 
+        dv = data['dispositivo_vigencia']
         if dv and dv.auto_inserido:
             dv = dv.dispositivo_pai
 
+        extensao = 'extensao' in data and data['extensao'] == 'True'
+        if extensao:
             dv_pk = dv.pk if dv else None
-            instance = self.instance
 
             def extenderPara(dpt_pk):
 
@@ -936,6 +961,26 @@ class DispositivoEdicaoVigenciaForm(ModelForm):
 
             extenderPara(instance.pk)
 
+        inst = instance
+        while instance.auto_inserido and instance.dispositivo_pai:
+            instance = instance.dispositivo_pai
+
+        inst.dispositivos_vigencias_set.filter(
+            ta_publicado__isnull=True).update(
+                inicio_vigencia=inst.inicio_vigencia,
+                inicio_eficacia=inst.inicio_eficacia,
+                fim_vigencia=inst.fim_vigencia,
+                fim_eficacia=inst.fim_eficacia)
+
+        inst.dispositivos_vigencias_set.filter(
+            ta_publicado__isnull=False).update(
+                inicio_vigencia=inst.inicio_eficacia,
+                inicio_eficacia=inst.inicio_eficacia,
+                fim_vigencia=inst.fim_eficacia,
+                fim_eficacia=inst.fim_eficacia)
+
+        return inst
+
 
 class MultipleChoiceWithoutValidationField(forms.MultipleChoiceField):
 
@@ -1249,20 +1294,20 @@ class DispositivoEdicaoAlteracaoForm(ModelForm):
 
 class TextNotificacoesForm(Form):
 
-    type_notificacoes = forms.ChoiceField(
+    type_notificacoes = forms.MultipleChoiceField(
         label=_('Níveis de Notificações'),
         choices=[('default', _('Dispositivos sem Notificações!')),
                  ('success', _('Informações!')),
                  ('info', _('Boas Práticas!')),
                  ('warning', _('Alertas!')),
                  ('danger', _('Erros!'))],
-        required=False)
+        required=False,
+        widget=widgets.CheckboxSelectMultiple())
 
     def __init__(self, *args, **kwargs):
 
-        field_type_notificacoes = to_row([(Field(
-            'type_notificacoes',
-            template="compilacao/layout/bootstrap_btn_checkbox.html"), 10),
+        field_type_notificacoes = to_row([(InlineCheckboxes(
+            'type_notificacoes'), 10),
             (Submit('submit-form', _('Filtrar'),
                     css_class='btn btn-primary pull-right'), 2)])
 

sapl/compilacao/migrations/0002_auto_20170825_1108.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.13 on 2017-08-25 11:08
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('compilacao', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='tipotextoarticulado',
+            name='content_type',
+            field=models.OneToOneField(null=True, on_delete=django.db.models.deletion.SET_NULL, to='contenttypes.ContentType', verbose_name='Modelo Integrado'),
+        ),
+    ]

sapl/compilacao/migrations/0003_auto_20170825_1136.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.13 on 2017-08-25 11:36
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('compilacao', '0002_auto_20170825_1108'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='tipotextoarticulado',
+            name='content_type',
+            field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='contenttypes.ContentType', verbose_name='Modelo Integrado'),
+        ),
+        migrations.AlterField(
+            model_name='tipotextoarticulado',
+            name='participacao_social',
+            field=models.BooleanField(choices=[(True, 'Sim'), (False, 'Não')], default=False, verbose_name='Participação Social'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='tipotextoarticulado',
+            name='publicacao_func',
+            field=models.BooleanField(choices=[(True, 'Sim'), (False, 'Não')], default=False, verbose_name='Histórico de Publicação'),
+            preserve_default=False,
+        ),
+    ]

sapl/compilacao/models.py

@@ -11,6 +11,7 @@ from django.db.models.deletion import PROTECT
 from django.http.response import Http404
 from django.template import defaultfilters
 from django.utils.decorators import classonlymethod
+from django.utils.encoding import force_text
 from django.utils.translation import ugettext_lazy as _
 
 from sapl.compilacao.utils import (get_integrations_view_names, int_to_letter,
@@ -110,18 +111,17 @@ class TipoTextoArticulado(models.Model):
     descricao = models.CharField(max_length=50, verbose_name=_('Descrição'))
     content_type = models.OneToOneField(
         ContentType,
-        null=True, default=None,
-        verbose_name=_('Modelo Integrado'))
-    participacao_social = models.NullBooleanField(
-        default=False,
         blank=True, null=True,
+        on_delete=models.SET_NULL,
+        verbose_name=_('Modelo Integrado'))
+    participacao_social = models.BooleanField(
+        blank=False,
         choices=YES_NO_CHOICES,
         verbose_name=_('Participação Social'))
 
-    publicacao_func = models.NullBooleanField(
-        default=False,
-        blank=True, null=True,
+    publicacao_func = models.BooleanField(
         choices=YES_NO_CHOICES,
+        blank=False,
         verbose_name=_('Histórico de Publicação'))
 
     perfis = models.ManyToManyField(
@@ -843,7 +843,7 @@ class Publicacao(TimestampedMixin):
 
 @reversion.register()
 class Dispositivo(BaseModel, TimestampedMixin):
-    TEXTO_PADRAO_DISPOSITIVO_REVOGADO = _('(Revogado)')
+    TEXTO_PADRAO_DISPOSITIVO_REVOGADO = force_text(_('(Revogado)'))
     INTERVALO_ORDEM = 1000
     ordem = models.PositiveIntegerField(
         default=0,

sapl/compilacao/templatetags/compilacao_filters.py

@@ -92,6 +92,10 @@ def nota_automatica(dispositivo, ta_pub_list):
         elif not dispositivo.dispositivo_substituido_id:
             return _('Inclusão feita pelo %s - %s.') % (
                 d, ta_publicado)
+        else:
+            if dispositivo.tipo_dispositivo.dispositivo_de_articulacao:
+                return _('Alteração de rótulo feita pelo %s - %s.') % (
+                    d, ta_publicado)
             else:
                 return _('Alteração feita pelo %s - %s.') % (
                     d, ta_publicado)
@@ -286,7 +290,6 @@ def nomenclatura_heranca(d, ignore_ultimo=0, ignore_primeiro=0):
     return result
 
 
-
 @register.filter
 def list(obj):
     return [obj, ]

sapl/compilacao/tests/test_tipo_texto_articulado_form.py

@@ -0,0 +1,76 @@
+import pytest
+from django.utils.translation import ugettext as _
+from model_mommy import mommy
+
+from sapl.compilacao import forms
+from sapl.compilacao.models import PerfilEstruturalTextoArticulado, TipoNota
+from sapl.compilacao.views import choice_models_in_extenal_views
+
+
+def test_valida_campos_obrigatorios_tipo_texto_articulado_form():
+    form = forms.TipoTaForm(data={})
+
+    assert not form.is_valid()
+
+    errors = form.errors
+
+    assert errors['sigla'] == [_('Este campo é obrigatório.')]
+    assert errors['descricao'] == [_('Este campo é obrigatório.')]
+    assert errors['participacao_social'] == [_('Este campo é obrigatório.')]
+    assert errors['publicacao_func'] == [_('Este campo é obrigatório.')]
+
+    assert len(errors) == 4
+
+
+_content_types = choice_models_in_extenal_views()
+
+
+@pytest.mark.parametrize('content_type', _content_types)
+@pytest.mark.django_db(transaction=False)
+def test_tipo_texto_articulado_form_valid(content_type):
+    perfil = mommy.make(PerfilEstruturalTextoArticulado)
+
+    form = forms.TipoTaForm(data={'sigla': 'si',
+                                  'descricao': 'teste',
+                                  'content_type': content_type[0],
+                                  'participacao_social': True,
+                                  'publicacao_func': True,
+                                  'perfis': [perfil.pk, ]
+                                  })
+
+    assert form.is_valid(), form.errors
+
+
+def test_valida_campos_obrigatorios_nota_form():
+    form = forms.NotaForm(data={})
+
+    assert not form.is_valid()
+
+    errors = form.errors
+
+    assert errors['texto'] == [_('Este campo é obrigatório')]
+    assert errors['publicidade'] == [_('Este campo é obrigatório.')]
+    assert errors['tipo'] == [_('Este campo é obrigatório.')]
+    assert errors['publicacao'] == [_('Este campo é obrigatório')]
+    assert errors['efetividade'] == [_('Este campo é obrigatório')]
+    assert errors['dispositivo'] == [_('Este campo é obrigatório.')]
+
+    assert len(errors) == 6
+
+
+@pytest.mark.django_db(transaction=False)
+def test_nota_form_invalido():
+    tipo = mommy.make(TipoNota)
+
+    form = forms.NotaForm(data={'titulo': 'titulo',
+                                'texto': 'teste',
+                                'url_externa': 'www.test.com',
+                                'publicidade': 'publicidade',
+                                'tipo': str(tipo.pk),
+                                'publicacao': '10/05/2017',
+                                'efetividade': '10/05/2017',
+                                'dispositivo': 'dispositivo',
+                                'pk': 'pk'
+                                })
+
+    assert not form.is_valid()

sapl/compilacao/views.py

@@ -142,7 +142,6 @@ class IntegracaoTaView(TemplateView):
                 implemente, ou passe `None` para as chaves que são fixas.
             """)
 
-        map_fields = self.map_fields
         ta_values = getattr(self, 'ta_values', {})
 
         item = get_object_or_404(self.model, pk=kwargs['pk'])
@@ -287,6 +286,203 @@ class CompMixin(PermissionRequiredMixin):
             context['NO_ENTRIES_MSG'] = CrudListView.no_entries_msg
         return context
 
+    def get_notificacoes(self, object_list=None, type_notificacoes=None):
+
+        p = []
+
+        def padd(r, type_notificacao, reverse_url=None, test=True, msg='',
+                 kwargs=None, to_position=None):
+
+            if not test:
+                return
+
+            r.contextual_class = type_notificacao
+            if not kwargs:
+                kwargs = {'ta_id': r.ta_id, 'pk': r.pk}
+            if reverse_url:
+                p.append((type_notificacao, msg,
+                          reverse_lazy(reverse_url, kwargs=kwargs),
+                          to_position))
+            else:
+                p.append((type_notificacao, msg, None, to_position))
+
+        def success(r):
+            type_notificacao = 'success'
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_vigencia',
+                 r.inconstitucionalidade,
+                 _('Declarado Inconstitucional.'))
+
+            padd(r, type_notificacao, 'sapl.compilacao:ta_text_edit',
+                 r.ta_publicado and r.dispositivo_atualizador,
+                 _('Dispositivo alterado em %s' % r.ta_publicado),
+                 {'ta_id': r.ta_publicado_id}, r.dispositivo_atualizador_id)
+
+        def info(r):
+            type_notificacao = 'info'
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_vigencia',
+                 r.publicacao and
+                 r.dispositivo_vigencia and
+                 r.publicacao.data != r.dispositivo_vigencia.inicio_vigencia,
+                 _('Data da publicação associada ao Dispositivo difere da data'
+                   ' de inicio de vigência do Dispositivo de vigência.'))
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_vigencia',
+                 r.publicacao and r.publicacao.data != r.inicio_vigencia,
+                 _('Data da publicação associada ao Dispositivo difere '
+                   'da data de inicio de vigência.'))
+
+            padd(r, type_notificacao, 'sapl.compilacao:dispositivo_edit',
+                 r.rotulo != r.rotulo_padrao(local_insert=1),
+                 _('Rótulo Diferente do Padrão'))
+
+            padd(r, type_notificacao, 'sapl.compilacao:dispositivo_edit',
+                 r.texto_atualizador and r.texto_atualizador != r.texto,
+                 _('Texto do Dispositivo para o Documento '
+                   'está diferente do texto para o Documento Alterador.'))
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_alteracao',
+                 r.texto_atualizador and r.texto_atualizador == r.texto,
+                 _('Texto do Dispositivo no Documento Alterador '
+                   'está igual ao Texto no Documento Original. '
+                   'Não é necessário manter armazenado o texto no Documento '
+                   'Alterador.'))
+
+        def warning(r):
+            type_notificacao = 'warning'
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_vigencia',
+                 r.dispositivo_vigencia and r.inicio_vigencia !=
+                 r.dispositivo_vigencia.inicio_vigencia,
+                 _('Data de início de Vigência difere da data início de '
+                   'Vigência do Dispositivo de Vigência'))
+
+            padd(r, type_notificacao, 'sapl.compilacao:ta_text',
+                 r.inconstitucionalidade and not r.notas.exists(),
+                 _('Dispositivo está definido como inconstitucional. É '
+                   'aconcelhavel inserir uma Nota informando esta condição.'),
+                 kwargs={'ta_id': r.ta_id},
+                 to_position=r.pk)
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_vigencia',
+                 r.inconstitucionalidade and not (
+                     r.inicio_vigencia == r.fim_vigencia and
+                     r.fim_vigencia == r.inicio_eficacia and
+                     r.inicio_eficacia == r.fim_eficacia),
+                 _('Dispositivo está definido como inconstitucional porém '
+                   'existe diferença entre as datas início e fim de '
+                   'vigência e eficácia.'))
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_vigencia',
+                 r.publicacao and
+                 r.ta_publicado and r.ta_publicado != r.publicacao.ta,
+                 _('A Publicação associada a este Dispositivo não é '
+                   'uma publicação do Texto Articulado Alterador.'))
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_vigencia',
+                 not r.publicacao,
+                 _('Dispositivo sem registro de publicação.'))
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_vigencia',
+                 r.texto and r.tipo_dispositivo.dispositivo_de_articulacao,
+                 _('Dispositivos de Articulação não '
+                   'deveriam armazenar texto.'))
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_vigencia',
+                 not r.texto and
+                 not r.tipo_dispositivo.dispositivo_de_articulacao,
+                 _('Dispositivo está sem texto.'))
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_alteracao',
+                 r.texto_atualizador and not r.ta_publicado,
+                 _('Existe Texto Atualizador, porém este Dispositivo não '
+                   'está associado a nenhum Documento Atualizador.'))
+
+        def danger(r):
+            type_notificacao = 'danger'
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_vigencia',
+                 not r.dispositivo_vigencia,
+                 _('Dispositivo sem definição de Dispositivo de Vigência.'))
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_vigencia',
+                 r.inconstitucionalidade and
+                 r.inicio_vigencia != r.fim_vigencia,
+                 _('Dispositivo está definido como inconstitucional porém '
+                   'existe período de vigência.'))
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_alteracao',
+                 r.ta_publicado and not r.dispositivo_atualizador,
+                 _('Dispositivo está associado a um Texto Articulado '
+                   'Atualizador mas, a nenhum Dispositivo Atualizador.'))
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_alteracao',
+                 not r.dispositivo_atualizador and
+                 r.dispositivo_substituido,
+                 _('Dispositivo está substituindo outro mas não foi informado '
+                   'o Dispositivo Atualizador.'))
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_alteracao',
+                 r.dispositivo_substituido and
+                 r.dispositivo_substituido.tipo_dispositivo !=
+                 r.tipo_dispositivo,
+                 _('Dispositivo está substituindo um Dispositivo '
+                   'de outro tipo.'))
+
+            padd(r, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_alteracao',
+                 r.dispositivo_substituido and
+                 r.dispositivo_substituido.ta != r.ta,
+                 _('Dispositivo está substituindo um Dispositivo de outro '
+                   'Texto Articulado.'))
+
+            padd(r.dispositivo_substituido, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_alteracao',
+                 r.dispositivo_substituido and
+                 r.dispositivo_substituido.dispositivo_subsequente != r,
+                 _('Dispositivo está substituindo um Dispositivo que não '
+                   'possui este como seu Dispositivo Subsequente.'))
+
+            padd(r.dispositivo_subsequente, type_notificacao,
+                 'sapl.compilacao:dispositivo_edit_alteracao',
+                 r.dispositivo_subsequente and
+                 r.dispositivo_subsequente.dispositivo_substituido != r,
+                 _('Dispositivo foi substituído por outro que não '
+                   'possui este como seu Dispositivo Substituído.'))
+
+        rr = []
+        for r in object_list:
+            p = []
+            r.contextual_class = ""
+
+            for f in type_notificacoes:
+                if f != 'default':
+                    locals()[f](r)
+
+            r.notificacoes = p
+
+            if p or 'default' in type_notificacoes:
+                rr.append(r)
+
+            if r.dispositivos_alterados_set.exists():
+                rr += self.get_notificacoes(
+                    r.dispositivos_alterados_set.all(), type_notificacoes)
+
+        return rr
+
 
 class TipoTaListView(CompMixin, ListView):
     model = TipoTextoArticulado
@@ -964,6 +1160,23 @@ class TextEditView(CompMixin, TemplateView):
         else:
             if 'lock' in request.GET:
                 # TODO - implementar logging de ação de usuário
+
+                notificacoes = self.get_notificacoes(
+                    object_list=self.object.dispositivos_set.all(),
+                    type_notificacoes=['danger', ])
+
+                if notificacoes:
+                    messages.error(
+                        request,
+                        _('Existem erros a serem corrigidos que impedem a '
+                          'publicação deste Texto Articulado. '
+                          'Corrija os erros apontados nas notificações.'))
+                    self.request.session[
+                        'type_notificacoes'] = ['danger', ]
+                    return redirect(to=reverse_lazy(
+                        'sapl.compilacao:ta_text_notificacoes', kwargs={
+                            'ta_id': self.object.id}))
+
                 self.object.editing_locked = True
                 self.object.privacidade = STATUS_TA_PUBLIC
                 self.object.save()
@@ -1564,9 +1777,7 @@ class ActionDeleteDispositivoMixin(ActionsCommonsMixin):
                         ordem__gt=base_ordem,
                         nivel__lte=base.nivel).first()
 
-                if not pbi:
-                    base.delete()
-                else:
+                if pbi:
                     dcc_a_excluir = Dispositivo.objects.order_by(
                         'ordem').filter(
                         ta_id=base.ta_id,
@@ -1605,8 +1816,14 @@ class ActionDeleteDispositivoMixin(ActionsCommonsMixin):
                                 dr.dispositivo0 -
                                 primeiro_a_religar + d.dispositivo0)
                             dr.rotulo = dr.rotulo_padrao()
-
                             dr.save(clean=base != dr)
+
+                if base.tipo_dispositivo.dispositivo_de_alteracao:
+                    dpts = base.dispositivos_alterados_set.all().order_by(
+                        '-ordem_bloco_atualizador')
+                    for dpt in dpts:
+                        self.remover_dispositivo(dpt, False)
+
                 if base.pk:
                     base.delete()
 
@@ -1882,22 +2099,25 @@ class ActionDispositivoCreateMixin(ActionsCommonsMixin):
 
         try:
             Dispositivo.objects.filter(
-                (Q(ta=dvt.ta) & Q(ta_publicado__isnull=True)) |
-                Q(ta_publicado=dvt.ta)
+                ta=dvt.ta, ta_publicado__isnull=True
             ).update(
                 dispositivo_vigencia=dvt,
                 inicio_vigencia=dvt.inicio_vigencia,
                 inicio_eficacia=dvt.inicio_eficacia)
 
-            dps = Dispositivo.objects.filter(dispositivo_vigencia_id=dvt.pk,
-                                             ta_publicado_id=dvt.ta_id)
-            with transaction.atomic():
+            Dispositivo.objects.filter(ta_publicado=dvt.ta
+                                       ).update(
+                dispositivo_vigencia=dvt,
+                inicio_vigencia=dvt.inicio_eficacia,
+                inicio_eficacia=dvt.inicio_eficacia)
+
+            dps = Dispositivo.objects.filter(dispositivo_vigencia=dvt)
             for d in dps:
                 if d.dispositivo_substituido:
                     ds = d.dispositivo_substituido
                     ds.fim_vigencia = d.inicio_vigencia - timedelta(days=1)
                     ds.fim_eficacia = d.inicio_eficacia - timedelta(days=1)
-                        d.save()
+                    ds.save()
 
                 if d.dispositivo_subsequente:
                     ds = d.dispositivo_subsequente
@@ -2302,7 +2522,7 @@ class ActionsEditMixin(ActionDragAndMoveDispositivoAlteradoMixin,
             dispositivos_do_bloco = \
                 bloco_alteracao.dispositivos_alterados_set.order_by(
                     'ordem_bloco_atualizador')
-            if dispositivos_do_bloco.exists:
+            if dispositivos_do_bloco.exists():
                 ndp.ordem_bloco_atualizador = dispositivos_do_bloco.last(
                 ).ordem_bloco_atualizador + Dispositivo.INTERVALO_ORDEM
 
@@ -2376,13 +2596,21 @@ class ActionsEditMixin(ActionDragAndMoveDispositivoAlteradoMixin,
                   'Alterador!'), time=10000)
             return data
 
+        if dispositivo_a_alterar.tipo_dispositivo.dispositivo_de_articulacao\
+                and not revogacao:
+            self.set_message(
+                data, 'warning',
+                _('Registrar alteração de um dispositivo de articulação '
+                      'só é relevante para o caso de alterações de rótulo. '
+                      'Se não é este o caso, a alteração deve ser específica '
+                      'para o dispositivo que se quer alterar.'), modal=True)
+
         ndp = Dispositivo.new_instance_based_on(
             dispositivo_a_alterar, dispositivo_a_alterar.tipo_dispositivo)
-
         ndp.auto_inserido = dispositivo_a_alterar.auto_inserido
-
         ndp.rotulo = dispositivo_a_alterar.rotulo
         ndp.publicacao = bloco_alteracao.publicacao
+
         if not revogacao:
             ndp.texto = dispositivo_a_alterar.texto
         else:
@@ -2390,12 +2618,13 @@ class ActionsEditMixin(ActionDragAndMoveDispositivoAlteradoMixin,
             ndp.dispositivo_de_revogacao = True
 
         ndp.dispositivo_vigencia = bloco_alteracao.dispositivo_vigencia
+
         if ndp.dispositivo_vigencia:
             ndp.inicio_eficacia = ndp.dispositivo_vigencia.inicio_eficacia
-            ndp.inicio_vigencia = ndp.dispositivo_vigencia.inicio_vigencia
+            ndp.inicio_vigencia = ndp.dispositivo_vigencia.inicio_eficacia
         else:
             ndp.inicio_eficacia = bloco_alteracao.inicio_eficacia
-            ndp.inicio_vigencia = bloco_alteracao.inicio_vigencia
+            ndp.inicio_vigencia = bloco_alteracao.inicio_eficacia
 
         try:
             ordem = dispositivo_a_alterar.criar_espaco(
@@ -2421,6 +2650,7 @@ class ActionsEditMixin(ActionDragAndMoveDispositivoAlteradoMixin,
             dispositivos_do_bloco = \
                 bloco_alteracao.dispositivos_alterados_set.order_by(
                     'ordem_bloco_atualizador')
+
             if dispositivos_do_bloco.exists():
                 ndp.ordem_bloco_atualizador = dispositivos_do_bloco.last(
                 ).ordem_bloco_atualizador + Dispositivo.INTERVALO_ORDEM
@@ -2449,6 +2679,7 @@ class ActionsEditMixin(ActionDragAndMoveDispositivoAlteradoMixin,
             bloco_alteracao.ordenar_bloco_alteracao()
 
             if not revogacao:
+                if 'message' not in data:
                     self.set_message(
                         data, 'success',
                         _('Dispositivo de Alteração adicionado com sucesso.'))
@@ -3038,10 +3269,14 @@ class TextNotificacoesView(CompMixin, ListView, FormView):
         self.object = TextoArticulado.objects.get(pk=self.kwargs['ta_id'])
         return super(TextNotificacoesView, self).get(request, *args, **kwargs)
 
+    def post(self, request, *args, **kwargs):
+        self.object = TextoArticulado.objects.get(pk=self.kwargs['ta_id'])
+        return FormView.post(self, request, *args, **kwargs)
+
     def get_context_data(self, **kwargs):
         if 'object' not in kwargs:
             kwargs['object'] = self.object
-        return super(TextNotificacoesView, self).get_context_data(**kwargs)
+        return ListView.get_context_data(self, **kwargs)
 
     def get_success_url(self):
         return reverse_lazy('sapl.compilacao:ta_text_notificacoes',
@@ -3071,199 +3306,11 @@ class TextNotificacoesView(CompMixin, ListView, FormView):
             ta_id=self.kwargs['ta_id']
         ).select_related(*DISPOSITIVO_SELECT_RELATED)
 
-        p = []
-
-        def padd(r, type_notificacao, reverse_url=None, test=True, msg='',
-                 kwargs=None, to_position=None):
-
-            if not test:
-                return
-
-            r.contextual_class = type_notificacao
-            if not kwargs:
-                kwargs = {'ta_id': r.ta_id, 'pk': r.pk}
-            if reverse_url:
-                p.append((type_notificacao, msg,
-                          reverse_lazy(reverse_url, kwargs=kwargs),
-                          to_position))
-            else:
-                p.append((type_notificacao, msg, None, to_position))
-
-        def success(r):
-            type_notificacao = 'success'
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_vigencia',
-                 r.inconstitucionalidade,
-                 _('Declarado Inconstitucional.'))
-
-            padd(r, type_notificacao, 'sapl.compilacao:ta_text_edit',
-                 r.ta_publicado and r.dispositivo_atualizador,
-                 _('Dispositivo alterado em %s' % r.ta_publicado),
-                 {'ta_id': r.ta_publicado_id}, r.dispositivo_atualizador_id)
-
-        def info(r):
-            type_notificacao = 'info'
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_vigencia',
-                 r.publicacao and
-                 r.dispositivo_vigencia and
-                 r.publicacao.data != r.dispositivo_vigencia.inicio_vigencia,
-                 _('Data da publicação associada ao Dispositivo difere da data'
-                   ' de inicio de vigência do Dispositivo de vigência.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_vigencia',
-                 r.publicacao and r.publicacao.data != r.inicio_vigencia,
-                 _('Data da publicação associada ao Dispositivo difere '
-                   'da data de inicio de vigência.'))
-
-            padd(r, type_notificacao, 'sapl.compilacao:dispositivo_edit',
-                 r.rotulo != r.rotulo_padrao(local_insert=1),
-                 _('Rótulo Diferente do Padrão'))
-
-            padd(r, type_notificacao, 'sapl.compilacao:dispositivo_edit',
-                 r.texto_atualizador and r.texto_atualizador != r.texto,
-                 _('Texto do Dispositivo para o Documento '
-                   'está diferente do texto para o Documento Alterador.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_alteracao',
-                 r.texto_atualizador and r.texto_atualizador == r.texto,
-                 _('Texto do Dispositivo no Documento Alterador '
-                   'está igual ao Texto no Documento Original. '
-                   'Não é necessário manter armazenado o texto no Documento '
-                   'Alterador.'))
-
-        def warning(r):
-            type_notificacao = 'warning'
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_vigencia',
-                 r.dispositivo_vigencia and r.inicio_vigencia !=
-                 r.dispositivo_vigencia.inicio_vigencia,
-                 _('Data de início de Vigência difere da data início de '
-                   'Vigência do Dispositivo de Vigência'))
-
-            padd(r, type_notificacao, 'sapl.compilacao:ta_text',
-                 r.inconstitucionalidade and not r.notas.exists(),
-                 _('Dispositivo está definido como inconstitucional. É '
-                   'aconcelhavel inserir uma Nota informando esta condição.'),
-                 kwargs={'ta_id': r.ta_id},
-                 to_position=r.pk)
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_vigencia',
-                 r.inconstitucionalidade and not (
-                     r.inicio_vigencia == r.fim_vigencia and
-                     r.fim_vigencia == r.inicio_eficacia and
-                     r.inicio_eficacia == r.fim_eficacia),
-                 _('Dispositivo está definido como inconstitucional porém '
-                   'existe diferença entre as datas início e fim de '
-                   'vigência e eficácia.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_vigencia',
-                 r.publicacao and
-                 r.ta_publicado and r.ta_publicado != r.publicacao.ta,
-                 _('A Publicação associada a este Dispositivo não é '
-                   'uma publicação do Texto Articulado Alterador.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_vigencia',
-                 not r.publicacao,
-                 _('Dispositivo sem registro de publicação.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_vigencia',
-                 r.texto and r.tipo_dispositivo.dispositivo_de_articulacao,
-                 _('Dispositivos de Articulação não '
-                   'deveriam armazenar texto.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_vigencia',
-                 not r.texto and
-                 not r.tipo_dispositivo.dispositivo_de_articulacao,
-                 _('Dispositivo está sem texto.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_alteracao',
-                 r.texto_atualizador and not r.ta_publicado,
-                 _('Existe Texto Atualizador, porém este Dispositivo não '
-                   'está associado a nenhum Documento Atualizador.'))
-
-        def danger(r):
-            type_notificacao = 'danger'
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_vigencia',
-                 not r.dispositivo_vigencia,
-                 _('Dispositivo sem definição de Dispositivo de Vigência.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_vigencia',
-                 r.inconstitucionalidade and
-                 r.inicio_vigencia != r.fim_vigencia,
-                 _('Dispositivo está definido como inconstitucional porém '
-                   'existe período de vigência.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_alteracao',
-                 r.ta_publicado and not r.dispositivo_atualizador,
-                 _('Dispositivo está associado a um Texto Articulado '
-                   'Atualizador mas, a nenhum Dispositivo Atualizador.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_alteracao',
-                 not r.dispositivo_atualizador and
-                 r.dispositivo_substituido,
-                 _('Dispositivo está substituindo outro mas não foi informado '
-                   'o Dispositivo Atualizador.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_alteracao',
-                 r.dispositivo_substituido and
-                 r.dispositivo_substituido.tipo_dispositivo !=
-                 r.tipo_dispositivo,
-                 _('Dispositivo está substituindo um Dispositivo '
-                   'de outro tipo.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_alteracao',
-                 r.dispositivo_substituido and
-                 r.dispositivo_substituido.ta != r.ta,
-                 _('Dispositivo está substituindo um Dispositivo de outro '
-                   'Texto Articulado.'))
-
-            padd(r, type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_alteracao',
-                 r.dispositivo_substituido and
-                 r.dispositivo_substituido.dispositivo_subsequente != r,
-                 _('Dispositivo está substituindo um Dispositivo que não '
-                   'possui este como seu Dispositivo Subsequente.'))
-
-            padd(r,
-                 type_notificacao,
-                 'sapl.compilacao:dispositivo_edit_alteracao',
-                 r.dispositivo_subsequente and
-                 r.dispositivo_subsequente.dispositivo_substituido != r,
-                 _('Dispositivo foi substituído por outro que não '
-                   'possui este como seu Dispositivo Substituído.'))
-
-        rr = []
-        for r in result:
-            p = []
-            r.contextual_class = ""
-
         type_notificacoes = []
         if 'type_notificacoes' in self.request.session:
             type_notificacoes = self.request.session['type_notificacoes']
 
-            if isinstance(type_notificacoes, list):
-                for f in type_notificacoes:
-                    if f != 'default':
-                        locals()[f](r)
-
-            r.notificacoes = p
-
-            if p or 'default' in type_notificacoes:
-                rr.append(r)
+        if type_notificacoes and not isinstance(type_notificacoes, list):
+            type_notificacoes = [type_notificacoes, ]
 
-        return rr
+        return self.get_notificacoes(result, type_notificacoes)

sapl/crispy_layout_mixin.py

@@ -1,5 +1,6 @@
 from math import ceil
 
+import rtyaml
 from crispy_forms.bootstrap import FormActions
 from crispy_forms.helper import FormHelper
 from crispy_forms.layout import HTML, Div, Fieldset, Layout, Submit
@@ -7,7 +8,6 @@ from django import template
 from django.core.urlresolvers import reverse
 from django.utils import formats
 from django.utils.translation import ugettext as _
-import rtyaml
 
 
 def heads_and_tails(list_of_lists):

sapl/crud/base.py

@@ -955,6 +955,7 @@ class CrudAux(Crud):
             Se o valor de subnav_template_name é nulo faz o filter subnav
             não abrir o padrão e nem um outro arquivo.
             """
+            if 'subnav_template_name' not in context:
                 context['subnav_template_name'] = self.subnav_template_name
             return context
 

sapl/decorators.py

@@ -0,0 +1,43 @@
+from datetime import date
+from functools import wraps
+
+from django.utils.translation import ugettext_lazy as _
+
+
+def vigencia_atual(decorated_method):
+    """
+    concatena a string ' (Atual)' caso a model instancia estiver
+    em vigência na data atual do servidor
+
+    Premissas:
+        * A classe precisa conter os atributos 'data_inicio' e 'data_fim'.
+        * 'data_inicio' e 'data_fim' precisam ser do tipo models.DateField
+    """
+    @wraps(decorated_method)
+    def display_atual(self):
+        string_displayed = decorated_method(self)
+
+        if hasattr(self, 'data_inicio') and hasattr(self, 'data_fim'):
+            today = date.today()
+            e_atual = self.data_inicio <= today <= self.data_fim
+            string_displayed = "{} {}".format(
+                string_displayed, "(Atual)" if e_atual else "")
+        else:
+            instancia_sem_atributo = "{} [{}, {}].".format(
+                'Instância não possui os atributos',
+                'data_inicio',
+                'data_fim')
+
+            mensagem_decorator = "Decorator @{} foi desabilitado.".format(
+                vigencia_atual.__name__()
+            )
+            print(_('{} {}'.format(
+                _(instancia_sem_atributo),
+                _(mensagem_decorator)
+            )
+            )
+            )
+
+        return string_displayed
+
+    return display_atual

sapl/legacy/migracao_documentos.py

@@ -3,7 +3,6 @@ import os
 import re
 
 import magic
-from django.db.models.signals import post_delete, post_save
 
 from sapl.base.models import CasaLegislativa
 from sapl.materia.models import (DocumentoAcessorio, MateriaLegislativa,
@@ -86,7 +85,8 @@ DOCS = {
     DocumentoAcessorioAdministrativo: [(
         'arquivo',
         'administrativo/{}',
-        'private/documentoacessorioadministrativo/{0}/{0}_acessorio_administrativo{1}')
+        'private/documentoacessorioadministrativo/{0}/'
+        '{0}_acessorio_administrativo{1}')
     ],
 }
 

sapl/legacy/scripts/street_sweeper.py

@@ -12,7 +12,8 @@ DB = ''
 
 SELECT_EXCLUIDOS = "SELECT %s FROM %s WHERE ind_excluido = 1 ORDER BY %s"
 
-REGISTROS_INCONSISTENTES = "DELETE FROM %s WHERE %s in (%s) AND ind_excluido = 0 "
+REGISTROS_INCONSISTENTES = "DELETE FROM %s WHERE %s "
+"in (%s) AND ind_excluido = 0 "
 
 EXCLUI_REGISTRO = "DELETE FROM %s WHERE ind_excluido=1"
 
@@ -43,6 +44,7 @@ mapa['parlamentar'] = ['autor', 'autoria', 'composicao_comissao',
                        'sessao_plenaria_presenca', 'unidade_tramitacao']
 """
 
+
 def get_ids_excluidos(cursor, query):
     """
         recupera as PKs de registros com ind_excluido = 1 da tabela principal
@@ -58,7 +60,8 @@ def remove_tabelas(cursor, tabela_principal, pk, query_dependentes=None):
 
     QUERY = SELECT_EXCLUIDOS % (pk, tabela_principal, pk)
     ids_excluidos = get_ids_excluidos(cursor, QUERY)
-    print("\nRegistros da tabela '%s' com ind_excluido = 1: %s" % (tabela_principal.upper(), len(ids_excluidos)))
+    print("\nRegistros da tabela '%s' com ind_excluido = 1: %s" %
+          (tabela_principal.upper(), len(ids_excluidos)))
 
     """
         Remove registros de tabelas que dependem da tabela principal,
@@ -69,7 +72,8 @@ def remove_tabelas(cursor, tabela_principal, pk, query_dependentes=None):
         print("Dependencias inconsistentes")
         for tabela in mapa[tabela_principal]:
 
-            QUERY_DEP = REGISTROS_INCONSISTENTES %  (tabela, pk, ','.join(ids_excluidos))
+            QUERY_DEP = REGISTROS_INCONSISTENTES % (
+                tabela, pk, ','.join(ids_excluidos))
 
             # Trata caso especifico de norma_juridica
             if query_dependentes:

sapl/materia/admin.py

@@ -11,6 +11,7 @@ if not DEBUG:
     admin.site.unregister(Proposicao)
 
     class ProposicaoAdmin(admin.ModelAdmin):
+
         def has_add_permission(self, request, obj=None):
             return False
 

sapl/materia/apps.py

@@ -6,6 +6,3 @@ class AppConfig(apps.AppConfig):
     name = 'sapl.materia'
     label = 'materia'
     verbose_name = _('Matéria')
-
-    def ready(self):
-        from . import signals

sapl/materia/email_utils.py

@@ -206,6 +206,7 @@ def do_envia_email_tramitacao(base_url, materia, status, unidade_destino):
         # a conexão será fechada
         except Exception:
             connection.close()
-            raise Exception('Erro ao enviar e-mail de acompanhamento de matéria.')
+            raise Exception(
+                'Erro ao enviar e-mail de acompanhamento de matéria.')
 
     connection.close()

sapl/materia/fixtures/pre_popula_status_tramitacao.json

@@ -0,0 +1,361 @@
+[{
+    "model": "materia.StatusTramitacao",
+    "pk": 1,
+    "fields": {
+      "sigla": "ADIAVOTAC",
+      "indicador": "R",
+      "descricao": "Adiada discussão e votação."
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 2,
+    "fields": {
+      "sigla": "AGAUTOGR",
+      "indicador": "R",
+      "descricao": "Aguardando assinatura do autógrafo"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 3,
+    "fields": {
+      "sigla": "AGMENSVET",
+      "indicador": "R",
+      "descricao": "Aguardando assinatura da mensagem sobre o veto"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 4,
+    "fields": {
+      "sigla": "AGORDIA",
+      "indicador": "R",
+      "descricao": "Aguardando a inclusão na ordem do dia"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 5,
+    "fields": {
+      "sigla": "AGPARECER",
+      "indicador": "R",
+      "descricao": "Aguardando emissão de parecer da comissão"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 6,
+    "fields": {
+      "sigla": "AGPROMLEI",
+      "indicador": "F",
+      "descricao": "Aguardando promulgação da lei"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 7,
+    "fields": {
+      "sigla": "AGPROMNOR",
+      "indicador": "F",
+      "descricao": "Aguardando promulgação da norma jurídica"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 8,
+    "fields": {
+      "sigla": "AGPROMVET",
+      "indicador": "R",
+      "descricao": "Aguardando promulgação de lei com veto rejeitado"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 9,
+    "fields": {
+      "sigla": "AGSANCAO",
+      "indicador": "F",
+      "descricao": "Aguardando sanção governamental"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 10,
+    "fields": {
+      "sigla": "ANEXADA",
+      "indicador": "R",
+      "descricao": "Proposição anexada à outra análoga ou conexa mais antiga"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 11,
+    "fields": {
+      "sigla": "APRESENT",
+      "indicador": "R",
+      "descricao": "Proposição apresentada em Plenário"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 12,
+    "fields": {
+      "sigla": "APROV1TUR",
+      "indicador": "R",
+      "descricao": "Proposição aprovada em 1º turno"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 13,
+    "fields": {
+      "sigla": "APROVADA",
+      "indicador": "F",
+      "descricao": "Proposição aprovada"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 14,
+    "fields": {
+      "sigla": "ARQUIVADA",
+      "indicador": "F",
+      "descricao": "Proposição arquivada"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 15,
+    "fields": {
+      "sigla": "AUTUAPAUTA",
+      "indicador": "R",
+      "descricao": "Proposição autuada e cumprindo prazo de pauta"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 16,
+    "fields": {
+      "sigla": "DESARQUIV",
+      "indicador": "R",
+      "descricao": "Proposição desarquivada pelo Autor"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 17,
+    "fields": {
+      "sigla": "DISTRCOMIS",
+      "indicador": "R",
+      "descricao": "Proposição distribuída às comissões"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 18,
+    "fields": {
+      "sigla": "INCLORDIA",
+      "indicador": "R",
+      "descricao": "Proposição inclusa na Ordem do Dia"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 19,
+    "fields": {
+      "sigla": "LEIPROMUL",
+      "indicador": "F",
+      "descricao": "Proposição transformada em lei por promulgação"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 20,
+    "fields": {
+      "sigla": "LEIVETPAR",
+      "indicador": "R",
+      "descricao": "Transformada em lei com veto parcial"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 21,
+    "fields": {
+      "sigla": "MANUTVETO",
+      "indicador": "R",
+      "descricao": "Parecer pela manutenção do veto"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 22,
+    "fields": {
+      "sigla": "NORMPROMUL",
+      "indicador": "F",
+      "descricao": "Norma promulgada"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 23,
+    "fields": {
+      "sigla": "PARECCONTR",
+      "indicador": "R",
+      "descricao": "Parecer contrário da comissão de mérito"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 24,
+    "fields": {
+      "sigla": "PARECERFAV",
+      "indicador": "R",
+      "descricao": "Parecer favorável da comissão"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 25,
+    "fields": {
+      "sigla": "PARECPLEN",
+      "indicador": "F",
+      "descricao": "Parecer em Plenário pelas comissões pertinentes"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 26,
+    "fields": {
+      "sigla": "PAREUCONJ",
+      "indicador": "R",
+      "descricao": "Parecer em reunião conjunta das Comissões pertinentes"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 27,
+    "fields": {
+      "sigla": "PREJUD",
+      "indicador": "F",
+      "descricao": "Proposição prejudicada"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 28,
+    "fields": {
+      "sigla": "PROMULVETO",
+      "indicador": "F",
+      "descricao": "Veto total ou parcial promulgado"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 29,
+    "fields": {
+      "sigla": "REJEITADA",
+      "indicador": "F",
+      "descricao": "Proposição rejeitada pelo Plenário"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 30,
+    "fields": {
+      "sigla": "REJEIVETO",
+      "indicador": "R",
+      "descricao": "Parecer pela rejeição do veto"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 31,
+    "fields": {
+      "sigla": "RETAUTOR",
+      "indicador": "F",
+      "descricao": "Proposição retirada pelo autor"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 32,
+    "fields": {
+      "sigla": "RETORDIA",
+      "indicador": "R",
+      "descricao": "Proposição retirada da Ordem do Dia"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 33,
+    "fields": {
+      "sigla": "TRANSFLEI",
+      "indicador": "F",
+      "descricao": "Proposição transformada em lei"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 34,
+    "fields": {
+      "sigla": "VETODISTR",
+      "indicador": "R",
+      "descricao": "Veto distribuído para emissão de parecer"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 35,
+    "fields": {
+      "sigla": "VETOLIDO",
+      "indicador": "R",
+      "descricao": "Veto sobre a proposição lido em sessão plenária"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 36,
+    "fields": {
+      "sigla": "VETOMANT",
+      "indicador": "F",
+      "descricao": "Veto sobre a proposição mantido"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 37,
+    "fields": {
+      "sigla": "VETOORDIA",
+      "indicador": "F",
+      "descricao": "Veto incluso na ordem do dia"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 38,
+    "fields": {
+      "sigla": "VETOPAUTA",
+      "indicador": "F",
+      "descricao": "Veto autuado e incluso em pauta"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 39,
+    "fields": {
+      "sigla": "VETOREJEI",
+      "indicador": "F",
+      "descricao": "Veto sobre a proposição rejeitado"
+    }
+  },
+  {
+    "model": "materia.StatusTramitacao",
+    "pk": 40,
+    "fields": {
+      "sigla": "VETOTOTAL",
+      "indicador": "R",
+      "descricao": "Proposição com veto tota"
+    }
+  }
+]

sapl/materia/forms.py

@@ -1,7 +1,8 @@
 
-from datetime import date, datetime
 import os
+from datetime import date, datetime
 
+import django_filters
 from crispy_forms.bootstrap import Alert, FormActions, InlineRadios
 from crispy_forms.helper import FormHelper
 from crispy_forms.layout import (HTML, Button, Column, Div, Field, Fieldset,
@@ -13,18 +14,16 @@ from django.core.files.base import File
 from django.core.urlresolvers import reverse
 from django.db import models, transaction
 from django.db.models import Max
-from django.forms import ModelForm, ModelChoiceField, widgets
+from django.forms import ModelChoiceField, ModelForm, widgets
 from django.forms.forms import Form
 from django.forms.models import ModelMultipleChoiceField
-from django.forms.widgets import Select, CheckboxSelectMultiple, HiddenInput
-from django.utils import six
+from django.forms.widgets import CheckboxSelectMultiple, HiddenInput, Select
 from django.utils.encoding import force_text
 from django.utils.html import format_html
 from django.utils.safestring import mark_safe
 from django.utils.translation import ugettext_lazy as _
-from django_filters.filterset import STRICTNESS
-import django_filters
 
+import sapl
 from sapl.base.models import Autor, TipoAutor
 from sapl.comissoes.models import Comissao
 from sapl.compilacao.models import (STATUS_TA_IMMUTABLE_PUBLIC,
@@ -41,8 +40,8 @@ from sapl.settings import MAX_DOC_UPLOAD_SIZE
 from sapl.utils import (RANGE_ANOS, YES_NO_CHOICES,
                         ChoiceWithoutValidationField,
                         MateriaPesquisaOrderingFilter, RangeWidgetOverride,
-                        autor_label, autor_modal, models_with_gr_for_model)
-import sapl
+                        autor_label, autor_modal, models_with_gr_for_model,
+                        qs_override_django_filter)
 
 from .models import (AcompanhamentoMateria, Anexada, Autoria, DespachoInicial,
                      DocumentoAcessorio, Numeracao, Proposicao, Relatoria,
@@ -165,6 +164,7 @@ class AcompanhamentoMateriaForm(ModelForm):
 
 
 class DocumentoAcessorioForm(ModelForm):
+    data = forms.DateField(required=True)
 
     class Meta:
         model = DocumentoAcessorio
@@ -493,7 +493,8 @@ class MateriaLegislativaFilterSet(django_filters.FilterSet):
 
     autoria__autor = django_filters.CharFilter(widget=forms.HiddenInput())
 
-    autoria__primeiro_autor = django_filters.BooleanFilter(required=False,
+    autoria__primeiro_autor = django_filters.BooleanFilter(
+        required=False,
         label='Primeiro Autor',
         widget=forms.HiddenInput())
 
@@ -591,42 +592,7 @@ class MateriaLegislativaFilterSet(django_filters.FilterSet):
 
     @property
     def qs(self):
-        if not hasattr(self, '_qs'):
-            valid = self.is_bound and self.form.is_valid()
-
-            if self.is_bound and not valid:
-                if self.strict == STRICTNESS.RAISE_VALIDATION_ERROR:
-                    raise forms.ValidationError(self.form.errors)
-                elif bool(self.strict) == STRICTNESS.RETURN_NO_RESULTS:
-                    self._qs = self.queryset.none()
-                    return self._qs
-                    # else STRICTNESS.IGNORE...  ignoring
-
-            # start with all the results and filter from there
-            qs = self.queryset.all()
-            for name, filter_ in six.iteritems(self.filters):
-                value = None
-                if valid:
-                    value = self.form.cleaned_data[name]
-                else:
-                    raw_value = self.form[name].value()
-                    try:
-                        value = self.form.fields[name].clean(raw_value)
-                    except forms.ValidationError:
-                        if self.strict == STRICTNESS.RAISE_VALIDATION_ERROR:
-                            raise
-                        elif bool(self.strict) == STRICTNESS.RETURN_NO_RESULTS:
-                            self._qs = self.queryset.none()
-                            return self._qs
-                            # else STRICTNESS.IGNORE...  ignoring
-
-                if value is not None:  # valid & clean data
-                    qs = qs._next_is_sticky()
-                    qs = filter_.filter(qs, value)
-
-            self._qs = qs
-
-        return self._qs
+        return qs_override_django_filter(self)
 
 
 def pega_ultima_tramitacao():
@@ -1629,3 +1595,86 @@ class MateriaAssuntoForm(ModelForm):
         fields = ['materia', 'assunto']
 
         widgets = {'materia': forms.HiddenInput()}
+
+
+class EtiquetaPesquisaForm(forms.Form):
+    tipo_materia = forms.ModelChoiceField(
+        label=TipoMateriaLegislativa._meta.verbose_name,
+        queryset=TipoMateriaLegislativa.objects.all(),
+        required=False,
+        empty_label='Selecione')
+
+    data_inicial = forms.DateField(
+        label='Data Inicial',
+        required=False,
+        widget=forms.DateInput(format='%d/%m/%Y')
+    )
+
+    data_final = forms.DateField(
+        label='Data Final',
+        required=False,
+        widget=forms.DateInput(format='%d/%m/%Y')
+    )
+
+    processo_inicial = forms.IntegerField(
+        label='Processo Inicial',
+        required=False)
+
+    processo_final = forms.IntegerField(
+        label='Processo Final',
+        required=False)
+
+    def __init__(self, *args, **kwargs):
+        super(EtiquetaPesquisaForm, self).__init__(*args, **kwargs)
+
+        row1 = to_row(
+            [('tipo_materia', 6),
+             ('data_inicial', 3),
+             ('data_final', 3)])
+
+        row2 = to_row(
+            [('processo_inicial', 6),
+             ('processo_final', 6)])
+
+        self.helper = FormHelper()
+        self.helper.layout = Layout(
+            Fieldset(
+                ('Formulário de Etiqueta'),
+                row1, row2,
+                form_actions(save_label='Pesquisar')
+            )
+        )
+
+    def clean(self):
+        cleaned_data = self.cleaned_data
+
+        # Verifica se algum campo de data foi preenchido
+        if cleaned_data['data_inicial'] or cleaned_data['data_final']:
+            # Então verifica se o usuário preencheu o Incial e mas não
+            # preencheu o Final, ou vice-versa
+            if (not cleaned_data['data_inicial'] or
+                    not cleaned_data['data_final']):
+                raise ValidationError(_(
+                    'Caso pesquise por data, os campos de Data Incial e ' +
+                    'Data Final devem ser preenchidos obrigatoriamente'))
+            # Caso tenha preenchido, verifica se a data final é maior que
+            # a inicial
+            elif cleaned_data['data_final'] < cleaned_data['data_inicial']:
+                raise ValidationError(_(
+                    'A Data Final não pode ser menor que a Data Inicial'))
+
+        # O mesmo processo anterior é feito com o processo
+        if (cleaned_data['processo_inicial'] or
+                cleaned_data['processo_final']):
+            if (not cleaned_data['processo_inicial'] or
+                    not cleaned_data['processo_final']):
+                raise ValidationError(_(
+                    'Caso pesquise por número de processo, os campos de ' +
+                    'Processo Inicial e Processo Final ' +
+                    'devem ser preenchidos obrigatoriamente'))
+            elif (cleaned_data['processo_final'] <
+                  cleaned_data['processo_inicial']):
+                raise ValidationError(_(
+                    'O processo final não pode ser menor que o inicial'))
+
+        return cleaned_data

sapl/materia/migrations/0012_auto_20170829_1321.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.3 on 2017-08-29 13:21
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('materia', '0011_auto_20170808_1034'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='materialegislativa',
+            options={'permissions': (('can_access_impressos', 'Can access impressos'),), 'verbose_name': 'Matéria Legislativa', 'verbose_name_plural': 'Matérias Legislativas'},
+        ),
+    ]

sapl/materia/migrations/0013_adiciona_status_tramitacao.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+from django.db import migrations
+import json
+import os
+
+
+from django.core.management import call_command
+
+
+
+def gera_status_tramitacao(apps, schema_editor):
+    StatusTramitacao = apps.get_model("materia", "StatusTramitacao")
+    db_alias = schema_editor.connection.alias
+    status_tramitacoes = StatusTramitacao.objects.all().exists()
+
+    if status_tramitacoes:
+        # Caso haja algum StatusTramitacao cadastrado na base de dados,
+        # a migração não deve ser carregada para evitar duplicações de dados.
+        print("Carga de {} não efetuada. Já Existem {} cadastrados...".format(
+            StatusTramitacao._meta.verbose_name,
+            StatusTramitacao._meta.verbose_name_plural
+           )
+        )
+    else:
+        fixture_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../fixtures'))
+        # pega status_tramitacoes listados em fixtures/pre_popula_status_tramitacao.json
+        fixture_filename = 'pre_popula_status_tramitacao.json'
+        fixture_file = os.path.join(fixture_dir, fixture_filename)
+        call_command('loaddata', fixture_file)
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        # A dependencia real desse script é o arquivo 0001_initial.py, mas
+        # isso gera um erro (Conflicting migrations detected; multiple leaf
+         # nodes in the migration graph). para não ocasionar problemas de migração,
+         # vamos manter a ordem padrão do django.
+        ('materia', '0012_auto_20170829_1321'),
+    ]
+
+    operations = [
+        migrations.RunPython(gera_status_tramitacao),
+    ]

sapl/materia/migrations/0014_auto_20170905_0818.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.7 on 2017-09-05 08:18
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('materia', '0013_adiciona_status_tramitacao'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='unidadetramitacao',
+            options={'ordering': ['orgao', 'comissao', 'parlamentar'], 'verbose_name': 'Unidade de Tramitação', 'verbose_name_plural': 'Unidades de Tramitação'},
+        ),
+    ]

sapl/materia/migrations/0015_auto_20170908_1024.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.13 on 2017-09-08 10:24
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+from sapl.materia.models import TipoProposicao
+
+
+class AlterUniqueTogetherFixConstraintInexistente(
+        migrations.AlterUniqueTogether):
+
+    def database_forwards(self,
+                          app_label, schema_editor, from_state, to_state):
+        constraint_names = schema_editor._constraint_names(
+            TipoProposicao, ['content_type_id', 'object_id'], unique=True)
+        if constraint_names:
+            # por alguma razão a constraint não existe em alguns bancos
+            # se ela existir continua a exetução normal
+            super(AlterUniqueTogetherFixConstraintInexistente,
+                  self).database_forwards(
+                app_label, schema_editor, from_state, to_state
+            )
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('materia', '0014_auto_20170905_0818'),
+    ]
+
+    operations = [
+        AlterUniqueTogetherFixConstraintInexistente(
+            name='tipoproposicao',
+            unique_together=set([]),
+        ),
+    ]

sapl/materia/migrations/0016_merge.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.13 on 2017-09-08 11:57
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('materia', '0015_auto_20170908_1024'),
+        ('materia', '0013_auto_20170816_1136'),
+    ]
+
+    operations = [
+    ]

sapl/materia/models.py

@@ -66,7 +66,6 @@ class TipoProposicao(models.Model):
     class Meta:
         verbose_name = _('Tipo de Proposição')
         verbose_name_plural = _('Tipos de Proposições')
-        unique_together = (('content_type', 'object_id'), )
 
     def __str__(self):
         return self.descricao
@@ -234,6 +233,8 @@ class MateriaLegislativa(models.Model):
         verbose_name_plural = _('Matérias Legislativas')
         unique_together = (("tipo", "numero", "ano"),)
 
+        permissions = (("can_access_impressos", "Can access impressos"),)
+
     def __str__(self):
         return _('%(tipo)s nº %(numero)s de %(ano)s') % {
             'tipo': self.tipo, 'numero': self.numero, 'ano': self.ano}
@@ -805,6 +806,7 @@ class UnidadeTramitacao(models.Model):
     class Meta:
         verbose_name = _('Unidade de Tramitação')
         verbose_name_plural = _('Unidades de Tramitação')
+        ordering = ['orgao', 'comissao', 'parlamentar']
 
     def __str__(self):
         if self.orgao and self.comissao and self.parlamentar:

sapl/materia/signals.py

@@ -1,8 +1,3 @@
-from django.db.models.signals import post_delete, post_save
-
 import django.dispatch
 
-from .models import DocumentoAcessorio, MateriaLegislativa
-
-
 tramitacao_signal = django.dispatch.Signal(providing_args=['post', 'request'])

sapl/materia/tests/test_materia.py

@@ -1,9 +1,9 @@
+import pytest
 from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.core.urlresolvers import reverse
 from model_mommy import mommy
-import pytest
 
 from sapl.base.models import Autor, TipoAutor
 from sapl.comissoes.models import Comissao, TipoComissao
@@ -226,6 +226,7 @@ def test_documento_acessorio_submit(admin_client):
          'data_materia': '2016-03-21',
          'autor': autor,
          'ementa': 'teste_ementa',
+         'data': '2016-03-21',
          'salvar': 'salvar'},
         follow=True)
 

sapl/materia/urls.py

@@ -4,9 +4,11 @@ from sapl.materia.views import (AcompanhamentoConfirmarView,
                                 AcompanhamentoExcluirView,
                                 AcompanhamentoMateriaView, AnexadaCrud,
                                 AssuntoMateriaCrud, AutoriaCrud,
-                                ConfirmarProposicao, CriarProtocoloMateriaView,
-                                DespachoInicialCrud, DocumentoAcessorioCrud,
+                                AutoriaMultiCreateView, ConfirmarProposicao,
+                                CriarProtocoloMateriaView, DespachoInicialCrud,
+                                DocumentoAcessorioCrud,
                                 DocumentoAcessorioEmLoteView,
+                                EtiquetaPesquisaView, ImpressosView,
                                 LegislacaoCitadaCrud, MateriaAssuntoCrud,
                                 MateriaLegislativaCrud,
                                 MateriaLegislativaPesquisaView, MateriaTaView,
@@ -20,15 +22,21 @@ from sapl.materia.views import (AcompanhamentoConfirmarView,
                                 TipoFimRelatoriaCrud, TipoMateriaCrud,
                                 TipoProposicaoCrud, TramitacaoCrud,
                                 TramitacaoEmLoteView, UnidadeTramitacaoCrud,
-                                proposicao_texto, recuperar_materia,
-                                AutoriaMultiCreateView)
+                                proposicao_texto, recuperar_materia)
 
-from . import receivers
 from .apps import AppConfig
 
-
 app_name = AppConfig.name
 
+urlpatterns_impressos = [
+    url(r'^materia/impressos/$',
+        ImpressosView.as_view(),
+        name='impressos'),
+    url(r'^materia/impressos/etiqueta-pesquisa/$',
+        EtiquetaPesquisaView.as_view(),
+        name='impressos_etiqueta'),
+]
+
 urlpatterns_materia = [
     url(r'^materia/', include(MateriaLegislativaCrud.get_urls() +
                               AnexadaCrud.get_urls() +
@@ -120,5 +128,5 @@ urlpatterns_sistema = [
     url(r'^sistema/materia/orgao/', include(OrgaoCrud.get_urls())),
 ]
 
-urlpatterns = urlpatterns_materia + \
+urlpatterns = urlpatterns_impressos + urlpatterns_materia + \
     urlpatterns_proposicao + urlpatterns_sistema

sapl/materia/views.py

@@ -1,21 +1,19 @@
-from datetime import datetime, date
+from datetime import datetime
 from random import choice
 from string import ascii_letters, digits
 
+import weasyprint
 from crispy_forms.helper import FormHelper
 from crispy_forms.layout import HTML
-from django import forms
 from django.contrib import messages
 from django.contrib.auth.decorators import permission_required
 from django.contrib.auth.mixins import PermissionRequiredMixin
-from django.contrib.contenttypes.models import ContentType
-from django.core.exceptions import (ObjectDoesNotExist,
-                                    MultipleObjectsReturned)
+from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
-from django.db.models import Q
 from django.http import HttpResponse, JsonResponse
 from django.http.response import Http404, HttpResponseRedirect
 from django.shortcuts import get_object_or_404, redirect
+from django.template import RequestContext, loader
 from django.utils import formats
 from django.utils.translation import ugettext_lazy as _
 from django.views.generic import CreateView, ListView, TemplateView, UpdateView
@@ -23,6 +21,7 @@ from django.views.generic.base import RedirectView
 from django.views.generic.edit import FormView
 from django_filters.views import FilterView
 
+import sapl
 from sapl.base.models import Autor, CasaLegislativa
 from sapl.comissoes.models import Comissao, Participacao
 from sapl.compilacao.models import (STATUS_TA_IMMUTABLE_RESTRICT,
@@ -33,25 +32,25 @@ from sapl.crud.base import (ACTION_CREATE, ACTION_DELETE, ACTION_DETAIL,
                             ACTION_LIST, ACTION_UPDATE, RP_DETAIL, RP_LIST,
                             Crud, CrudAux, MasterDetailCrud,
                             PermissionRequiredForAppCrudMixin, make_pagination)
-from sapl.materia.forms import (AnexadaForm, ConfirmarProposicaoForm,
-                                LegislacaoCitadaForm, AutoriaForm, ProposicaoForm,
-                                TipoProposicaoForm, TramitacaoForm,
-                                TramitacaoUpdateForm, AutoriaMultiCreateForm)
+from sapl.materia.forms import (AnexadaForm, AutoriaForm,
+                                AutoriaMultiCreateForm,
+                                ConfirmarProposicaoForm, LegislacaoCitadaForm,
+                                ProposicaoForm, TipoProposicaoForm,
+                                TramitacaoForm, TramitacaoUpdateForm)
 from sapl.norma.models import LegislacaoCitada
 from sapl.protocoloadm.models import Protocolo
 from sapl.utils import (TURNO_TRAMITACAO_CHOICES, YES_NO_CHOICES, autor_label,
                         autor_modal, gerar_hash_arquivo, get_base_url,
                         montar_row_autor)
-import sapl
 
 from .email_utils import do_envia_email_confirmacao
 from .forms import (AcessorioEmLoteFilterSet, AcompanhamentoMateriaForm,
                     AdicionarVariasAutoriasFilterSet, DespachoInicialForm,
-                    DocumentoAcessorioForm, MateriaAssuntoForm,
-                    MateriaLegislativaFilterSet, MateriaSimplificadaForm,
-                    PrimeiraTramitacaoEmLoteFilterSet, ReceberProposicaoForm,
-                    RelatoriaForm, TramitacaoEmLoteFilterSet,
-                    filtra_tramitacao_destino,
+                    DocumentoAcessorioForm, EtiquetaPesquisaForm,
+                    MateriaAssuntoForm, MateriaLegislativaFilterSet,
+                    MateriaSimplificadaForm, PrimeiraTramitacaoEmLoteFilterSet,
+                    ReceberProposicaoForm, RelatoriaForm,
+                    TramitacaoEmLoteFilterSet, filtra_tramitacao_destino,
                     filtra_tramitacao_destino_and_status,
                     filtra_tramitacao_status)
 from .models import (AcompanhamentoMateria, Anexada, AssuntoMateria, Autoria,
@@ -62,7 +61,6 @@ from .models import (AcompanhamentoMateria, Anexada, AssuntoMateria, Autoria,
                      TipoProposicao, Tramitacao, UnidadeTramitacao)
 from .signals import tramitacao_signal
 
-
 AssuntoMateriaCrud = Crud.build(AssuntoMateria, 'assunto_materia')
 
 OrigemCrud = Crud.build(Origem, '')
@@ -1062,6 +1060,11 @@ class DocumentoAcessorioCrud(MasterDetailCrud):
         def __init__(self, **kwargs):
             super(MasterDetailCrud.CreateView, self).__init__(**kwargs)
 
+        def get_initial(self):
+            self.initial['data'] = datetime.now().date()
+
+            return self.initial
+
         def get_context_data(self, **kwargs):
             context = super(
                 MasterDetailCrud.CreateView, self).get_context_data(**kwargs)
@@ -1732,8 +1735,7 @@ class TramitacaoEmLoteView(PrimeiraTramitacaoEmLoteView):
         if ('tramitacao__status' in qr and
                 'tramitacao__unidade_tramitacao_destino' in qr and
                 qr['tramitacao__status'] and
-                    qr['tramitacao__unidade_tramitacao_destino']
-                ):
+                qr['tramitacao__unidade_tramitacao_destino']):
             lista = filtra_tramitacao_destino_and_status(
                 qr['tramitacao__status'],
                 qr['tramitacao__unidade_tramitacao_destino'])
@@ -1741,3 +1743,56 @@ class TramitacaoEmLoteView(PrimeiraTramitacaoEmLoteView):
                 id__in=lista).distinct()
 
         return context
+
+
+class ImpressosView(PermissionRequiredMixin, TemplateView):
+    template_name = 'materia/impressos/impressos.html'
+    permission_required = ('materia.can_access_impressos', )
+
+
+def gerar_pdf_impressos(request, context):
+    template = loader.get_template('materia/impressos/pdf.html')
+    html = template.render(RequestContext(request, context))
+    response = HttpResponse(content_type="application/pdf")
+    weasyprint.HTML(
+        string=html,
+        base_url=request.build_absolute_uri()).write_pdf(
+        response)
+
+    return response
+
+
+class EtiquetaPesquisaView(PermissionRequiredMixin, FormView):
+    form_class = EtiquetaPesquisaForm
+    template_name = 'materia/impressos/etiqueta.html'
+    permission_required = ('materia.can_access_impressos', )
+
+    def form_valid(self, form):
+        context = {}
+
+        materias = MateriaLegislativa.objects.all().order_by(
+            '-data_apresentacao')
+
+        if form.cleaned_data['tipo_materia']:
+            materias = materias.filter(tipo=form.cleaned_data['tipo_materia'])
+
+        if form.cleaned_data['data_inicial']:
+            materias = materias.filter(
+                data_apresentacao__gte=form.cleaned_data['data_inicial'],
+                data_apresentacao__lte=form.cleaned_data['data_final'])
+
+        if form.cleaned_data['processo_inicial']:
+            materias = materias.filter(
+                numeracao__numero_materia__gte=form.cleaned_data[
+                    'processo_inicial'],
+                numeracao__numero_materia__lte=form.cleaned_data[
+                    'processo_final'])
+
+        context['quantidade'] = len(materias)
+
+        if context['quantidade'] > 20:
+            materias = materias[:20]
+
+        context['materias'] = materias
+
+        return gerar_pdf_impressos(self.request, context)

sapl/norma/apps.py

@@ -6,6 +6,3 @@ class AppConfig(apps.AppConfig):
     name = 'sapl.norma'
     label = 'norma'
     verbose_name = _('Norma Jurídica')
-
-    def ready(self):
-        from . import signals

sapl/norma/forms.py

@@ -118,21 +118,24 @@ class NormaJuridicaForm(ModelForm):
         widgets = {'assuntos': widgets.CheckboxSelectMultiple}
 
     def clean(self):
-        super(NormaJuridicaForm, self).clean()
+        cleaned_data = super(NormaJuridicaForm, self).clean()
 
-        cleaned_data = self.cleaned_data
+        if not self.is_valid():
+            return cleaned_data
 
         if (cleaned_data['tipo_materia'] and
             cleaned_data['numero_materia'] and
                 cleaned_data['ano_materia']):
-
             try:
                 materia = MateriaLegislativa.objects.get(
                     tipo_id=cleaned_data['tipo_materia'],
                     numero=cleaned_data['numero_materia'],
                     ano=cleaned_data['ano_materia'])
             except ObjectDoesNotExist:
-                raise forms.ValidationError("Matéria escolhida não existe!")
+                raise forms.ValidationError(
+                    _("Matéria %s/%s é inexistente." % (
+                        self.cleaned_data['numero_materia'],
+                        self.cleaned_data['ano_materia'])))
             else:
                 cleaned_data['materia'] = materia
 

sapl/norma/migrations/0007_auto_20170904_1708.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.7 on 2017-09-04 17:08
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('norma', '0006_normajuridica_data_ultima_atualizacao'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='assuntonorma',
+            options={'ordering': ['assunto'], 'verbose_name': 'Assunto de Norma Jurídica', 'verbose_name_plural': 'Assuntos de Normas Jurídicas'},
+        ),
+        migrations.AlterField(
+            model_name='normajuridica',
+            name='esfera_federacao',
+            field=models.CharField(choices=[('M', 'Municipal'), ('E', 'Estadual'), ('F', 'Federal')], max_length=1, verbose_name='Esfera Federação'),
+        ),
+    ]

sapl/norma/models.py

@@ -20,6 +20,7 @@ class AssuntoNorma(models.Model):
     class Meta:
         verbose_name = _('Assunto de Norma Jurídica')
         verbose_name_plural = _('Assuntos de Normas Jurídicas')
+        ordering = ['assunto']
 
     def __str__(self):
         return self.assunto
@@ -59,15 +60,17 @@ class TipoNormaJuridica(models.Model):
     def __str__(self):
         return self.descricao
 
+
 def norma_upload_path(instance, filename):
     return texto_upload_path(instance, filename, subpath=instance.ano)
 
+
 @reversion.register()
 class NormaJuridica(models.Model):
     ESFERA_FEDERACAO_CHOICES = Choices(
+        ('M', 'municipal', _('Municipal')),
         ('E', 'estadual', _('Estadual')),
         ('F', 'federal', _('Federal')),
-        ('M', 'municipal', _('Municipal')),
     )
 
     texto_integral = models.FileField(

sapl/norma/signals.py

@@ -1,3 +0,0 @@
-from django.db.models.signals import post_delete, post_save
-
-from .models import NormaJuridica

sapl/norma/tests/test_norma.py

@@ -1,7 +1,10 @@
 import pytest
 from django.core.urlresolvers import reverse
+from django.utils.translation import ugettext_lazy as _
 from model_mommy import mommy
 
+from sapl.materia.models import MateriaLegislativa, TipoMateriaLegislativa
+from sapl.norma.forms import NormaJuridicaForm, NormaRelacionadaForm
 from sapl.norma.models import NormaJuridica, TipoNormaJuridica
 
 
@@ -38,14 +41,92 @@ def test_incluir_norma_errors(admin_client):
                                  follow=True)
 
     assert (response.context_data['form'].errors['tipo'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
     assert (response.context_data['form'].errors['numero'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
     assert (response.context_data['form'].errors['ano'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
     assert (response.context_data['form'].errors['data'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
     assert (response.context_data['form'].errors['esfera_federacao'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
     assert (response.context_data['form'].errors['ementa'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
+
+
+# TODO esse teste repete o teste acima (test_incluir_norma_errors)
+# mas a granularidade certa para testar campos obrigatórios seria
+# no nível de form ou então de model, não de client...
+def test_norma_form_invalida():
+    form = NormaJuridicaForm(data={})
+
+    assert not form.is_valid()
+
+    errors = form.errors
+
+    assert errors['tipo'] == [_('Este campo é obrigatório.')]
+    assert errors['numero'] == [_('Este campo é obrigatório.')]
+    assert errors['ano'] == [_('Este campo é obrigatório.')]
+    assert errors['data'] == [_('Este campo é obrigatório.')]
+    assert errors['esfera_federacao'] == [_('Este campo é obrigatório.')]
+    assert errors['ementa'] == [_('Este campo é obrigatório.')]
+
+
+@pytest.mark.django_db(transaction=False)
+def test_norma_juridica_materia_inexistente():
+
+    tipo = mommy.make(TipoNormaJuridica)
+    tipo_materia = mommy.make(TipoMateriaLegislativa)
+
+    form = NormaJuridicaForm(data={'tipo': str(tipo.pk),
+                                   'numero': '1',
+                                   'ano': '2017',
+                                   'data': '2017-12-12',
+                                   'esfera_federacao': 'F',
+                                   'ementa': 'teste norma',
+                                   'tipo_materia': str(tipo_materia.pk),
+                                   'numero_materia': '2',
+                                   'ano_materia': '2017'
+                                   })
+
+    assert not form.is_valid()
+
+    assert form.errors['__all__'] == [_("Matéria 2/2017 é inexistente.")]
+
+
+@pytest.mark.django_db(transaction=False)
+def test_norma_juridica_materia_existente():
+    tipo = mommy.make(TipoNormaJuridica)
+    tipo_materia = mommy.make(TipoMateriaLegislativa)
+    mommy.make(MateriaLegislativa,
+               numero=2,
+               ano=2017,
+               tipo=tipo_materia)
+
+    form = NormaJuridicaForm(data={'tipo': str(tipo.pk),
+                                   'numero': '1',
+                                   'ano': '2017',
+                                   'data': '2017-12-12',
+                                   'esfera_federacao': 'F',
+                                   'ementa': 'teste norma',
+                                   'tipo_materia': str(tipo_materia.pk),
+                                   'numero_materia': '2',
+                                   'ano_materia': '2017'
+                                   })
+    assert form.is_valid()
+
+
+@pytest.mark.django_db(transaction=False)
+def test_norma_relacionada_form_campos_obrigatorios():
+    form = NormaRelacionadaForm(data={})
+
+    assert not form.is_valid()
+
+    errors = form.errors
+
+    assert errors['tipo'] == [_('Este campo é obrigatório.')]
+    assert errors['numero'] == [_('Este campo é obrigatório.')]
+    assert errors['ano'] == [_('Este campo é obrigatório.')]
+    assert errors['tipo_vinculo'] == [_('Este campo é obrigatório.')]
+
+    assert len(errors) == 4

sapl/norma/urls.py

@@ -2,7 +2,8 @@ from django.conf.urls import include, url
 
 from sapl.norma.views import (AssuntoNormaCrud, NormaCrud, NormaPesquisaView,
                               NormaRelacionadaCrud, NormaTaView, TipoNormaCrud,
-                              TipoVinculoNormaJuridicaCrud, recuperar_norma)
+                              TipoVinculoNormaJuridicaCrud, recuperar_norma,
+                              recuperar_numero_norma)
 
 from .apps import AppConfig
 
@@ -25,5 +26,7 @@ urlpatterns = [
         NormaPesquisaView.as_view(), name='norma_pesquisa'),
 
     url(r'^norma/recuperar-norma$', recuperar_norma, name="recuperar_norma"),
+    url(r'^norma/recuperar-numero-norma$', recuperar_numero_norma,
+        name="recuperar_numero_norma"),
 
 ]

sapl/norma/views.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
 from django.http import JsonResponse
@@ -185,3 +187,22 @@ def recuperar_norma(request):
         response = JsonResponse({'ementa': '', 'id': 0})
 
     return response
+
+
+def recuperar_numero_norma(request):
+    tipo = TipoNormaJuridica.objects.get(pk=request.GET['tipo'])
+    ano = request.GET.get('ano', '')
+
+    param = {'tipo': tipo}
+    param['ano'] = ano if ano else datetime.now().year
+
+    norma = NormaJuridica.objects.filter(**param).order_by(
+        'tipo', 'ano', 'numero').values_list('numero', 'ano').last()
+    if norma:
+        response = JsonResponse({'numero': int(norma[0]) + 1,
+                                 'ano': norma[1]})
+    else:
+        response = JsonResponse(
+            {'numero': 1, 'ano': ano})
+
+    return response

sapl/painel/urls.py

@@ -2,8 +2,8 @@ from django.conf.urls import url
 
 from .apps import AppConfig
 from .views import (cronometro_painel, get_dados_painel, painel_mensagem_view,
-                    painel_parlamentar_view, painel_view,
-                    painel_votacao_view, votante_view)
+                    painel_parlamentar_view, painel_view, painel_votacao_view,
+                    votante_view)
 
 app_name = AppConfig.name
 

sapl/painel/views.py

@@ -1,10 +1,10 @@
-from datetime import date
+
 
 from django.contrib import messages
 from django.contrib.auth.decorators import user_passes_test
-from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned
-from django.db.models import Q
+from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
+from django.db.models import Q
 from django.http import HttpResponse, JsonResponse
 from django.http.response import Http404, HttpResponseRedirect
 from django.shortcuts import render
@@ -12,12 +12,11 @@ from django.utils.translation import ugettext_lazy as _
 
 from sapl.crud.base import Crud
 from sapl.painel.apps import AppConfig
-from sapl.painel.models import Painel
-from sapl.parlamentares.models import Filiacao, Votante
+from sapl.parlamentares.models import Votante
 from sapl.sessao.models import (ExpedienteMateria, OrdemDia, PresencaOrdemDia,
                                 RegistroVotacao, SessaoPlenaria,
                                 SessaoPlenariaPresenca, VotoParlamentar)
-from sapl.utils import get_client_ip
+from sapl.utils import filiacao_data, get_client_ip
 
 from .models import Cronometro
 
@@ -253,8 +252,6 @@ def get_cronometro_status(request, name):
         cronometro = ''
     return cronometro
 
-# ##############################ORDEM DO DIA##################################
-
 
 def get_materia_aberta(pk):
     return OrdemDia.objects.filter(
@@ -262,56 +259,43 @@ def get_materia_aberta(pk):
 
 
 def get_presentes(pk, response, materia):
-    filiacao = Filiacao.objects.filter(
-        data_desfiliacao__isnull=True, parlamentar__ativo=True)
-    parlamentar_partido = {}
-    for f in filiacao:
-        parlamentar_partido[
-            f.parlamentar.nome_parlamentar] = f.partido.sigla
-
-    sessao_plenaria_presenca = SessaoPlenariaPresenca.objects.filter(
+    if type(materia) == OrdemDia:
+        presentes = PresencaOrdemDia.objects.filter(
             sessao_plenaria_id=pk)
-    presentes_sessao_plenaria = [
-        p.parlamentar.nome_parlamentar for p in sessao_plenaria_presenca]
-    num_presentes_sessao_plen = len(presentes_sessao_plenaria)
-
-    presenca_ordem_dia = PresencaOrdemDia.objects.filter(
+    elif type(materia) == ExpedienteMateria:
+        presentes = SessaoPlenariaPresenca.objects.filter(
             sessao_plenaria_id=pk)
-    presentes_ordem_dia = []
-    for p in presenca_ordem_dia:
-        nome_parlamentar = p.parlamentar.nome_parlamentar
 
-        try:
-            parlamentar_partido[nome_parlamentar]
-        except KeyError:
-            presentes_ordem_dia.append(
-                {'id': p.id,
-                 'nome': nome_parlamentar,
-                 'partido': str(_('Sem Registro')),
-                 })
+    num_presentes = len(presentes)
+    data_sessao = materia.sessao_plenaria.data_inicio
+
+    presentes_list = []
+    for p in presentes:
+        filiacao = filiacao_data(p.parlamentar, data_sessao, data_sessao)
+
+        if not filiacao:
+            partido = _('Sem Registro')
         else:
-            presentes_ordem_dia.append(
+            partido = filiacao
+
+        presentes_list.append(
             {'id': p.id,
-                 'nome': nome_parlamentar,
-                 'partido': parlamentar_partido[nome_parlamentar],
+             'parlamentar_id': p.parlamentar.id,
+             'nome': p.parlamentar.nome_parlamentar,
+             'partido': partido,
+             'voto': ''
              })
-    num_presentes_ordem_dia = len(presentes_ordem_dia)
 
     if materia.tipo_votacao == 1:
-        tipo_votacao = str(_('Simbólica'))
-        response = get_votos(response, materia)
+        tipo_votacao = 'Simbólica'
     elif materia.tipo_votacao == 2:
         tipo_votacao = 'Nominal'
-        response = get_votos_nominal(response, materia)
     elif materia.tipo_votacao == 3:
         tipo_votacao = 'Secreta'
-        response = get_votos(response, materia)
 
     response.update({
-        'presentes_ordem_dia': presentes_ordem_dia,
-        'num_presentes_ordem_dia': num_presentes_ordem_dia,
-        'presentes_sessao_plenaria': presentes_sessao_plenaria,
-        'num_presentes_sessao_plenaria': num_presentes_sessao_plen,
+        'presentes': presentes_list,
+        'num_presentes': num_presentes,
         'status_painel': 'ABERTO',
         'msg_painel': str(_('Votação aberta!')),
         'tipo_resultado': materia.resultado,
@@ -322,76 +306,11 @@ def get_presentes(pk, response, materia):
     return response
 
 
-# ########################EXPEDIENTE############################################
-
-
 def get_materia_expediente_aberta(pk):
     return ExpedienteMateria.objects.filter(
         sessao_plenaria_id=pk, votacao_aberta=True).last()
 
 
-def get_presentes_expediente(pk, response, materia):
-    filiacao = Filiacao.objects.filter(
-        data_desfiliacao__isnull=True, parlamentar__ativo=True)
-    parlamentar_partido = {}
-    for f in filiacao:
-        parlamentar_partido[
-            f.parlamentar.nome_parlamentar] = f.partido.sigla
-
-    sessao_plenaria_presenca = SessaoPlenariaPresenca.objects.filter(
-        sessao_plenaria_id=pk)
-    presentes_sessao_plenaria = [
-        p.parlamentar.nome_parlamentar for p in sessao_plenaria_presenca]
-    num_presentes_sessao_plen = len(presentes_sessao_plenaria)
-
-    presenca_expediente = SessaoPlenariaPresenca.objects.filter(
-        sessao_plenaria_id=pk)
-    presentes_expediente = []
-    for p in presenca_expediente:
-        nome_parlamentar = p.parlamentar.nome_parlamentar
-
-        try:
-            parlamentar_partido[nome_parlamentar]
-        except KeyError:
-            presentes_expediente.append(
-                {'id': p.id,
-                 'nome': nome_parlamentar,
-                 'partido': str(_('Sem Registro')),
-                 })
-        else:
-            presentes_expediente.append(
-                {'id': p.id,
-                 'nome': nome_parlamentar,
-                 'partido': parlamentar_partido[nome_parlamentar],
-                 })
-    num_presentes_expediente = len(presentes_expediente)
-
-    if materia.tipo_votacao == 1:
-        tipo_votacao = 'Simbólica'
-        response = get_votos(response, materia)
-    elif materia.tipo_votacao == 2:
-        tipo_votacao = 'Nominal'
-        response = get_votos_nominal(response, materia)
-    elif materia.tipo_votacao == 3:
-        tipo_votacao = 'Secreta'
-        response = get_votos(response, materia)
-
-    response.update({
-        'presentes_expediente': presentes_expediente,
-        'num_presentes_expediente': num_presentes_expediente,
-        'presentes_sessao_plenaria': presentes_sessao_plenaria,
-        'num_presentes_sessao_plenaria': num_presentes_sessao_plen,
-        'status_painel': str(_('ABERTO')),
-        'msg_painel': str(_('Votação aberta!')),
-        'tipo_resultado': tipo_votacao,
-        'observacao_materia': materia.observacao,
-        'materia_legislativa_texto': str(materia.materia)})
-
-    return response
-
-
-# ##########################GENERAL FUNCTIONS#############################
-
 def response_nenhuma_materia(response):
     response.update({
         'status_painel': 'FECHADO',
@@ -400,112 +319,47 @@ def response_nenhuma_materia(response):
 
 
 def get_votos(response, materia):
-    if materia.tipo_votacao == 1:
-        tipo_votacao = 'Simbólica'
-    elif materia.tipo_votacao == 2:
-        tipo_votacao = 'Nominal'
-    elif materia.tipo_votacao == 3:
-        tipo_votacao = 'Secreta'
-
     if type(materia) == OrdemDia:
         registro = RegistroVotacao.objects.filter(
             ordem=materia, materia=materia.materia).last()
-    else:
+    elif type(materia) == ExpedienteMateria:
         registro = RegistroVotacao.objects.filter(
             expediente=materia, materia=materia.materia).last()
 
-    if registro:
-        total = (registro.numero_votos_sim +
-                 registro.numero_votos_nao +
-                 registro.numero_abstencoes)
-        response.update({
-            'numero_votos_sim': registro.numero_votos_sim,
-            'numero_votos_nao': registro.numero_votos_nao,
-            'numero_abstencoes': registro.numero_abstencoes,
-            'total_votos': total,
-            'tipo_votacao': tipo_votacao,
-            'tipo_resultado': registro.tipo_resultado_votacao.nome,
-        })
-    else:
+    if not registro:
         response.update({
             'numero_votos_sim': 0,
             'numero_votos_nao': 0,
             'numero_abstencoes': 0,
+            'registro': None,
             'total_votos': 0,
-            'tipo_votacao': tipo_votacao,
             'tipo_resultado': 'Ainda não foi votada.',
         })
-    return response
-
-
-def get_votos_nominal(response, materia):
-    votos = []
 
-    if materia.tipo_votacao == 1:
-        tipo_votacao = 'Simbólica'
-    elif materia.tipo_votacao == 2:
-        tipo_votacao = 'Nominal'
-    elif materia.tipo_votacao == 3:
-        tipo_votacao = 'Secreta'
-
-    if type(materia) == OrdemDia:
-        registro = RegistroVotacao.objects.filter(
-            ordem=materia, materia=materia.materia).last()
     else:
-        registro = RegistroVotacao.objects.filter(
-            expediente=materia, materia=materia.materia).last()
-
-    if not registro:
-        response.update({
-            'numero_votos_sim': 0,
-            'numero_votos_nao': 0,
-            'numero_abstencoes': 0,
-            'total_votos': 0,
-            'tipo_votacao': tipo_votacao,
-            'tipo_resultado': 'Não foi votado ainda',
-            'votos': None
-        })
+        total = (registro.numero_votos_sim +
+                 registro.numero_votos_nao +
+                 registro.numero_abstencoes)
 
-    else:
+        if materia.tipo_votacao == 2:
             votos_parlamentares = VotoParlamentar.objects.filter(
-            votacao_id=registro.id).order_by('parlamentar__nome_parlamentar')
+                votacao_id=registro.id).order_by(
+                    'parlamentar__nome_parlamentar')
 
-        filiacao = Filiacao.objects.filter(
-            data_desfiliacao__isnull=True, parlamentar__ativo=True)
-        parlamentar_partido = {}
-        for f in filiacao:
-            parlamentar_partido[
-                f.parlamentar.nome_parlamentar] = f.partido.sigla
-
-        for v in votos_parlamentares:
+            for i, p in enumerate(response['presentes']):
                 try:
-                parlamentar_partido[v.parlamentar.nome_parlamentar]
-            except KeyError:
-                votos.append({
-                    'parlamentar': v.parlamentar.nome_parlamentar,
-                    'voto': str(v.voto),
-                    'partido': str(_('Sem Registro'))
-                })
-            else:
-                votos.append({
-                    'parlamentar': v.parlamentar.nome_parlamentar,
-                    'voto': str(v.voto),
-                    'partido': parlamentar_partido[
-                        v.parlamentar.nome_parlamentar]
-                })
-
-        total = (registro.numero_votos_sim +
-                 registro.numero_votos_nao +
-                 registro.numero_abstencoes)
+                    response['presentes'][i]['voto'] = votos_parlamentares.get(
+                        parlamentar_id=p['parlamentar_id']).voto
+                except ObjectDoesNotExist:
+                    response['presentes'][i]['voto'] = None
 
         response.update({
             'numero_votos_sim': registro.numero_votos_sim,
             'numero_votos_nao': registro.numero_votos_nao,
             'numero_abstencoes': registro.numero_abstencoes,
+            'registro': True,
             'total_votos': total,
-            'tipo_votacao': tipo_votacao,
             'tipo_resultado': registro.tipo_resultado_votacao.nome,
-            'votos': votos
         })
 
     return response
@@ -514,79 +368,60 @@ def get_votos_nominal(response, materia):
 @user_passes_test(check_permission)
 def get_dados_painel(request, pk):
     sessao = SessaoPlenaria.objects.get(id=pk)
-    cronometro_discurso = get_cronometro_status(request, 'discurso')
-    cronometro_aparte = get_cronometro_status(request, 'aparte')
-    cronometro_ordem = get_cronometro_status(request, 'ordem')
 
     response = {
         'sessao_plenaria': str(sessao),
         'sessao_plenaria_data': sessao.data_inicio.strftime('%d/%m/%Y'),
         'sessao_plenaria_hora_inicio': sessao.hora_inicio,
-        "cronometro_aparte": cronometro_aparte,
-        "cronometro_discurso": cronometro_discurso,
-        "cronometro_ordem": cronometro_ordem,
+        'cronometro_aparte': get_cronometro_status(request, 'aparte'),
+        'cronometro_discurso': get_cronometro_status(request, 'discurso'),
+        'cronometro_ordem': get_cronometro_status(request, 'ordem'),
     }
 
     ordem_dia = get_materia_aberta(pk)
     expediente = get_materia_expediente_aberta(pk)
 
+    # Caso tenha alguma matéria com votação aberta, ela é mostrada no painel
+    # com prioridade para Ordem do Dia.
     if ordem_dia:
-        return JsonResponse(get_presentes(pk, response, ordem_dia))
+        return JsonResponse(get_votos(
+            get_presentes(pk, response, ordem_dia),
+            ordem_dia))
     elif expediente:
-        return JsonResponse(get_presentes_expediente(pk, response, expediente))
+        return JsonResponse(get_votos(
+            get_presentes(pk, response, expediente),
+            expediente))
 
-    # Ultimo voto em ordem e ultimo voto em expediente
+    # Caso não tenha nenhuma aberta,
+    # a matéria a ser mostrada no Painel deve ser a última votada
     last_ordem_voto = RegistroVotacao.objects.filter(
         ordem__sessao_plenaria=sessao).last()
     last_expediente_voto = RegistroVotacao.objects.filter(
         expediente__sessao_plenaria=sessao).last()
 
-    # Ultimas materias votadas
     if last_ordem_voto:
         ultima_ordem_votada = last_ordem_voto.ordem
     if last_expediente_voto:
         ultimo_expediente_votado = last_expediente_voto.expediente
 
-    # Caso não tenha nenhuma votação aberta
     if last_ordem_voto or last_expediente_voto:
-
         # Se alguma ordem E algum expediente já tiver sido votado...
         if last_ordem_voto and last_expediente_voto:
-            # Verifica se o último resultado é um uma ordem do dia
-            if last_ordem_voto.pk >= last_expediente_voto.pk:
-                if ultima_ordem_votada.tipo_votacao in [1, 3]:
-                    return JsonResponse(
-                        get_votos(get_presentes(
-                            pk, response, ultima_ordem_votada),
-                            ultima_ordem_votada))
-                elif ultima_ordem_votada.tipo_votacao == 2:
-                    return JsonResponse(
-                        get_votos_nominal(get_presentes(
-                            pk, response, ultima_ordem_votada),
-                            ultima_ordem_votada))
-            # Caso não seja, verifica se é um expediente
-            else:
-                if ultimo_expediente_votado.tipo_votacao in [1, 3]:
-                    return JsonResponse(
-                        get_votos(get_presentes_expediente(
-                                  pk, response, ultimo_expediente_votado),
-                                  ultimo_expediente_votado))
-                elif ultimo_expediente_votado.tipo_votacao == 2:
-                    return JsonResponse(
-                        get_votos_nominal(get_presentes_expediente(
-                                          pk, response,
-                                          ultimo_expediente_votado),
-                                          ultimo_expediente_votado))
+            materia = ultima_ordem_votada\
+                if last_ordem_voto.pk >= last_expediente_voto.pk\
+                else ultimo_expediente_votado
 
         # Caso somente um deles tenha resultado, prioriza a Ordem do Dia
-        if last_ordem_voto:
-            return JsonResponse(get_presentes(
-                pk, response, ultima_ordem_votada))
+        elif last_ordem_voto:
+            materia = ultima_ordem_votada
+
         # Caso a Ordem do dia não tenha resultado, mostra o último expediente
-        if last_expediente_voto:
-            return JsonResponse(get_presentes_expediente(
-                pk, response,
-                ultimo_expediente_votado))
+        elif last_expediente_voto:
+            materia = ultimo_expediente_votado
+
+        return JsonResponse(get_votos(
+                            get_presentes(pk, response, materia),
+                            materia))
 
     # Retorna que não há nenhuma matéria já votada ou aberta
     return response_nenhuma_materia(response)

sapl/parlamentares/fixtures/pre_popula_cargosmesa.json

@@ -0,0 +1,37 @@
+[
+  {
+    "model": "parlamentares.CargoMesa",
+    "pk": 1,
+    "fields": {
+      "descricao": "Presidente",
+      "unico": true
+    }
+  },
+  {
+    "model": "parlamentares.CargoMesa",
+    "pk": 2,
+    "fields": {
+      "descricao": "Vice-Presidente",
+      "unico": true
+    }
+  },
+  {
+    "model": "parlamentares.CargoMesa",
+    "pk": 3,
+    "fields": {
+      "descricao": "Primeiro-Secretário",
+      "unico": true
+    }
+  },
+  {
+    "model": "parlamentares.CargoMesa",
+    "pk": 4,
+    "fields": {
+      "descricao": "Segundo-Secretário",
+      "unico": true
+    }
+  }
+]
+
+
+

sapl/parlamentares/fixtures/pre_popula_partidos.json

@@ -0,0 +1,282 @@
+[
+  {
+    "model": "parlamentares.Partido",
+    "pk": 1,
+    "fields": {
+      "sigla": "PMDB",
+      "nome": "PARTIDO DO MOVIMENTO DEMOCRÁTICO BRASILEIRO"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 2,
+    "fields": {
+      "sigla": "PTB",
+      "nome": "PARTIDO TRABALHISTA BRASILEIRO"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 3,
+    "fields": {
+      "sigla": "PDT",
+      "nome": "PARTIDO DEMOCRÁTICO TRABALHISTA"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 4,
+    "fields": {
+      "sigla": "PT",
+      "nome": "PARTIDO DOS TRABALHADORES"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 5,
+    "fields": {
+      "sigla": "DEM",
+      "nome": "DEMOCRATAS"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 6,
+    "fields": {
+      "sigla": "PCdoB",
+      "nome": "PARTIDO COMUNISTA DO BRASIL"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 7,
+    "fields": {
+      "sigla": "PSB",
+      "nome": "PARTIDO SOCIALISTA BRASILEIRO"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 8,
+    "fields": {
+      "sigla": "PSDB",
+      "nome": "PARTIDO DA SOCIAL DEMOCRACIA BRASILEIRA"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 9,
+    "fields": {
+      "sigla": "PTC",
+      "nome": "PARTIDO TRABALHISTA CRISTÃO"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 10,
+    "fields": {
+      "sigla": "PSC",
+      "nome": "PARTIDO SOCIAL CRISTÃO"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 11,
+    "fields": {
+      "sigla": "PMN",
+      "nome": "PARTIDO DA MOBILIZAÇÃO NACIONAL"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 12,
+    "fields": {
+      "sigla": "PRP",
+      "nome": "PARTIDO REPUBLICANO PROGRESSISTA"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 13,
+    "fields": {
+      "sigla": "PPS",
+      "nome": "PARTIDO POPULAR SOCIALISTA"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 14,
+    "fields": {
+      "sigla": "PV",
+      "nome": "PARTIDO VERDE"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 15,
+    "fields": {
+      "sigla": "PTdoB",
+      "nome": "PARTIDO TRABALHISTA DO BRASIL"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 16,
+    "fields": {
+      "sigla": "PP",
+      "nome": "PARTIDO PROGRESSISTA"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 17,
+    "fields": {
+      "sigla": "PSTU",
+      "nome": "PARTIDO SOCIALISTA DOS TRABALHADORES UNIFICADO"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 18,
+    "fields": {
+      "sigla": "PCB",
+      "nome": "PARTIDO COMUNISTA BRASILEIRO"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 19,
+    "fields": {
+      "sigla": "PRTB",
+      "nome": "PARTIDO RENOVADOR TRABALHISTA BRASILEIRO"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 20,
+    "fields": {
+      "sigla": "PHS",
+      "nome": "PARTIDO HUMANISTA DA SOLIDARIEDADE"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 21,
+    "fields": {
+      "sigla": "PSDC",
+      "nome": "PARTIDO SOCIAL DEMOCRATA CRISTÃO"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 22,
+    "fields": {
+      "sigla": "PCO",
+      "nome": "PARTIDO DA CAUSA OPERÁRIA"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 23,
+    "fields": {
+      "sigla": "PODE",
+      "nome": "PODEMOS"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 24,
+    "fields": {
+      "sigla": "PSL",
+      "nome": "PARTIDO SOCIAL LIBERAL"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 25,
+    "fields": {
+      "sigla": "PRB",
+      "nome": "PARTIDO REPUBLICANO BRASILEIRO"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 26,
+    "fields": {
+      "sigla": "PSOL",
+      "nome": "PARTIDO SOCIALISMO E LIBERDADE"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 27,
+    "fields": {
+      "sigla": "PR",
+      "nome": "PARTIDO DA REPÚBLICA"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 28,
+    "fields": {
+      "sigla": "PSD",
+      "nome": "PARTIDO SOCIAL DEMOCRÁTICO"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 29,
+    "fields": {
+      "sigla": "PPL",
+      "nome": "PARTIDO PÁTRIA LIVRE"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 30,
+    "fields": {
+      "sigla": "PEN",
+      "nome": "PARTIDO ECOLÓGICO NACIONAL"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 31,
+    "fields": {
+      "sigla": "PROS",
+      "nome": "PARTIDO REPUBLICANO DA ORDEM SOCIAL"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 32,
+    "fields": {
+      "sigla": "SD",
+      "nome": "SOLIDARIEDADE"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 33,
+    "fields": {
+      "sigla": "NOVO",
+      "nome": "PARTIDO NOVO"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 34,
+    "fields": {
+      "sigla": "REDE",
+      "nome": "REDE SUSTENTABILIDADE"
+    }
+  },
+  {
+    "model": "parlamentares.Partido",
+    "pk": 35,
+    "fields": {
+      "sigla": "PMB",
+      "nome": "PARTIDO DA MULHER BRASILEIRA"
+    }
+  }
+]

sapl/parlamentares/forms.py

@@ -5,7 +5,7 @@ from crispy_forms.layout import Fieldset, Layout
 from django import forms
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Group, User
-from django.core.exceptions import ObjectDoesNotExist, ValidationError
+from django.core.exceptions import ValidationError
 from django.db import transaction
 from django.db.models import Q
 from django.forms import ModelForm
@@ -62,17 +62,34 @@ class MandatoForm(ModelForm):
     def clean(self):
         super(MandatoForm, self).clean()
 
+        if not self.is_valid():
+            return self.cleaned_data
+
         data = self.cleaned_data
-        try:
-            if 'legislatura' in data and 'parlamentar' in data:
-                    Mandato.objects.get(
-                        parlamentar__pk=self.initial['parlamentar'].pk,
-                        legislatura__pk=data['legislatura'].pk)
-        except ObjectDoesNotExist:
-            pass
-        else:
-            raise ValidationError('Mandato nesta legislatura já existe.')
-        return data
+
+        legislatura = data['legislatura']
+
+        data_inicio_mandato = data['data_inicio_mandato']
+        if data_inicio_mandato:
+            if (data_inicio_mandato < legislatura.data_inicio or
+                    data_inicio_mandato > legislatura.data_fim):
+                raise ValidationError(_("Data início mandato fora do intervalo"
+                                        " de legislatura informada"))
+
+        data_fim_mandato = data['data_fim_mandato']
+        if data_fim_mandato:
+            if (data_fim_mandato < legislatura.data_inicio or
+                    data_fim_mandato > legislatura.data_fim):
+                raise ValidationError(_("Data fim mandato fora do intervalo de"
+                                        " legislatura informada"))
+
+        existe_mandato = Mandato.objects.filter(
+            parlamentar=data['parlamentar'],
+            legislatura=data['legislatura']).exists()
+        if existe_mandato:
+            raise ValidationError(_('Mandato nesta legislatura já existe.'))
+
+        return self.cleaned_data
 
 
 class LegislaturaForm(ModelForm):
@@ -81,6 +98,26 @@ class LegislaturaForm(ModelForm):
         model = Legislatura
         exclude = []
 
+    def clean(self):
+        data = super(LegislaturaForm, self).clean()
+
+        if not self.is_valid():
+            return self.cleaned_data
+
+        data_inicio = data['data_inicio']
+        data_fim = data['data_fim']
+        data_eleicao = data['data_eleicao']
+
+        if data_eleicao.year >= data_inicio.year:
+            raise ValidationError(_("Data eleição não pode ser inferior a "
+                                    "data início da legislatura"))
+
+        if data_inicio > data_fim or (data_fim.year - data_inicio.year != 4):
+            raise ValidationError(_("Intervalo de início e fim inválido para "
+                                    "legislatura."))
+
+        return data
+
 
 class LegislaturaCreateForm(LegislaturaForm):
 
@@ -88,6 +125,10 @@ class LegislaturaCreateForm(LegislaturaForm):
         super(LegislaturaCreateForm, self).clean()
 
         cleaned_data = self.cleaned_data
+
+        if not self.is_valid():
+            return cleaned_data
+
         eleicao = cleaned_data['data_eleicao']
         inicio = cleaned_data['data_inicio']
         fim = cleaned_data['data_fim']
@@ -275,44 +316,23 @@ class FrenteForm(ModelForm):
 
 
 class VotanteForm(ModelForm):
-    senha = forms.CharField(
-        max_length=20,
-        label=_('Senha'),
-        required=True,
-        widget=forms.PasswordInput())
-
-    senha_confirma = forms.CharField(
-        max_length=20,
-        label=_('Confirmar Senha'),
-        required=True,
-        widget=forms.PasswordInput())
 
     username = forms.CharField(
         label=_('Usuário'),
         required=True,
         max_length=30)
 
-    email = forms.EmailField(
-        required=True,
-        label=_('Email'))
-
-    email_confirma = forms.EmailField(
-        required=True,
-        label=_('Confirmar Email'))
-
     class Meta:
         model = Votante
-        fields = ['username', 'senha', 'senha_confirma', 'email',
-                  'email_confirma']
+        fields = ['username']
 
     def __init__(self, *args, **kwargs):
-        row1 = to_row([('username', 4), ('senha', 4), ('senha_confirma', 4)])
-        row2 = to_row([('email', 6), ('email_confirma', 6)])
+        row1 = to_row([('username', 4)])
 
         self.helper = FormHelper()
         self.helper.layout = Layout(
             Fieldset(_('Votante'),
-                     row1, row2, form_actions(save_label='Salvar'))
+                     row1, form_actions(save_label='Salvar'))
         )
         super(VotanteForm, self).__init__(*args, **kwargs)
 
@@ -327,23 +347,19 @@ class VotanteForm(ModelForm):
         cd = self.cleaned_data
 
         username = cd['username']
-        if get_user_model().objects.filter(username=username).exists():
-            raise ValidationError(_('Não foi possível salvar registro,\
-                                     pois usuário existente'))
-
-        if ('senha' not in cd or 'senha_confirma' not in cd or
-                not cd['senha'] or not cd['senha_confirma']):
+        user = get_user_model().objects.filter(username=username)
+        if not user.exists():
             raise ValidationError(_(
-                'A senha e sua confirmação devem ser informadas.'))
-        msg = _('As senhas não conferem.')
-        self.valida_igualdade(cd['senha'], cd['senha_confirma'], msg)
-
-        if ('email' not in cd or 'email_confirma' not in cd or
-                not cd['email'] or not cd['email_confirma']):
+                "{} [{}] {}".format(
+                    'Não foi possível vincular usuário. Usuário',
+                    username,
+                    'não existe')))
+        if Votante.objects.filter(user=user[0].pk).exists():
             raise ValidationError(_(
-                'O email e sua confirmação devem ser informados.'))
-        msg = _('Os emails não conferem.')
-        self.valida_igualdade(cd['email'], cd['email_confirma'], msg)
+                "{} [{}] {}".format(
+                    'Não foi possível vincular usuário. Usuário',
+                    username,
+                    'já esta vinculado à outro parlamentar')))
 
         return self.cleaned_data
 
@@ -352,12 +368,7 @@ class VotanteForm(ModelForm):
         votante = super(VotanteForm, self).save(commit)
 
         # Cria user
-        u = User.objects.create(
-            username=self.cleaned_data['username'],
-            email=self.cleaned_data['email'])
-        u.set_password(self.cleaned_data['senha'])
-        u.save()
-
+        u = User.objects.get(username=self.cleaned_data['username'])
         # Adiciona user ao grupo
         g = Group.objects.filter(name=SAPL_GROUP_VOTANTE)[0]
         u.groups.add(g)

sapl/parlamentares/migrations/0005_auto_20170814_1615.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.11 on 2017-08-14 16:15
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('parlamentares', '0004_auto_20170711_1305'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='frente',
+            options={'verbose_name': 'Frente Parlamentar', 'verbose_name_plural': 'Frentes Parlamentares'},
+        ),
+    ]

sapl/parlamentares/migrations/0006_auto_20170831_1400.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.13 on 2017-08-31 14:00
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('parlamentares', '0005_auto_20170814_1615'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='votante',
+            options={'permissions': (('can_vote', 'Can Vote'),), 'verbose_name': 'Usuário Votante', 'verbose_name_plural': 'Usuários Votantes'},
+        ),
+    ]

sapl/parlamentares/migrations/0007_adiciona_partidos.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+from django.db import migrations
+import json
+import os
+
+
+from django.core.management import call_command
+
+
+
+def gera_partidos_tse(apps, schema_editor):
+    Partido = apps.get_model("parlamentares", "Partido")
+    db_alias = schema_editor.connection.alias
+    partidos = Partido.objects.all().exists()
+
+    if partidos:
+        # Caso haja algum partido cadastrado na base de dados,
+        # a migração não deve ser carregada para evitar duplicações de dados.
+        print("Carga de Partido não efetuada. Já Existem partidos cadastrados...")
+    else:
+        fixture_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../fixtures'))
+        # pega partidos listados em fixtures/pre_popula_partidos.json
+        fixture_filename = 'pre_popula_partidos.json'
+        fixture_file = os.path.join(fixture_dir, fixture_filename)
+        call_command('loaddata', fixture_file)
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        # A dependencia real desse script é o arquivo 0001_initial.py, mas
+        # isso gera um erro (Conflicting migrations detected; multiple leaf
+         # nodes in the migration graph). para não  ocasionar problemas de migração,
+         # vamos manter a ordem padrão do django.
+        ('parlamentares', '0006_auto_20170831_1400'),
+    ]
+
+    operations = [
+        migrations.RunPython(gera_partidos_tse),
+    ]

sapl/parlamentares/migrations/0008_adiciona_cargos_mesa.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+from django.db import migrations
+import json
+import os
+
+
+from django.core.management import call_command
+
+
+
+def gera_cargos_mesa(apps, schema_editor):
+    CargoMesa = apps.get_model("parlamentares", "CargoMesa")
+    db_alias = schema_editor.connection.alias
+    cargos_mesa = CargoMesa.objects.all().exists()
+
+    if cargos_mesa:
+        # Caso haja algum CargoMesa cadastrado na base de dados,
+        # a migração não deve ser carregada para evitar duplicações de dados.
+        print("Carga de {} não efetuada. Já Existem {} cadastrados...".format(
+            CargoMesa._meta.verbose_name, CargoMesa._meta.verbose_name_plural))
+    else:
+        fixture_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../fixtures'))
+        # pega partidos listados em fixtures/pre_popula_partidos.json
+        fixture_filename = 'pre_popula_cargosmesa.json'
+        fixture_file = os.path.join(fixture_dir, fixture_filename)
+        call_command('loaddata', fixture_file)
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        # A dependencia real desse script é o arquivo 0001_initial.py, mas
+        # isso gera um erro (Conflicting migrations detected; multiple leaf
+         # nodes in the migration graph). para não ocasionar problemas de migração,
+         # vamos manter a ordem padrão do django.
+        ('parlamentares', '0007_adiciona_partidos'),
+    ]
+
+    operations = [
+        migrations.RunPython(gera_cargos_mesa),
+    ]

sapl/parlamentares/migrations/0009_auto_20170905_1617.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.13 on 2017-09-05 16:17
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('parlamentares', '0008_adiciona_cargos_mesa'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='situacaomilitar',
+            options={'ordering': ['descricao'], 'verbose_name': 'Tipo Situação Militar', 'verbose_name_plural': 'Tipos Situações Militares'},
+        ),
+        migrations.AlterModelOptions(
+            name='tipoafastamento',
+            options={'ordering': ['descricao'], 'verbose_name': 'Tipo de Afastamento', 'verbose_name_plural': 'Tipos de Afastamento'},
+        ),
+        migrations.AlterModelOptions(
+            name='tipodependente',
+            options={'ordering': ['descricao'], 'verbose_name': 'Tipo de Dependente', 'verbose_name_plural': 'Tipos de Dependente'},
+        ),
+    ]

sapl/parlamentares/models.py

@@ -1,11 +1,12 @@
 from datetime import datetime
 
+import reversion
 from django.db import models
 from django.utils.translation import ugettext_lazy as _
 from model_utils import Choices
-import reversion
 
 from sapl.base.models import Autor
+from sapl.decorators import vigencia_atual
 from sapl.utils import (INDICADOR_AFASTAMENTO, UF, YES_NO_CHOICES,
                         SaplGenericRelation, get_settings_auth_user_model,
                         intervalos_tem_intersecao,
@@ -28,14 +29,12 @@ class Legislatura(models.Model):
         current_year = datetime.now().year
         return self.data_inicio.year <= current_year <= self.data_fim.year
 
+    @vigencia_atual
     def __str__(self):
-        current = ' (%s)' % _('Atual') if self.atual() else ''
-
-        return _('%(numero)sª (%(start)s - %(end)s)%(current)s') % {
+        return _('%(numero)sª (%(start)s - %(end)s)') % {
             'numero': self.numero,
             'start': self.data_inicio.year,
-            'end': self.data_fim.year,
-            'current': current}
+            'end': self.data_fim.year}
 
 
 @reversion.register()
@@ -64,6 +63,7 @@ class SessaoLegislativa(models.Model):
         verbose_name_plural = _('Sessões Legislativas')
         ordering = ['-data_inicio', '-data_fim']
 
+    @vigencia_atual
     def __str__(self):
         return _('%(numero)sº (%(inicio)s - %(fim)s)') % {
             'numero': self.numero,
@@ -190,6 +190,7 @@ class SituacaoMilitar(models.Model):
     class Meta:
         verbose_name = _('Tipo Situação Militar')
         verbose_name_plural = _('Tipos Situações Militares')
+        ordering = ['descricao']
 
     def __str__(self):
         return self.descricao
@@ -360,6 +361,7 @@ class TipoDependente(models.Model):
     class Meta:
         verbose_name = _('Tipo de Dependente')
         verbose_name_plural = _('Tipos de Dependente')
+        ordering = ['descricao']
 
     def __str__(self):
         return self.descricao
@@ -432,6 +434,7 @@ class TipoAfastamento(models.Model):
     class Meta:
         verbose_name = _('Tipo de Afastamento')
         verbose_name_plural = _('Tipos de Afastamento')
+        ordering = ['descricao']
 
     def __str__(self):
         return self.descricao
@@ -554,8 +557,8 @@ class Frente(models.Model):
         ))
 
     class Meta:
-        verbose_name = _('Frente')
-        verbose_name_plural = _('Frentes')
+        verbose_name = _('Frente Parlamentar')
+        verbose_name_plural = _('Frentes Parlamentares')
 
     def get_parlamentares(self):
         return Parlamentar.objects.filter(ativo=True)
@@ -576,8 +579,8 @@ class Votante(models.Model):
         max_length=30, null=True, blank=True)
 
     class Meta:
-        verbose_name = _('Usuário')
-        verbose_name_plural = _('Usuários')
+        verbose_name = _('Usuário Votante')
+        verbose_name_plural = _('Usuários Votantes')
         permissions = (
             ('can_vote', _('Can Vote')),
         )

sapl/parlamentares/tests/test_parlamentares.py

@@ -1,7 +1,9 @@
 import pytest
 from django.core.urlresolvers import reverse
+from django.utils.translation import ugettext_lazy as _
 from model_mommy import mommy
 
+from sapl.parlamentares.forms import FrenteForm, LegislaturaForm, MandatoForm
 from sapl.parlamentares.models import (Dependente, Filiacao, Legislatura,
                                        Mandato, Parlamentar, Partido,
                                        TipoDependente)
@@ -94,11 +96,11 @@ def test_form_errors_dependente(admin_client):
         follow=True)
 
     assert (response.context_data['form'].errors['nome'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
     assert (response.context_data['form'].errors['tipo'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
     assert (response.context_data['form'].errors['sexo'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
 
 
 @pytest.mark.django_db(transaction=False)
@@ -112,9 +114,9 @@ def test_form_errors_filiacao(admin_client):
                                  follow=True)
 
     assert (response.context_data['form'].errors['partido'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
     assert (response.context_data['form'].errors['data'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
 
 
 @pytest.mark.django_db(transaction=False)
@@ -126,14 +128,13 @@ def test_mandato_submit(admin_client):
                               kwargs={'pk': 14}),
                       {'parlamentar': 14,  # hidden field
                        'legislatura': 5,
-                       'data_fim_mandato': '2016-01-01',
                        'data_expedicao_diploma': '2016-03-22',
                        'observacao': 'Observação do mandato',
                        'salvar': 'salvar'},
                       follow=True)
 
     mandato = Mandato.objects.first()
-    assert 'Observação do mandato' == mandato.observacao
+    assert str(_('Observação do mandato')) == str(_(mandato.observacao))
 
 
 @pytest.mark.django_db(transaction=False)
@@ -146,6 +147,141 @@ def test_form_errors_mandato(admin_client):
                                  follow=True)
 
     assert (response.context_data['form'].errors['legislatura'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
     assert (response.context_data['form'].errors['data_expedicao_diploma'] ==
-            ['Este campo é obrigatório.'])
+            [_('Este campo é obrigatório.')])
+
+
+def test_mandato_form_invalido():
+
+    form = MandatoForm(data={})
+
+    assert not form.is_valid()
+
+    errors = form.errors
+    assert errors['legislatura'] == [_('Este campo é obrigatório.')]
+    assert errors['parlamentar'] == [_('Este campo é obrigatório.')]
+    assert errors['data_expedicao_diploma'] == [_('Este campo é obrigatório.')]
+
+
+@pytest.mark.django_db(transaction=False)
+def test_mandato_form_duplicado():
+    parlamentar = mommy.make(Parlamentar, pk=1)
+    legislatura = mommy.make(Legislatura, pk=1)
+
+    Mandato.objects.create(parlamentar=parlamentar,
+                           legislatura=legislatura,
+                           data_expedicao_diploma='2017-07-25')
+
+    form = MandatoForm(data={
+        'parlamentar': str(parlamentar.pk),
+        'legislatura': str(legislatura.pk),
+        'data_expedicao_diploma': '01/07/2015'
+    })
+
+    assert not form.is_valid()
+
+    assert form.errors['__all__'] == [
+        _('Mandato nesta legislatura já existe.')]
+
+
+@pytest.mark.django_db(transaction=False)
+def test_mandato_form_datas_invalidas():
+    parlamentar = mommy.make(Parlamentar, pk=1)
+    legislatura = mommy.make(Legislatura, pk=1,
+                             data_inicio='2017-01-01',
+                             data_fim='2021-12-31')
+
+    form = MandatoForm(data={
+        'parlamentar': str(parlamentar.pk),
+        'legislatura': str(legislatura.pk),
+        'data_expedicao_diploma': '2016-11-01',
+        'data_inicio_mandato': '2016-12-12',
+        'data_fim_mandato': '2019-10-09'
+    })
+
+    assert not form.is_valid()
+    assert form.errors['__all__'] == \
+        ["Data início mandato fora do intervalo de legislatura informada"]
+
+    form = MandatoForm(data={
+        'parlamentar': str(parlamentar.pk),
+        'legislatura': str(legislatura.pk),
+        'data_expedicao_diploma': '2016-11-01',
+        'data_inicio_mandato': '2017-02-02',
+        'data_fim_mandato': '2022-01-01'
+    })
+
+    assert not form.is_valid()
+    assert form.errors['__all__'] == \
+        ["Data fim mandato fora do intervalo de legislatura informada"]
+
+
+def test_legislatura_form_invalido():
+
+    legislatura_form = LegislaturaForm(data={})
+
+    assert not legislatura_form.is_valid()
+
+    errors = legislatura_form.errors
+
+    errors['numero'] == [_('Este campo é obrigatório.')]
+    errors['data_inicio'] == [_('Este campo é obrigatório.')]
+    errors['data_fim'] == [_('Este campo é obrigatório.')]
+    errors['data_eleicao'] == [_('Este campo é obrigatório.')]
+
+    assert len(errors) == 4
+
+
+def test_legislatura_form_datas_invalidas():
+
+    legislatura_form = LegislaturaForm(data={'numero': '1',
+                                             'data_inicio': '2017-02-01',
+                                             'data_fim': '2021-12-31',
+                                             'data_eleicao': '2017-02-01'
+                                             })
+
+    assert not legislatura_form.is_valid()
+
+    expected = \
+        _("Data eleição não pode ser inferior a data início da legislatura")
+    assert legislatura_form.errors['__all__'] == [expected]
+
+    legislatura_form = LegislaturaForm(data={'numero': '1',
+                                             'data_inicio': '2017-02-01',
+                                             'data_fim': '2017-01-01',
+                                             'data_eleicao': '2016-11-01'
+                                             })
+
+    assert not legislatura_form.is_valid()
+
+    assert legislatura_form.errors['__all__'] == \
+        [_("Intervalo de início e fim inválido para legislatura.")]
+
+
+@pytest.mark.django_db(transaction=False)
+def test_valida_campos_obrigatorios_frente_form():
+    form = FrenteForm(data={})
+
+    assert not form.is_valid()
+
+    errors = form.errors
+
+    assert errors['nome'] == [_('Este campo é obrigatório.')]
+    assert errors['data_criacao'] == [_('Este campo é obrigatório.')]
+
+    assert len(errors) == 2
+
+
+@pytest.mark.django_db(transaction=False)
+def test_frente_form_valido():
+    parlamentares = mommy.make(Parlamentar)
+
+    form = FrenteForm(data={'nome': 'Nome da Frente',
+                            'parlamentar': str(parlamentares.pk),
+                            'data_criacao': '10/11/2017',
+                            'data_extincao': '10/12/2017',
+                            'descricao': 'teste'
+                            })
+
+    assert form.is_valid()

sapl/parlamentares/urls.py

@@ -5,8 +5,7 @@ from sapl.parlamentares.views import (CargoMesaCrud, ColigacaoCrud,
                                       FiliacaoCrud, FrenteCrud, FrenteList,
                                       LegislaturaCrud, MandatoCrud,
                                       MesaDiretoraView, NivelInstrucaoCrud,
-                                      ParlamentarCrud,
-                                      ParlamentarMateriasView,
+                                      ParlamentarCrud, ParlamentarMateriasView,
                                       ParticipacaoParlamentarCrud, PartidoCrud,
                                       ProposicaoParlamentarCrud,
                                       RelatoriaParlamentarCrud,

sapl/parlamentares/views.py

@@ -1,7 +1,12 @@
+import json
+from datetime import datetime
+
 from django.contrib import messages
+from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import MultipleObjectsReturned, ObjectDoesNotExist
 from django.core.urlresolvers import reverse, reverse_lazy
 from django.db.models import F, Q
+from django.db.models.aggregates import Count
 from django.http import JsonResponse
 from django.http.response import HttpResponseRedirect
 from django.templatetags.static import static
@@ -9,13 +14,16 @@ from django.utils.datastructures import MultiValueDictKeyError
 from django.utils.translation import ugettext_lazy as _
 from django.views.decorators.clickjacking import xframe_options_exempt
 from django.views.generic import FormView
+from django.views.generic.edit import UpdateView
 
+from sapl.base.models import Autor
 from sapl.comissoes.models import Participacao
 from sapl.crud.base import (RP_CHANGE, RP_DETAIL, RP_LIST, Crud, CrudAux,
                             CrudBaseForListAndDetailExternalAppView,
                             MasterDetailCrud)
-from sapl.materia.models import Proposicao, Relatoria
+from sapl.materia.models import Autoria, Proposicao, Relatoria
 from sapl.parlamentares.apps import AppConfig
+from sapl.utils import parlamentares_ativos
 
 from .forms import (FiliacaoForm, LegislaturaCreateForm, LegislaturaUpdateForm,
                     MandatoForm, ParlamentarCreateForm, ParlamentarForm,
@@ -25,15 +33,6 @@ from .models import (CargoMesa, Coligacao, ComposicaoColigacao, ComposicaoMesa,
                      NivelInstrucao, Parlamentar, Partido, SessaoLegislativa,
                      SituacaoMilitar, TipoAfastamento, TipoDependente, Votante)
 
-from sapl.base.models import Autor
-from sapl.materia.models import Autoria
-from django.contrib.contenttypes.models import ContentType
-from django.db.models.aggregates import Count
-
-import datetime
-import json
-
-
 CargoMesaCrud = CrudAux.build(CargoMesa, 'cargo_mesa')
 PartidoCrud = CrudAux.build(Partido, 'partidos')
 SessaoLegislativaCrud = CrudAux.build(SessaoLegislativa, 'sessao_legislativa')
@@ -67,8 +66,7 @@ class VotanteView(MasterDetailCrud):
 
         def delete(self, *args, **kwargs):
             obj = self.get_object()
-            if obj.user:
-                obj.user.delete()
+            obj.delete()
             return HttpResponseRedirect(
                 reverse('sapl.parlamentares:votante_list',
                         kwargs={'pk': obj.parlamentar.pk}))
@@ -189,7 +187,8 @@ class ColigacaoCrud(CrudAux):
         ordering = ('-numero_votos', 'nome')
 
         def get_context_data(self, **kwargs):
-            context = super(ColigacaoCrud.ListView, self).get_context_data(kwargs=kwargs)
+            context = super(ColigacaoCrud.ListView, self).get_context_data(
+                kwargs=kwargs)
             rows = context['rows']
             coluna_votos_recebidos = 2
             for row in rows:
@@ -201,15 +200,25 @@ class ColigacaoCrud(CrudAux):
     class DetailView(CrudAux.DetailView):
 
         def get_context_data(self, **kwargs):
-            context = super(ColigacaoCrud.DetailView, self).get_context_data(kwargs=kwargs)
+            context = super().get_context_data(kwargs=kwargs)
             coligacao = context['coligacao']
             if not coligacao.numero_votos:
                 coligacao.numero_votos = '0'
 
+            context['subnav_template_name'] = \
+                'parlamentares/subnav_coligacao.yaml'
+
             return context
 
-    class BaseMixin(CrudAux.BaseMixin):
-        subnav_template_name = 'parlamentares/subnav_coligacao.yaml'
+    class UpdateView(CrudAux.UpdateView):
+
+        def get_context_data(self, **kwargs):
+            context = super(UpdateView, self).get_context_data(kwargs=kwargs)
+
+            context['subnav_template_name'] = \
+                'parlamentares/subnav_coligacao.yaml'
+
+            return context
 
 
 def json_date_convert(date):
@@ -224,32 +233,6 @@ def json_date_convert(date):
                          year=int(ano))
 
 
-def parlamentares_ativos(data_inicio, data_fim=None):
-    '''
-    :param data_inicio: define a data de inicial do período desejado
-    :param data_fim: define a data final do período desejado
-    :return: queryset dos parlamentares ativos naquele período
-    '''
-    mandatos_ativos = Mandato.objects.filter(Q(
-        data_inicio_mandato__lte=data_inicio,
-        data_fim_mandato__isnull=True) | Q(
-        data_inicio_mandato__lte=data_inicio,
-        data_fim_mandato__gte=data_inicio))
-    if data_fim:
-        mandatos_ativos = mandatos_ativos | Mandato.objects.filter(
-            data_inicio_mandato__gte=data_inicio,
-            data_inicio_mandato__lte=data_fim)
-    else:
-        mandatos_ativos = mandatos_ativos | Mandato.objects.filter(
-            data_inicio_mandato__gte=data_inicio)
-
-    parlamentares_id = mandatos_ativos.values_list(
-        'parlamentar_id',
-        flat=True).distinct('parlamentar_id')
-
-    return Parlamentar.objects.filter(id__in=parlamentares_id)
-
-
 def frente_atualiza_lista_parlamentares(request):
     '''
     :param request: recebe os parâmetros do GET da chamada Ajax
@@ -295,6 +278,7 @@ class FrenteCrud(CrudAux):
     list_field_names = ['nome', 'data_criacao', 'parlamentares']
 
     class CreateView(CrudAux.CreateView):
+
         def get_context_data(self, **kwargs):
             context = super().get_context_data(**kwargs)
 
@@ -305,6 +289,7 @@ class FrenteCrud(CrudAux):
             return context
 
     class UpdateView(CrudAux.UpdateView):
+
         def get_context_data(self, **kwargs):
             context = super().get_context_data(**kwargs)
 
@@ -343,7 +328,6 @@ class MandatoCrud(MasterDetailCrud):
 
             return context
 
-
     class CreateView(MasterDetailCrud.CreateView):
         form_class = MandatoForm
 
@@ -388,6 +372,7 @@ class LegislaturaCrud(CrudAux):
         form_class = LegislaturaUpdateForm
 
     class DetailView(CrudAux.DetailView):
+
         def has_permission(self):
             return True
 
@@ -396,6 +381,7 @@ class LegislaturaCrud(CrudAux):
             return super().get(request, *args, **kwargs)
 
     class ListView(CrudAux.ListView):
+
         def has_permission(self):
             return True
 
@@ -671,17 +657,20 @@ class MesaDiretoraView(FormView):
                 not SessaoLegislativa.objects.exists()):
             return self.validation(request)
 
-        sessao = SessaoLegislativa.objects.filter(
-            legislatura=Legislatura.objects.first()).first(
-        )
+        legislatura = Legislatura.objects.first()
+        sessoes = SessaoLegislativa.objects.filter(
+            legislatura=legislatura).order_by("data_inicio")
+
+        year = datetime.now().year
+        sessao_atual = sessoes.filter(data_inicio__year=year).first()
 
-        mesa = sessao.composicaomesa_set.all() if sessao else []
+        mesa = sessao_atual.composicaomesa_set.all() if sessao_atual else []
 
         cargos_ocupados = [m.cargo for m in mesa]
         cargos = CargoMesa.objects.all()
         cargos_vagos = list(set(cargos) - set(cargos_ocupados))
 
-        parlamentares = Legislatura.objects.first().mandato_set.all()
+        parlamentares = legislatura.mandato_set.all()
         parlamentares_ocupados = [m.parlamentar for m in mesa]
         parlamentares_vagos = list(
             set(
@@ -696,11 +685,9 @@ class MesaDiretoraView(FormView):
         return self.render_to_response(
             {'legislaturas': Legislatura.objects.all(
             ).order_by('-numero'),
-                'legislatura_selecionada': Legislatura.objects.first(),
-                'sessoes': SessaoLegislativa.objects.filter(
-                legislatura=Legislatura.objects.first()),
-                'sessao_selecionada': SessaoLegislativa.objects.filter(
-                legislatura=Legislatura.objects.first()).first(),
+                'legislatura_selecionada': legislatura,
+                'sessoes': sessoes,
+                'sessao_selecionada': sessao_atual,
                 'composicao_mesa': mesa,
                 'parlamentares': parlamentares_vagos,
                 'cargos_vagos': cargos_vagos
@@ -714,7 +701,6 @@ def altera_field_mesa(request):
         operação (Legislatura/Sessão/Inclusão/Remoção),
         atualizando os campos após cada alteração
     """
-
     legislatura = request.GET['legislatura']
     sessoes = SessaoLegislativa.objects.filter(
         legislatura=legislatura).order_by('-data_inicio')
@@ -730,9 +716,11 @@ def altera_field_mesa(request):
     # Caso a mudança tenha sido no campo legislatura, a sessão
     # atual deve ser a primeira daquela legislatura
     else:
-        sessao_selecionada = SessaoLegislativa.objects.filter(
-            legislatura=legislatura).order_by(
-            '-data_inicio').first().id
+        year = datetime.now().year
+        try:
+            sessao_selecionada = sessoes.get(data_inicio__year=year).id
+        except ObjectDoesNotExist:
+            sessao_selecionada = sessoes.first().id
 
     # Atualiza os componentes da view após a mudança
     composicao_mesa = ComposicaoMesa.objects.filter(
@@ -895,6 +883,10 @@ def altera_field_mesa_public_view(request):
     # Caso a mudança tenha sido no campo legislatura, a sessão
     # atual deve ser a primeira daquela legislatura
     else:
+        try:
+            year = datetime.now().year
+            sessao_selecionada = sessoes.get(data_inicio__year=year).id
+        except ObjectDoesNotExist as e:
             sessao_selecionada = sessoes.first().id
 
     # Atualiza os componentes da view após a mudança

sapl/protocoloadm/forms.py

@@ -1,18 +1,19 @@
 from datetime import datetime
 
+import django_filters
 from crispy_forms.bootstrap import InlineRadios
 from crispy_forms.helper import FormHelper
-from crispy_forms.layout import HTML, Button, Fieldset, Layout, Submit
+from crispy_forms.layout import HTML, Button, Fieldset, Layout
 from django import forms
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.db import models
 from django.forms import ModelForm
 from django.utils.translation import ugettext_lazy as _
-import django_filters
 
 from sapl.base.models import Autor, TipoAutor
-from sapl.crispy_layout_mixin import form_actions, to_row
-from sapl.materia.models import MateriaLegislativa, TipoMateriaLegislativa, UnidadeTramitacao
+from sapl.crispy_layout_mixin import SaplFormLayout, form_actions, to_row
+from sapl.materia.models import (MateriaLegislativa, TipoMateriaLegislativa,
+                                 UnidadeTramitacao)
 from sapl.utils import (RANGE_ANOS, AnoNumeroOrderingFilter,
                         RangeWidgetOverride, autor_label, autor_modal)
 
@@ -20,7 +21,6 @@ from .models import (DocumentoAcessorioAdministrativo, DocumentoAdministrativo,
                      Protocolo, TipoDocumentoAdministrativo,
                      TramitacaoAdministrativo)
 
-
 TIPOS_PROTOCOLO = [('0', 'Recebido'), ('1', 'Enviado'), ('', 'Ambos')]
 TIPOS_PROTOCOLO_CREATE = [('0', 'Recebido'), ('1', 'Enviado')]
 
@@ -116,7 +116,7 @@ class ProtocoloFilterSet(django_filters.FilterSet):
         self.form.helper = FormHelper()
         self.form.helper.form_method = 'GET'
         self.form.helper.layout = Layout(
-            Fieldset('',
+            Fieldset(_('Pesquisar Protocolo'),
                      row1, row2,
                      row3,
                      HTML(autor_label),
@@ -218,13 +218,12 @@ class AnularProcoloAdmForm(ModelForm):
 
         cleaned_data = super(AnularProcoloAdmForm, self).clean()
 
-        numero = cleaned_data.get("numero")
-        ano = cleaned_data.get("ano")
+        if not self.is_valid():
+            return cleaned_data
+
+        numero = cleaned_data['numero']
+        ano = cleaned_data['ano']
 
-        # se não inserido numero ou ano não prosseguir
-        # (e ele vai falhar pq numero e ano são obrigatórios)
-        if not numero or not ano:
-            return
         try:
             protocolo = Protocolo.objects.get(numero=numero, ano=ano)
             if protocolo.anulado:
@@ -234,6 +233,7 @@ class AnularProcoloAdmForm(ModelForm):
         except ObjectDoesNotExist:
             raise forms.ValidationError(
                 _("Protocolo %s/%s não existe" % (numero, ano)))
+
         exists = False
         if protocolo.tipo_materia:
             exists = MateriaLegislativa.objects.filter(
@@ -566,18 +566,24 @@ class DocumentoAdministrativoForm(ModelForm):
     def clean(self):
         super(DocumentoAdministrativoForm, self).clean()
 
-        numero_protocolo = self.data['numero_protocolo']
-        ano_protocolo = self.data['ano_protocolo']
+        cleaned_data = self.cleaned_data
 
+        if not self.is_valid():
+            return cleaned_data
+
+        numero_protocolo = cleaned_data['numero_protocolo']
+        ano_protocolo = cleaned_data['ano_protocolo']
+
+        # campos opcionais, mas que se informados devem ser válidos
         if numero_protocolo and ano_protocolo:
             try:
                 self.fields['protocolo'].initial = Protocolo.objects.get(
                     numero=numero_protocolo,
                     ano=ano_protocolo).pk
             except ObjectDoesNotExist:
-                msg = _('Protocolo %s/%s inexistente' % (
+                msg = _('Protocolo %s/%s inexistente.' % (
                     numero_protocolo, ano_protocolo))
-                raise ValidationError(str(msg))
+                raise ValidationError(msg)
 
         return self.cleaned_data
 
@@ -615,12 +621,10 @@ class DocumentoAdministrativoForm(ModelForm):
             [('observacao', 12)])
 
         self.helper = FormHelper()
-        self.helper.layout = Layout(
+        self.helper.layout = SaplFormLayout(
             Fieldset(_('Identificação Básica'),
                      row1, row2, row3, row4, row5),
             Fieldset(_('Outras Informações'),
-                     row6, row7),
-            form_actions(more=[Submit('Excluir', 'Excluir')]),
-        )
+                     row6, row7))
         super(DocumentoAdministrativoForm, self).__init__(
             *args, **kwargs)

sapl/protocoloadm/tests/test_protocoloadm.py

@@ -7,10 +7,14 @@ from django.utils.translation import ugettext_lazy as _
 from model_mommy import mommy
 
 from sapl.materia.models import UnidadeTramitacao
-from sapl.protocoloadm.forms import AnularProcoloAdmForm
+from sapl.protocoloadm.forms import (AnularProcoloAdmForm,
+                                     DocumentoAdministrativoForm,
+                                     MateriaLegislativa, ProtocoloDocumentForm,
+                                     ProtocoloMateriaForm)
 from sapl.protocoloadm.models import (DocumentoAdministrativo, Protocolo,
                                       StatusTramitacaoAdministrativo,
                                       TipoDocumentoAdministrativo,
+                                      TipoMateriaLegislativa,
                                       TramitacaoAdministrativo)
 
 
@@ -250,3 +254,163 @@ def test_create_tramitacao(admin_client):
     tramitacao = TramitacaoAdministrativo.objects.last()
     # Verifica se a tramitacao que obedece as regras de negócios é criada
     assert tramitacao.data_tramitacao == datetime.date(2016, 8, 21)
+
+
+@pytest.mark.django_db(transaction=False)
+def test_anular_protocolo_dados_invalidos():
+
+    form = AnularProcoloAdmForm(data={})
+
+    assert not form.is_valid()
+
+    errors = form.errors
+
+    assert errors['numero'] == [_('Este campo é obrigatório.')]
+    assert errors['ano'] == [_('Este campo é obrigatório.')]
+    assert errors['justificativa_anulacao'] == [_('Este campo é obrigatório.')]
+
+    assert len(errors) == 3
+
+
+@pytest.mark.django_db(transaction=False)
+def test_anular_protocolo_form_anula_protocolo_inexistente():
+    form = AnularProcoloAdmForm(data={'numero': '1',
+                                      'ano': '2017',
+                                      'justificativa_anulacao': 'teste'
+                                      })
+
+    assert not form.is_valid()
+
+    assert form.errors['__all__'] == [_(
+        'Protocolo 1/2017 não existe')]
+
+
+@pytest.mark.django_db(transaction=False)
+def test_anular_protocolo_form_anula_protocolo_anulado():
+    mommy.make(Protocolo, numero=1, ano=2017, anulado=True)
+
+    form = AnularProcoloAdmForm(data={'numero': '1',
+                                      'ano': '2017',
+                                      'justificativa_anulacao': 'teste'
+                                      })
+
+    assert not form.is_valid()
+
+    assert form.errors['__all__'] == [_(
+        'Protocolo 1/2017 já encontra-se anulado')]
+
+
+@pytest.mark.django_db(transaction=False)
+def test_anular_protocolo_form_anula_protocolo_com_doc_vinculado():
+    tipo_materia = mommy.make(TipoMateriaLegislativa)
+
+    mommy.make(Protocolo,
+               numero=1,
+               ano=2017,
+               tipo_materia=tipo_materia,
+               anulado=False)
+
+    mommy.make(MateriaLegislativa,
+               ano=2017,
+               numero_protocolo=1)
+
+    form = AnularProcoloAdmForm(data={'numero': '1',
+                                      'ano': '2017',
+                                      'justificativa_anulacao': 'teste'
+                                      })
+
+    assert not form.is_valid()
+
+    assert form.errors['__all__'] == \
+        [_("Protocolo 1/2017 não pode ser removido pois existem "
+           "documentos vinculados a ele.")]
+
+    tipo_documento = mommy.make(TipoDocumentoAdministrativo)
+
+    protocolo_documento = mommy.make(Protocolo,
+                                     numero=2,
+                                     ano=2017,
+                                     tipo_documento=tipo_documento,
+                                     anulado=False)
+
+    mommy.make(DocumentoAdministrativo,
+               protocolo=protocolo_documento)
+
+    form = AnularProcoloAdmForm(data={'numero': '2',
+                                      'ano': '2017',
+                                      'justificativa_anulacao': 'teste'
+                                      })
+
+    assert not form.is_valid()
+
+    assert form.errors['__all__'] == \
+        [_("Protocolo 2/2017 não pode ser removido pois existem "
+           "documentos vinculados a ele.")]
+
+
+def test_documento_administrativo_invalido():
+    form = DocumentoAdministrativoForm(data={})
+
+    assert not form.is_valid()
+
+    errors = form.errors
+    assert errors['ano'] == [_('Este campo é obrigatório.')]
+    assert errors['tipo'] == [_('Este campo é obrigatório.')]
+    assert errors['assunto'] == [_('Este campo é obrigatório.')]
+    assert errors['numero'] == [_('Este campo é obrigatório.')]
+    assert errors['data'] == [_('Este campo é obrigatório.')]
+
+    assert len(errors) == 5
+
+
+@pytest.mark.django_db(transaction=False)
+def test_documento_administrativo_protocolo_inexistente():
+
+    tipo = mommy.make(TipoDocumentoAdministrativo)
+
+    form = DocumentoAdministrativoForm(data={'ano': '2017',
+                                             'tipo': str(tipo.pk),
+                                             'assunto': 'teste',
+                                             'numero': '1',
+                                             'data': '2017-10-10',
+                                             'numero_protocolo': '11',
+                                             'ano_protocolo': '2017'
+                                             })
+
+    assert not form.is_valid()
+
+    assert form.errors['__all__'] == [_('Protocolo 11/2017 inexistente.')]
+
+
+def test_protocolo_documento_form_invalido():
+
+    form = ProtocoloDocumentForm(data={})
+
+    assert not form.is_valid()
+
+    errors = form.errors
+
+    assert errors['tipo_protocolo'] == [_('Este campo é obrigatório.')]
+    assert errors['interessado'] == [_('Este campo é obrigatório.')]
+    assert errors['tipo_documento'] == [_('Este campo é obrigatório.')]
+    assert errors['numero_paginas'] == [_('Este campo é obrigatório.')]
+    assert errors['assunto'] == [_('Este campo é obrigatório.')]
+
+    assert len(errors) == 5
+
+
+def test_protocolo_materia_invalido():
+
+    form = ProtocoloMateriaForm(data={})
+
+    assert not form.is_valid()
+
+    errors = form.errors
+
+    assert errors['assunto_ementa'] == [_('Este campo é obrigatório.')]
+    assert errors['tipo_autor'] == [_('Este campo é obrigatório.')]
+    assert errors['tipo_materia'] == [_('Este campo é obrigatório.')]
+    assert errors['numero_paginas'] == [_('Este campo é obrigatório.')]
+    assert errors['autor'] == [_('Este campo é obrigatório.')]
+
+    assert len(errors) == 5

sapl/protocoloadm/views.py

@@ -1,25 +1,26 @@
 from datetime import date, datetime
 
-
 from braces.views import FormValidMessageMixin
 from django.contrib import messages
 from django.contrib.auth.mixins import PermissionRequiredMixin
-from django.db.models import Q
+from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
-from django.db.models import Max
-from django.http import (Http404, HttpResponse, HttpResponseRedirect,
-                         JsonResponse)
+from django.db.models import Max, Q
+from django.http import Http404, HttpResponse, JsonResponse
 from django.shortcuts import redirect
 from django.utils.translation import ugettext_lazy as _
-from django.views.generic import CreateView, DetailView, FormView, ListView
-from django.views.generic.base import TemplateView
+from django.views.generic import CreateView, ListView
+from django.views.generic.base import RedirectView, TemplateView
 from django_filters.views import FilterView
 
 import sapl
 from sapl.base.models import Autor
+from sapl.comissoes.models import Comissao
 from sapl.crud.base import Crud, CrudAux, MasterDetailCrud, make_pagination
 from sapl.materia.models import MateriaLegislativa, TipoMateriaLegislativa
+from sapl.parlamentares.models import Legislatura, Parlamentar
+from sapl.protocoloadm.models import Protocolo
 from sapl.utils import create_barcode, get_client_ip
 
 from .forms import (AnularProcoloAdmForm, DocumentoAcessorioAdministrativoForm,
@@ -28,12 +29,8 @@ from .forms import (AnularProcoloAdmForm, DocumentoAcessorioAdministrativoForm,
                     ProtocoloFilterSet, ProtocoloMateriaForm,
                     TramitacaoAdmEditForm, TramitacaoAdmForm)
 from .models import (DocumentoAcessorioAdministrativo, DocumentoAdministrativo,
-                     Protocolo, StatusTramitacaoAdministrativo,
+                     StatusTramitacaoAdministrativo,
                      TipoDocumentoAdministrativo, TramitacaoAdministrativo)
-from sapl.parlamentares.models import Parlamentar
-from sapl.protocoloadm.models import Protocolo
-from sapl.comissoes.models import Comissao
-from django.contrib.contenttypes.models import ContentType
 
 TipoDocumentoAdministrativoCrud = CrudAux.build(
     TipoDocumentoAdministrativo, '')
@@ -102,14 +99,21 @@ class DocumentoAdministrativoCrud(Crud):
         def list_url(self):
             return ''
 
-    class ListView(DocumentoAdministrativoMixin, Crud.ListView):
-        pass
+    class ListView(RedirectView, DocumentoAdministrativoMixin, Crud.ListView):
 
-    class CreateView(DocumentoAdministrativoMixin, Crud.CreateView):
+        def get_redirect_url(self, *args, **kwargs):
+            namespace = self.model._meta.app_config.name
+            return reverse('%s:%s' % (namespace, 'pesq_doc_adm'))
+
+    class CreateView(Crud.CreateView):
         form_class = DocumentoAdministrativoForm
         layout_key = None
 
-    class UpdateView(DocumentoAdministrativoMixin, Crud.UpdateView):
+        @property
+        def cancel_url(self):
+            return self.search_url
+
+    class UpdateView(Crud.UpdateView):
         form_class = DocumentoAdministrativoForm
         layout_key = None
 
@@ -120,6 +124,7 @@ class DocumentoAdministrativoCrud(Crud):
                         'numero_protocolo': p.numero}
 
     class DetailView(DocumentoAdministrativoMixin, Crud.DetailView):
+
         def get_context_data(self, **kwargs):
             context = super().get_context_data(**kwargs)
             self.layout_display[0]['rows'][-1][0]['text'] = (
@@ -128,9 +133,10 @@ class DocumentoAdministrativoCrud(Crud):
                     kwargs={'pk': self.object.pk}))
             return context
 
-    class DeleteView(DocumentoAdministrativoMixin, Crud.DeleteView):
+    class DeleteView(Crud.DeleteView):
+
         def get_success_url(self):
-            return reverse('sapl.protocoloadm:pesq_doc_adm', kwargs={})
+            return self.search_url
 
 
 class StatusTramitacaoAdministrativoCrud(CrudAux):
@@ -178,7 +184,7 @@ class ProtocoloPesquisaView(PermissionRequiredMixin, FilterView):
         context['page_range'] = make_pagination(
             page_obj.number, paginator.num_pages)
 
-        context['title'] = _('Pesquisa de Protocolos')
+        context['title'] = _('Protocolo')
 
         return context
 
@@ -287,6 +293,13 @@ class ProtocoloDocumentoView(PermissionRequiredMixin,
         if numeracao == 'A':
             numero = Protocolo.objects.filter(
                 ano=date.today().year).aggregate(Max('numero'))
+        elif numeracao == 'L':
+            legislatura = Legislatura.objects.last()
+            data_inicio = legislatura.data_inicio
+            data_fim = legislatura.data_fim
+            numero = Protocolo.objects.filter(
+                data__gte=data_inicio, data__lte=data_fim).aggregate(
+                    Max('numero'))
         elif numeracao == 'U':
             numero = Protocolo.objects.all().aggregate(Max('numero'))
 
@@ -458,14 +471,20 @@ class ProtocoloMateriaView(PermissionRequiredMixin, CreateView):
         return context
 
     def autores_ativos(self):
-            lista_parlamentares = Parlamentar.objects.filter(ativo=True).values_list('id', flat=True)
+        lista_parlamentares = Parlamentar.objects.filter(
+            ativo=True).values_list('id', flat=True)
         model_parlamentar = ContentType.objects.get_for_model(Parlamentar)
-            autor_parlamentar = Autor.objects.filter(content_type=model_parlamentar, object_id__in=lista_parlamentares)
+        autor_parlamentar = Autor.objects.filter(
+            content_type=model_parlamentar, object_id__in=lista_parlamentares)
 
-            lista_comissoes = Comissao.objects.filter(Q(data_extincao__isnull=True)|Q(data_extincao__gt=date.today())).values_list('id', flat=True)
+        lista_comissoes = Comissao.objects.filter(Q(
+            data_extincao__isnull=True) | Q(
+            data_extincao__gt=date.today())).values_list('id', flat=True)
         model_comissao = ContentType.objects.get_for_model(Comissao)
-            autor_comissoes = Autor.objects.filter(content_type=model_comissao, object_id__in=lista_comissoes)
-            autores_outros = Autor.objects.exclude(content_type__in=[model_parlamentar, model_comissao])
+        autor_comissoes = Autor.objects.filter(
+            content_type=model_comissao, object_id__in=lista_comissoes)
+        autores_outros = Autor.objects.exclude(
+            content_type__in=[model_parlamentar, model_comissao])
         q = autor_parlamentar | autor_comissoes | autores_outros
         return q
 

sapl/redireciona_urls/tests.py

@@ -6,6 +6,7 @@ EMPTY_STRING = ''
 
 
 class RedirecionaURLsTests(TestCase):
+
     def test_redireciona_index_SAPL(self):
         response = self.client.get(reverse(
             'sapl.redireciona_urls:redireciona_sapl_index')

sapl/redireciona_urls/urls.py

@@ -1,24 +1,18 @@
+from django.conf.urls import url
+
 from .apps import AppConfig
-from .views import (
-    RedirecionaAtasList,
-    RedirecionaComissao,
+from .views import (RedirecionaAtasList, RedirecionaComissao,
                     RedirecionaHistoricoTramitacoesList,
                     RedirecionaMateriaLegislativaDetail,
                     RedirecionaMateriaLegislativaList,
                     RedirecionaMateriasPorAnoAutorTipo,
-    RedirecionaMateriasPorAutor,
-    RedirecionaMesaDiretoraView,
+                    RedirecionaMateriasPorAutor, RedirecionaMesaDiretoraView,
                     RedirecionaNormasJuridicasDetail,
-    RedirecionaNormasJuridicasList,
-    RedirecionaParlamentar,
-    RedirecionaPautaSessao,
-    RedirecionaPresencaParlamentares,
+                    RedirecionaNormasJuridicasList, RedirecionaParlamentar,
+                    RedirecionaPautaSessao, RedirecionaPresencaParlamentares,
                     RedirecionaRelatoriosList,
                     RedirecionaRelatoriosMateriasEmTramitacaoList,
-    RedirecionaSessaoPlenaria,
-    RedirecionaSAPLIndex)
-from django.conf.urls import url
-
+                    RedirecionaSAPLIndex, RedirecionaSessaoPlenaria)
 
 app_name = AppConfig.name
 

sapl/redireciona_urls/views.py

@@ -1,17 +1,19 @@
-from .exceptions import UnknownUrlNameError
 from django.core.urlresolvers import NoReverseMatch, reverse
 from django.views.generic import RedirectView
+
 from sapl.base.apps import AppConfig as atasConfig
-from sapl.base.apps import AppConfig as presenca_sessaoConfig
-from sapl.base.apps import AppConfig as relatoriosConfig
 from sapl.comissoes.apps import AppConfig as comissoesConfig
 from sapl.materia.apps import AppConfig as materiaConfig
 from sapl.norma.apps import AppConfig as normaConfig
 from sapl.parlamentares.apps import AppConfig as parlamentaresConfig
 from sapl.sessao.apps import AppConfig as sessaoConfig
 
+from .exceptions import UnknownUrlNameError
+
 EMPTY_STRING = ''
 
+presenca_sessaoConfig = relatoriosConfig = atasConfig
+
 app_parlamentares = parlamentaresConfig.name
 app_atas = atasConfig.name
 app_presenca_sessao = presenca_sessaoConfig.name
@@ -50,7 +52,6 @@ relatorio_materia_por_ano_autor_tipo = (
 historico_tramitacoes = (app_relatorios + ':historico_tramitacoes')
 
 
-
 def has_iframe(url, request):
 
     iframe = request.GET.get(

sapl/relatorios/templates/pdf_capa_processo_preparar_pysc.py

@@ -11,7 +11,8 @@ casa={}
 aux = context.sapl_documentos.props_sapl.propertyItems()
 for item in aux:
     casa[item[0]] = item[1]
-localidade=context.zsql.localidade_obter_zsql(cod_localidade=casa["cod_localidade"])
+localidade = context.zsql.localidade_obter_zsql(
+    cod_localidade=casa["cod_localidade"])
 if len(casa["num_cep"]) == 8:
     cep = casa["num_cep"][:4] + "-" + casa["num_cep"][5:]
 else:
@@ -23,7 +24,8 @@ if cep!="":
         linha1 = linha1 + " - "
     linha1 = linha1 + "CEP " + cep
 if localidade[0].nom_localidade != "" and localidade[0].nom_localidade != None:
-  linha1 = linha1 + " - "+localidade[0].nom_localidade+" "+localidade[0].sgl_uf
+    linha1 = linha1 + " - " + \
+        localidade[0].nom_localidade + " " + localidade[0].sgl_uf
 if casa["num_tel"] != "" and casa["num_tel"] != None:
     linha1 = linha1 + " Tel.: " + casa["num_tel"]
 
@@ -57,10 +59,14 @@ else:
 protocolos = []
 REQUEST = context.REQUEST
 for protocolo in context.zsql.protocolo_pesquisar_zsql(tip_protocolo=REQUEST['rad_tip_protocolo'],
-                              cod_protocolo=REQUEST['txt_num_protocolo'], ano_protocolo=REQUEST['txt_ano_protocolo'],
-                              tip_documento=REQUEST['lst_tip_documento'], tip_processo=REQUEST['rad_tip_processo'], 
-                              tip_materia=REQUEST['lst_tip_materia'], des_assunto=REQUEST['txt_assunto'], 
-                              cod_autor=REQUEST['hdn_cod_autor'], des_interessado=REQUEST['txa_txt_interessado'], 
+                                                       cod_protocolo=REQUEST['txt_num_protocolo'], ano_protocolo=REQUEST[
+                                                           'txt_ano_protocolo'],
+                                                       tip_documento=REQUEST['lst_tip_documento'], tip_processo=REQUEST[
+                                                           'rad_tip_processo'],
+                                                       tip_materia=REQUEST[
+                                                           'lst_tip_materia'], des_assunto=REQUEST['txt_assunto'],
+                                                       cod_autor=REQUEST['hdn_cod_autor'], des_interessado=REQUEST[
+    'txa_txt_interessado'],
         dat_apres=REQUEST['dt_apres'], dat_apres2=REQUEST['dt_apres2']):
     dic = {}
 
@@ -68,7 +74,8 @@ for protocolo in context.zsql.protocolo_pesquisar_zsql(tip_protocolo=REQUEST['ra
 
     dic['ano'] = str(protocolo.ano_protocolo)
 
-        dic['data']=context.pysc.iso_to_port_pysc(protocolo.dat_protocolo)+' - '+protocolo.hor_protocolo
+    dic['data'] = context.pysc.iso_to_port_pysc(
+        protocolo.dat_protocolo) + ' - ' + protocolo.hor_protocolo
 
     dic['txt_assunto'] = protocolo.txt_assunto_ementa
 
@@ -100,18 +107,21 @@ for protocolo in context.zsql.protocolo_pesquisar_zsql(tip_protocolo=REQUEST['ra
 
     dic['num_materia'] = ''
     for materia in context.zsql.materia_obter_zsql(num_protocolo=protocolo.cod_protocolo, ano_ident_basica=protocolo.ano_protocolo):
-               dic['num_materia']=str(materia.num_ident_basica)+'/'+ str(materia.ano_ident_basica)
+        dic['num_materia'] = str(materia.num_ident_basica) + \
+            '/' + str(materia.ano_ident_basica)
 
     dic['num_documento'] = ''
     for documento in context.zsql.documento_administrativo_obter_zsql(num_protocolo=protocolo.cod_protocolo):
-               dic['num_documento']=str(documento.num_documento)+'/'+ str(documento.ano_documento)
+        dic['num_documento'] = str(
+            documento.num_documento) + '/' + str(documento.ano_documento)
 
     dic['num_processo'] = dic['num_materia'] or dic['num_documento']
 
     dic['numeracao'] = ''
     for materia_num in context.zsql.materia_obter_zsql(num_protocolo=protocolo.cod_protocolo, ano_ident_basica=protocolo.ano_protocolo):
         for numera in context.zsql.numeracao_obter_zsql(cod_materia=materia_num.cod_materia, ind_excluido=0):
-               dic['numeracao']='PROCESSO N° ' +str(numera.num_materia)+'/'+ str(numera.ano_materia)
+            dic['numeracao'] = 'PROCESSO N° ' + \
+                str(numera.num_materia) + '/' + str(numera.ano_materia)
 
     dic['anulado'] = ''
     if protocolo.ind_anulado == 1:
@@ -131,7 +141,8 @@ filtro['autor']=REQUEST.hdn_cod_autor
 filtro['interessado'] = REQUEST.txa_txt_interessado
 
 sessao = session.id
-caminho = context.pdf_capa_processo_gerar(sessao,imagem,data,protocolos,cabecalho,rodape,filtro)
+caminho = context.pdf_capa_processo_gerar(
+    sessao, imagem, data, protocolos, cabecalho, rodape, filtro)
 if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:

sapl/relatorios/templates/pdf_detalhe_materia_gerar.py

@@ -21,17 +21,21 @@ def cabecalho(dic_inf_basicas,imagem):
     tmp += '\t\t\t\t<lines>2cm 24.5cm 19cm 24.5cm</lines>\n'
     if dic_inf_basicas['nom_camara'] != "" and dic_inf_basicas['nom_camara'] != None:
         tmp += '\t\t\t\t<setFont name="Helvetica" size="16"/>\n'
-        tmp+='\t\t\t\t<drawString x="5cm" y="27.2cm">' + dic_inf_basicas['nom_camara'] + '</drawString>\n'
+        tmp += '\t\t\t\t<drawString x="5cm" y="27.2cm">' + \
+            dic_inf_basicas['nom_camara'] + '</drawString>\n'
     tmp += '\t\t\t\t<setFont name="Helvetica" size="14"/>\n'
     tmp += '\t\t\t\t<drawString x="5cm" y="26.5cm">Sistema de Apoio ao Processo Legislativo</drawString>\n'
     if str(dic_inf_basicas['nom_projeto']) != "" and str(dic_inf_basicas['nom_projeto']) != None:
         tmp += '\t\t\t\t<setFont name="Helvetica" size="15"/>\n'
-        tmp+='\t\t\t\t<drawCentredString x="10.5cm" y="25.2cm">' + str(dic_inf_basicas['nom_projeto']) + '</drawCentredString>\n'
+        tmp += '\t\t\t\t<drawCentredString x="10.5cm" y="25.2cm">' + \
+            str(dic_inf_basicas['nom_projeto']) + '</drawCentredString>\n'
     if str(dic_inf_basicas['cod_projeto']) != "" and str(dic_inf_basicas['cod_projeto']) != None:
         tmp += '\t\t\t\t<setFont name="Helvetica" size="15"/>\n'
-        tmp+='\t\t\t\t<drawCentredString x="10.5cm" y="24.7cm">' + str(dic_inf_basicas['cod_projeto']) + '</drawCentredString>\n'
+        tmp += '\t\t\t\t<drawCentredString x="10.5cm" y="24.7cm">' + \
+            str(dic_inf_basicas['cod_projeto']) + '</drawCentredString>\n'
     return tmp
 
+
 def rodape(dic_rodape):
     """
     Função que gera o codigo rml do rodape da pagina.
@@ -60,11 +64,14 @@ def rodape(dic_rodape):
     tmp += '\t\t\t\t<setFont name="Helvetica" size="8"/>\n'
     tmp += '\t\t\t\t<drawString x="2cm" y="3.3cm">' + data_emissao + '</drawString>\n'
     tmp += '\t\t\t\t<drawString x="17.9cm" y="3.3cm">Página <pageNumber/></drawString>\n'
-    tmp+='\t\t\t\t<drawCentredString x="10.5cm" y="2.7cm">' + linha1 + '</drawCentredString>\n'
-    tmp+='\t\t\t\t<drawCentredString x="10.5cm" y="2.3cm">' + linha2 + '</drawCentredString>\n'
+    tmp += '\t\t\t\t<drawCentredString x="10.5cm" y="2.7cm">' + \
+        linha1 + '</drawCentredString>\n'
+    tmp += '\t\t\t\t<drawCentredString x="10.5cm" y="2.3cm">' + \
+        linha2 + '</drawCentredString>\n'
 
     return tmp
 
+
 def paraStyle():
     """Função que gera o código rml que define o estilo dos parágrafos"""
 
@@ -86,6 +93,7 @@ def paraStyle():
 
     return tmp
 
+
 def inf_basicas(dic_inf_basicas):
     """
     Função que gera o código rml das funções básicas do relatório
@@ -95,15 +103,18 @@ def inf_basicas(dic_inf_basicas):
     # Texto do projeto
     texto_projeto = str(dic_inf_basicas['texto_projeto'])
     if texto_projeto != "" and texto_projeto != None:
-        tmp+='\t\t<para style="texto_projeto">' + texto_projeto.replace('&','&amp;') + '</para>\n'
+        tmp += '\t\t<para style="texto_projeto">' + \
+            texto_projeto.replace('&', '&amp;') + '</para>\n'
 
     # início das informações básicas
     tmp += '\t\t<para style="P1">Informações Básicas</para>\n'
     if str(dic_inf_basicas['apresentada']) != "" and str(dic_inf_basicas['apresentada']) != None:
-        tmp+='\t\t<para style="P2"><b>Apresentada em: </b> ' + str(dic_inf_basicas['apresentada']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Apresentada em: </b> ' + \
+            str(dic_inf_basicas['apresentada']) + '</para>\n'
 
     if str(dic_inf_basicas['formato']) != "" and str(dic_inf_basicas['formato']) != None:
-        tmp+='\t\t<para style="P2"><b>Formato: </b> ' + str(dic_inf_basicas['formato']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Formato: </b> ' + \
+            str(dic_inf_basicas['formato']) + '</para>\n'
 
     if dic_inf_basicas['publicada'] == 0:
         tmp += '\t\t<para style="P2"><b>Publicada:</b> Não</para>\n'
@@ -111,7 +122,8 @@ def inf_basicas(dic_inf_basicas):
         tmp += '\t\t<para style="P2"><b>Publicada:</b> Sim</para>\n'
 
     if str(dic_inf_basicas['objeto']) != "" and str(dic_inf_basicas['objeto']) != None:
-        tmp+='\t\t<para style="P2"><b>Objeto: </b> ' + str(dic_inf_basicas['objeto']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Objeto: </b> ' + \
+            str(dic_inf_basicas['objeto']) + '</para>\n'
 
     if dic_inf_basicas['tramitacao'] == 0:
         tmp += '\t\t<para style="P2"><b>Tramitação:</b> Não</para>\n'
@@ -119,13 +131,16 @@ def inf_basicas(dic_inf_basicas):
         tmp += '\t\t<para style="P2"><b>Tramitação:</b> Sim</para>\n'
 
     if str(dic_inf_basicas['reg_tramitacao']) != "" and str(dic_inf_basicas['reg_tramitacao']) != None:
-        tmp+='\t\t<para style="P2"><b>Regime: </b> ' + str(dic_inf_basicas['reg_tramitacao']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Regime: </b> ' + \
+            str(dic_inf_basicas['reg_tramitacao']) + '</para>\n'
 
     if str(dic_inf_basicas['prazo']) != "" and str(dic_inf_basicas['prazo']) != None:
-        tmp+='\t\t<para style="P2"><b>Dias de prazo: </b> ' + str(dic_inf_basicas['prazo']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Dias de prazo: </b> ' + \
+            str(dic_inf_basicas['prazo']) + '</para>\n'
 
     if str(dic_inf_basicas['fim_prazo']) != "" and str(dic_inf_basicas['fim_prazo']) != None:
-        tmp+='\t\t<para style="P2"><b>Data do fim do prazo: </b> ' + str(dic_inf_basicas['fim_prazo']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Data do fim do prazo: </b> ' + \
+            str(dic_inf_basicas['fim_prazo']) + '</para>\n'
 
     if dic_inf_basicas['mat_complementar'] == 0:
         tmp += '\t\t<para style="P2"><b>Matéria Complementar:</b> Não</para>\n'
@@ -139,18 +154,22 @@ def inf_basicas(dic_inf_basicas):
 
     apelido = dic_inf_basicas['apelido']
     if apelido != "" and apelido != None:
-        tmp+='\t\t<para style="P2"><b>Apelido: </b> ' + apelido.replace('&','&amp;') + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Apelido: </b> ' + \
+            apelido.replace('&', '&amp;') + '</para>\n'
 
     indexacao = dic_inf_basicas['indexacao']
     if indexacao != "" and indexacao != None:
-        tmp+='\t\t<para style="P2"><b>Indexação: </b> ' + indexacao.replace('&','&amp;') + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Indexação: </b> ' + \
+            indexacao.replace('&', '&amp;') + '</para>\n'
 
     observacao = dic_inf_basicas['observacao']
     if observacao != "" and observacao != None:
-        tmp+='\t\t<para style="P2"><b>Observação: </b> ' + observacao.replace('&','&amp;') + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Observação: </b> ' + \
+            observacao.replace('&', '&amp;') + '</para>\n'
 
     return tmp
 
+
 def orig_externa(dic_orig_externa):
     """
     Função que gera o código rml da origem externa
@@ -160,46 +179,60 @@ def orig_externa(dic_orig_externa):
     tmp += '\t\t<para style="P1">Origem Externa</para>\n'
     try:
         if dic_orig_externa['local'] != "" and dic_orig_externa['local'] != None:
-            tmp+='\t\t<para style="P2"><b>Local:</b> ' + dic_orig_externa['local'] + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Local:</b> ' + \
+                dic_orig_externa['local'] + '</para>\n'
 
         if dic_orig_externa['data'] != "" and dic_orig_externa['data'] != None:
-            tmp+='\t\t<para style="P2"><b>Data:</b> ' + dic_orig_externa['data'] + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Data:</b> ' + \
+                dic_orig_externa['data'] + '</para>\n'
 
         if dic_orig_externa['tipo'] != "" and dic_orig_externa['tipo'] != None:
-            tmp+='\t\t<para style="P2"><b>Tipo:</b> ' + dic_orig_externa['tipo'] + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Tipo:</b> ' + \
+                dic_orig_externa['tipo'] + '</para>\n'
 
         if dic_orig_externa['numero_ano'] != "" and dic_orig_externa['numero_ano'] != None:
-            tmp+='\t\t<para style="P2"><b>Número/Ano:</b> ' + dic_orig_externa['numero_ano'] + '</para>\n'
-    except: pass
+            tmp += '\t\t<para style="P2"><b>Número/Ano:</b> ' + \
+                dic_orig_externa['numero_ano'] + '</para>\n'
+    except:
+        pass
 
     return tmp
 
+
 def mat_anexadas(lst_mat_anexadas):
 
     tmp = ''
     tmp += '\t\t<para style="P1">Matérias Anexadas</para>\n'
     for dic_mat in lst_mat_anexadas:
         if dic_mat['nom_mat'] != "" and dic_mat['nom_mat'] != None:
-            tmp+='\t\t<para style="P2"><b>Nome da matéria:</b> ' + dic_mat['nom_mat'] + '</para>\n'
-            tmp+='\t\t<para style="P2"><b>Data:</b> ' + dic_mat['data'] + '</para>\n'
-            tmp+='\t\t<para style="P2"><b>Data final:</b> ' + str(dic_mat['data_fim']) + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Nome da matéria:</b> ' + \
+                dic_mat['nom_mat'] + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Data:</b> ' + \
+                dic_mat['data'] + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Data final:</b> ' + \
+                str(dic_mat['data_fim']) + '</para>\n'
     return tmp
 
+
 def autoria(lst_autoria):
 
     tmp = ''
     tmp += '\t\t<para style="P1">Autores</para>\n'
     for dic_autor in lst_autoria:
         if dic_autor['nom_autor'] != "" and dic_autor['nom_autor'] != None:
-            tmp+='\t\t<para style="P2"><b>Nome do Autor:</b> ' + dic_autor['nom_autor'] + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Nome do Autor:</b> ' + \
+                dic_autor['nom_autor'] + '</para>\n'
 
         if dic_autor['nom_autor'] != "" and dic_autor['cargo'] != None:
-            tmp+='\t\t<para style="P2"><b>Cargo:</b> ' + dic_autor['cargo'] + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Cargo:</b> ' + \
+                dic_autor['cargo'] + '</para>\n'
 
         if dic_autor['nom_autor'] != "" and dic_autor['tipo'] != None:
-            tmp+='\t\t<para style="P2"><b>Tipo:</b> ' + dic_autor['tipo'] + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Tipo:</b> ' + \
+                dic_autor['tipo'] + '</para>\n'
     return tmp
 
+
 def despachos_iniciais(lst_des_iniciais):
 
     tmp = ''
@@ -207,94 +240,137 @@ def despachos_iniciais(lst_des_iniciais):
     for dic_dados in lst_des_iniciais:
         if dic_dados['nom_comissao'] == None:
             dic_dados['nom_comissao'] = " "
-        tmp+='\t\t<para style="P2"><b>Nome da comissão:</b> ' + dic_dados['nom_comissao'] + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Nome da comissão:</b> ' + \
+            dic_dados['nom_comissao'] + '</para>\n'
     return tmp
 
+
 def tramitacoes(dic_tramitacoes):
 
     tmp = ''
     tmp += '\t\t<para style="P1">Última Tramitação</para>\n'
     try:
-        tmp+='\t\t<para style="P2"><b>Data Ação:</b> ' + str(dic_tramitacoes['data']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Unidade Local:</b> ' + dic_tramitacoes['unidade'] + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Encaminhada em:</b> ' + str(dic_tramitacoes['data_enc']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Destino:</b> ' + dic_tramitacoes['destino'] + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Turno:</b> ' + dic_tramitacoes['turno'] + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Status:</b> ' + dic_tramitacoes['status'] + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Data Ação:</b> ' + \
+            str(dic_tramitacoes['data']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Unidade Local:</b> ' + \
+            dic_tramitacoes['unidade'] + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Encaminhada em:</b> ' + \
+            str(dic_tramitacoes['data_enc']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Destino:</b> ' + \
+            dic_tramitacoes['destino'] + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Turno:</b> ' + \
+            dic_tramitacoes['turno'] + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Status:</b> ' + \
+            dic_tramitacoes['status'] + '</para>\n'
         if dic_tramitacoes['urgente'] == 0:
             tmp += '\t\t<para style="P2"><b>Urgente:</b> Não</para>\n'
         else:
             tmp += '\t\t<para style="P2"><b>Urgente:</b> Sim</para>\n'
 
-        tmp+='\t\t<para style="P2"><b>Data do fim do prazo:</b> ' + str(dic_tramitacoes['data_fim']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Data do fim do prazo:</b> ' + \
+            str(dic_tramitacoes['data_fim']) + '</para>\n'
         if dic_tramitacoes['texto_acao'] != "" and dic_tramitacoes['texto_acao'] != None:
-            tmp+='\t\t<para style="P2"><b>Texto da Ação:</b> ' + dic_tramitacoes['texto_acao'].replace('&','&amp;') + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Texto da Ação:</b> ' + \
+                dic_tramitacoes['texto_acao'].replace(
+                    '&', '&amp;') + '</para>\n'
 
-    except: pass
+    except:
+        pass
     return tmp
 
+
 def relatorias(lst_relatorias):
 
     tmp = ''
     tmp += '\t\t<para style="P1">Relatorias</para>\n'
     for dic_comissao in lst_relatorias:
-        tmp+='\t\t<para style="P2"><b>Comissão:</b> ' + dic_comissao['nom_comissao'] + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Data Designação:</b> ' + str(dic_comissao['data_desig']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Parlamentar:</b> ' + dic_comissao['parlamentar'] + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Data Destituição:</b> ' + str(dic_comissao['data_dest']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Motivo Fim Relatoria:</b> ' + dic_comissao['motivo'] + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Comissão:</b> ' + \
+            dic_comissao['nom_comissao'] + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Data Designação:</b> ' + \
+            str(dic_comissao['data_desig']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Parlamentar:</b> ' + \
+            dic_comissao['parlamentar'] + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Data Destituição:</b> ' + \
+            str(dic_comissao['data_dest']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Motivo Fim Relatoria:</b> ' + \
+            dic_comissao['motivo'] + '</para>\n'
     return tmp
 
+
 def numeracoes(lst_numeracoes):
 
     tmp = ''
     tmp += '\t\t<para style="P1">Numerações</para>\n'
     for dic_dados in lst_numeracoes:
-        tmp+='\t\t<para style="P2"><b>Nome:</b> ' + dic_dados['nome'] + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Ano:</b> ' + str(dic_dados['ano']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Nome:</b> ' + \
+            dic_dados['nome'] + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Ano:</b> ' + \
+            str(dic_dados['ano']) + '</para>\n'
     return tmp
 
+
 def legislacoes_citadas(lst_leg_citadas):
 
     tmp = ''
     tmp += '\t\t<para style="P1">Legislações Citadas</para>\n'
     for dic_dados in lst_leg_citadas:
-        tmp+='\t\t<para style="P2"><b>Tipo Norma:</b> ' + str(dic_dados['nome_lei']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Disposição:</b> ' + str(dic_dados['disposicao']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Parte:</b> ' + str(dic_dados['parte']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Livro:</b> ' + str(dic_dados['livro']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Tí­tulo:</b> ' + str(dic_dados['titulo']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Capí­tulo:</b> ' + str(dic_dados['capitulo']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Seção:</b> ' + str(dic_dados['secao']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Subseção:</b> ' + str(dic_dados['subsecao']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Artigo:</b> ' + str(dic_dados['artigo']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Parágrafo:</b> ' + str(dic_dados['paragrafo']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Inciso:</b> ' + str(dic_dados['inciso']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Alí­nea:</b> ' + str(dic_dados['alinea']) + '</para>\n'
-        tmp+='\t\t<para style="P2"><b>Item:</b> ' + str(dic_dados['item']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Tipo Norma:</b> ' + \
+            str(dic_dados['nome_lei']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Disposição:</b> ' + \
+            str(dic_dados['disposicao']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Parte:</b> ' + \
+            str(dic_dados['parte']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Livro:</b> ' + \
+            str(dic_dados['livro']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Tí­tulo:</b> ' + \
+            str(dic_dados['titulo']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Capí­tulo:</b> ' + \
+            str(dic_dados['capitulo']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Seção:</b> ' + \
+            str(dic_dados['secao']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Subseção:</b> ' + \
+            str(dic_dados['subsecao']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Artigo:</b> ' + \
+            str(dic_dados['artigo']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Parágrafo:</b> ' + \
+            str(dic_dados['paragrafo']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Inciso:</b> ' + \
+            str(dic_dados['inciso']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Alí­nea:</b> ' + \
+            str(dic_dados['alinea']) + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Item:</b> ' + \
+            str(dic_dados['item']) + '</para>\n'
     return tmp
 
+
 def documentos_acessorios(lst_acessorios):
 
     tmp = ''
     tmp += '\t\t<para style="P1">Documentos Acessórios</para>\n'
     for dic_dados in lst_acessorios:
         if dic_dados['tipo'] != None:
-            tmp+='\t\t<para style="P2"><b>Tipo:</b> ' + dic_dados['tipo'] + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Tipo:</b> ' + \
+                dic_dados['tipo'] + '</para>\n'
 
         if dic_dados['nome'] != None:
-            tmp+='\t\t<para style="P2"><b>Nome:</b> ' + dic_dados['nome'] + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Nome:</b> ' + \
+                dic_dados['nome'] + '</para>\n'
 
-        tmp+='\t\t<para style="P2"><b>Data:</b> ' + dic_dados['data'] + '</para>\n'
+        tmp += '\t\t<para style="P2"><b>Data:</b> ' + \
+            dic_dados['data'] + '</para>\n'
         if dic_dados['autor'] != None:
-            tmp+='\t\t<para style="P2"><b>Autor:</b> ' + dic_dados['autor'] + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Autor:</b> ' + \
+                dic_dados['autor'] + '</para>\n'
 
         if dic_dados['ementa'] != None:
-            tmp+='\t\t<para style="P2"><b>Ementa:</b> ' + dic_dados['ementa'].replace('&','&amp;') + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Ementa:</b> ' + \
+                dic_dados['ementa'].replace('&', '&amp;') + '</para>\n'
         if dic_dados['indexacao'] != None:
-            tmp+='\t\t<para style="P2"><b>Ementa:</b> ' + dic_dados['indexacao'].replace('&','&amp;') + '</para>\n'
+            tmp += '\t\t<para style="P2"><b>Ementa:</b> ' + \
+                dic_dados['indexacao'].replace('&', '&amp;') + '</para>\n'
     return tmp
 
+
 def principal(imagem, dic_rodape, dic_inf_basicas, dic_orig_externa, lst_mat_anexadas, lst_autoria, lst_des_iniciais,
               dic_tramitacoes, lst_relatorias, lst_numeracoes, lst_leg_citadas, lst_acessorios, sessao=''):
     """

sapl/relatorios/templates/pdf_detalhe_materia_preparar_pysc.py

@@ -17,7 +17,8 @@ casa={}
 aux = context.sapl_documentos.props_sapl.propertyItems()
 for item in aux:
     casa[item[0]] = item[1]
-localidade=context.zsql.localidade_obter_zsql(cod_localidade=casa["cod_localidade"])
+localidade = context.zsql.localidade_obter_zsql(
+    cod_localidade=casa["cod_localidade"])
 data_emissao = DateTime().strftime("%d/%m/%Y")
 rodape = casa
 rodape['data_emissao'] = data_emissao
@@ -39,7 +40,8 @@ for materia in context.zsql.materia_obter_zsql(cod_materia=REQUEST['cod_materia'
     inf_basicas_dic['publicada'] = materia.dat_publicacao
     inf_basicas_dic['objeto'] = materia.des_objeto
     inf_basicas_dic['tramitacao'] = materia.ind_tramitacao
- inf_basicas_dic['cod_projeto']= materia.sgl_tipo_materia+"   "+ str(materia.num_ident_basica)+" de "+ str(materia.ano_ident_basica)
+    inf_basicas_dic['cod_projeto'] = materia.sgl_tipo_materia + "   " + \
+        str(materia.num_ident_basica) + " de " + str(materia.ano_ident_basica)
     inf_basicas_dic['nom_projeto'] = materia.des_tipo_materia
 
     for tramitacao in context.zsql.regime_tramitacao_obter_zsql(cod_regime_tramitacao=materia.cod_regime_tramitacao):
@@ -76,14 +78,17 @@ for materia in context.zsql.materia_obter_zsql(cod_materia=REQUEST['cod_materia'
         orig_externa_dic['local'] = origem.sgl_origem + "-" + origem.nom_origem
         orig_externa_dic['tipo'] = materia.tip_origem_externa
         orig_externa_dic['data'] = materia.dat_origem_externa
-  orig_externa_dic['numero_ano']= str(materia.num_origem_externa)+ "/"+ str(materia.ano_origem_externa)
+        orig_externa_dic['numero_ano'] = str(
+            materia.num_origem_externa) + "/" + str(materia.ano_origem_externa)
 
 # #o bloco abaixo gera o dicionario das materias anexadas (ln 55)
     lst_mat_anexadas = []
     dic_mat = {}
     for anexada in context.zsql.anexada_obter_zsql(cod_materia_principal=materia.cod_materia):
-  aux1 = context.zsql.materia_obter_zsql(cod_materia = anexada.cod_materia_anexada)
-  aux2 = context.zsql.tipo_materia_legislativa_obter_zsql(tip_materia = aux1[0].tip_id_basica)
+        aux1 = context.zsql.materia_obter_zsql(
+            cod_materia=anexada.cod_materia_anexada)
+        aux2 = context.zsql.tipo_materia_legislativa_obter_zsql(
+            tip_materia=aux1[0].tip_id_basica)
 #  """#tratando possíveis erros"""
 #  if aux2.sgl_tipo_materia==None: aux2.sgl_tipo_materia=""
 #  if aux2.num_ident_basica==None: aux2.num_ident_basica=""
@@ -91,7 +96,8 @@ for materia in context.zsql.materia_obter_zsql(cod_materia=REQUEST['cod_materia'
 #  if anexadas.dat_anexacao==None: anexadas.dat_anexacao=""
 #  if anexadas.dat_desanexacao==None: anexadas.dat_desanexacao=""
 #  """#"""
-  dic_mat['nom_mat']= aux2[0].sgl_tipo_materia+ "/"+ str(aux1[0].num_ident_basica)+ "/"+ str(aux1[0].ano_ident_basica)
+        dic_mat['nom_mat'] = aux2[0].sgl_tipo_materia + "/" + \
+            str(aux1[0].num_ident_basica) + "/" + str(aux1[0].ano_ident_basica)
         dic_mat['data'] = anexada.dat_anexacao
         dic_mat['data_fim'] = anexada.dat_desanexacao
         lst_mat_anexadas.append(dic_mat)
@@ -139,7 +145,8 @@ for materia in context.zsql.materia_obter_zsql(cod_materia=REQUEST['cod_materia'
                 comissao.nom_comissao = ''
             if comissao.sgl_comissao == None:
                 comissao.sgl_comissao = ''
-     dic_dados['nom_comissao']=comissao.nom_comissao+ " - "+ comissao.sgl_comissao
+            dic_dados['nom_comissao'] = comissao.nom_comissao + \
+                " - " + comissao.sgl_comissao
             lst_des_iniciais.append(dic_dados)
 
 # #o bloco abaixo gera o dicionário de Tramitacoes(ln 87)
@@ -153,9 +160,8 @@ for materia in context.zsql.materia_obter_zsql(cod_materia=REQUEST['cod_materia'
         dic_tramitacoes['data_fim'] = tramitacao.dat_fim_prazo
         dic_tramitacoes['texto_acao'] = tramitacao.txt_tramitacao
 
-   
         for unidade in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao=tramitacao.cod_unid_tram_local):
-     #-----------------se unidade for comissao---------------------------------
+            #-----------------se unidade for comissao--------------------------
             if unidade.cod_orgao == None:
                 for comissao in context.zsql.comissao_obter_zsql(cod_comissao=unidade.cod_comissao):
                     if tramitacao.cod_unid_tram_dest != None:
@@ -163,17 +169,21 @@ for materia in context.zsql.materia_obter_zsql(cod_materia=REQUEST['cod_materia'
                             # se unidade destino for comissao
                             if unidade_dest.cod_orgao == None:
                                 for comissao_dest in context.zsql.comissao_obter_zsql(cod_comissao=unidade_dest.cod_comissao):
-                dic_tramitacoes['unidade']= comissao.nom_comissao
-                dic_tramitacoes['destino']= comissao_dest.nom_comissao
+                                    dic_tramitacoes[
+                                        'unidade'] = comissao.nom_comissao
+                                    dic_tramitacoes[
+                                        'destino'] = comissao_dest.nom_comissao
                             # se unidade destino for orgao
                             if unidade_dest.cod_comissao == None:
                                 for orgao_dest in context.zsql.orgao_obter_zsql(cod_orgao=unidade_dest.cod_orgao):
-                dic_tramitacoes['unidade']= comissao.nom_comissao
-                dic_tramitacoes['destino']= orgao_dest.nom_orgao
+                                    dic_tramitacoes[
+                                        'unidade'] = comissao.nom_comissao
+                                    dic_tramitacoes[
+                                        'destino'] = orgao_dest.nom_orgao
                     else:
                         dic_tramitacoes['unidade'] = comissao.nom_comissao
                         dic_tramitacoes['destino'] = "None"
-     #---------------se unidade for orgao----------------------------------------- 
+            #---------------se unidade for orgao-------------------------------
             if unidade.cod_comissao == None:
                 for orgao in context.zsql.orgao_obter_zsql(cod_orgao=unidade.cod_orgao):
                     if tramitacao.cod_unid_tram_dest != None:
@@ -181,13 +191,17 @@ for materia in context.zsql.materia_obter_zsql(cod_materia=REQUEST['cod_materia'
                             # se unidade destino for comissao
                             if unidade_dest.cod_orgao == None:
                                 for comissao_dest in context.zsql.comissao_obter_zsql(cod_comissao=unidade_dest.cod_comissao):
-                dic_tramitacoes['unidade']= orgao.nom_orgao
-                dic_tramitacoes['destino']= comissao_dest.nom_comissao
+                                    dic_tramitacoes[
+                                        'unidade'] = orgao.nom_orgao
+                                    dic_tramitacoes[
+                                        'destino'] = comissao_dest.nom_comissao
                             # se unidade destino for orgao
                             if unidade_dest.cod_comissao == None:
                                 for orgao_dest in context.zsql.orgao_obter_zsql(cod_orgao=unidade_dest.cod_orgao):
-                dic_tramitacoes['unidade']= orgao.nom_orgao
-                dic_tramitacoes['destino']= orgao_dest.nom_orgao  
+                                    dic_tramitacoes[
+                                        'unidade'] = orgao.nom_orgao
+                                    dic_tramitacoes[
+                                        'destino'] = orgao_dest.nom_orgao
                     else:
                         dic_tramitacoes['unidade'] = orgao.nom_orgao
                         dic_tramitacoes['destino'] = "None"
@@ -218,7 +232,8 @@ for materia in context.zsql.materia_obter_zsql(cod_materia=REQUEST['cod_materia'
     dic_dados = {}
     for numeracao in context.zsql.numeracao_obter_zsql(cod_materia=materia.cod_materia):
         for tipo_materia in context.zsql.tipo_materia_legislativa_obter_zsql(tip_materia=numeracao.tip_materia):
-   dic_dados['nome']= tipo_materia.sgl_tipo_materia+ "-"+ tipo_materia.des_tipo_materia+ "nº"+ numeracao.num_materia
+            dic_dados['nome'] = tipo_materia.sgl_tipo_materia + "-" + \
+                tipo_materia.des_tipo_materia + "nº" + numeracao.num_materia
             dic_dados['ano'] = numeracao.ano_materia
         lst_numeracoes.append(dic_dados)
 
@@ -228,8 +243,10 @@ for materia in context.zsql.materia_obter_zsql(cod_materia=REQUEST['cod_materia'
     lst_legis_citadas = []
     dic_dados = {}
     for legislacao in context.zsql.legislacao_citada_obter_zsql(cod_materia=materia.cod_materia):
-  norma = context.zsql.norma_juridica_obter_zsql(cod_norma = legislacao.cod_norma_sel)
-  dic_dados['nome_lei']= str(norma[0].tip_norma_sel) + " nº"+ str(norma[0].num_norma) + " de"+ str(norma[0].ano_norma)
+        norma = context.zsql.norma_juridica_obter_zsql(
+            cod_norma=legislacao.cod_norma_sel)
+        dic_dados['nome_lei'] = str(norma[0].tip_norma_sel) + " nº" + \
+            str(norma[0].num_norma) + " de" + str(norma[0].ano_norma)
         dic_dados['disposicao'] = legislacao.des_disposicoes
         dic_dados['parte'] = legislacao.des_parte
         dic_dados['livro'] = legislacao.des_livro

sapl/relatorios/templates/pdf_documento_administrativo_preparar_pysc.py

@@ -11,7 +11,8 @@ casa={}
 aux = context.sapl_documentos.props_sapl.propertyItems()
 for item in aux:
     casa[item[0]] = item[1]
-localidade=context.zsql.localidade_obter_zsql(cod_localidade=casa["cod_localidade"])
+localidade = context.zsql.localidade_obter_zsql(
+    cod_localidade=casa["cod_localidade"])
 if len(casa["num_cep"]) == 8:
     cep = casa["num_cep"][:4] + "-" + casa["num_cep"][5:]
 else:
@@ -23,7 +24,8 @@ if cep!="":
         linha1 = linha1 + " - "
     linha1 = linha1 + "CEP " + cep
 if localidade[0].nom_localidade != "" and localidade[0].nom_localidade != None:
-  linha1 = linha1 + " - "+localidade[0].nom_localidade+" "+localidade[0].sgl_uf
+    linha1 = linha1 + " - " + \
+        localidade[0].nom_localidade + " " + localidade[0].sgl_uf
 if casa["num_tel"] != "" and casa["num_tel"] != None:
     linha1 = linha1 + " Tel.: " + casa["num_tel"]
 
@@ -57,14 +59,20 @@ else:
 documentos = []
 REQUEST = context.REQUEST
 for documento in context.zsql.documento_administrativo_pesquisar_zsql(tip_documento=REQUEST['lst_tip_documento'],
-                                                    num_documento=REQUEST['txt_num_documento'], ano_documento=REQUEST['txt_ano_documento'], 
-                                                    num_protocolo=REQUEST['txt_num_protocolo'], ind_tramitacao=REQUEST['rad_tramitando'], 
-                                                    des_assunto=REQUEST['txa_txt_assunto'], cod_status=REQUEST['lst_status'], 
-                                                    txt_interessado=REQUEST['txa_txt_interessado'], dat_apres1=REQUEST['dt_apres1'], 
+                                                                      num_documento=REQUEST['txt_num_documento'], ano_documento=REQUEST[
+                                                                          'txt_ano_documento'],
+                                                                      num_protocolo=REQUEST[
+                                                                          'txt_num_protocolo'], ind_tramitacao=REQUEST['rad_tramitando'],
+                                                                      des_assunto=REQUEST[
+                                                                          'txa_txt_assunto'], cod_status=REQUEST['lst_status'],
+                                                                      txt_interessado=REQUEST[
+                                                                          'txa_txt_interessado'], dat_apres1=REQUEST['dt_apres1'],
                                                                       dat_apres2=REQUEST['dt_apres2'], rd_ordem=REQUEST['rd_ordenacao']):
     dic = {}
 
-        dic['titulo']=documento.sgl_tipo_documento+" "+str(documento.num_documento)+" "+str(documento.ano_documento)+" - "+documento.des_tipo_documento
+    dic['titulo'] = documento.sgl_tipo_documento + " " + \
+        str(documento.num_documento) + " " + \
+        str(documento.ano_documento) + " - " + documento.des_tipo_documento
     dic['txt_assunto'] = documento.txt_assunto
     dic['txt_interessado'] = documento.txt_interessado
 
@@ -103,7 +111,8 @@ filtro['assunto']=REQUEST.txa_txt_assunto
 filtro['tipo_documento'] = ''
 if REQUEST.lst_tip_documento != '':
     for tipo_documento in context.zsql.tipo_documento_administrativo_obter_zsql(ind_excluido=0, tip_documento=REQUEST.lst_tip_documento):
-        filtro['tipo_documento']= tipo_documento.sgl_tipo_documento + ' - ' + tipo_documento.des_tipo_documento
+        filtro['tipo_documento'] = tipo_documento.sgl_tipo_documento + \
+            ' - ' + tipo_documento.des_tipo_documento
 
 filtro['tramitando'] = ''
 if REQUEST.rad_tramitando == '1':
@@ -114,10 +123,12 @@ elif REQUEST['rad_tramitando']=='0':
 filtro['situacao_atual'] = ''
 if REQUEST.lst_status != '':
     for status in context.zsql.status_tramitacao_administrativo_obter_zsql(ind_exluido=0, cod_status=REQUEST.lst_status):
-        filtro['situacao_atual']=status.sgl_status + ' - ' + status.des_status
+        filtro['situacao_atual'] = status.sgl_status + \
+            ' - ' + status.des_status
 
 sessao = session.id
-caminho = context.pdf_documento_administrativo_gerar(sessao,imagem,data,documentos,cabecalho,rodape,filtro)
+caminho = context.pdf_documento_administrativo_gerar(
+    sessao, imagem, data, documentos, cabecalho, rodape, filtro)
 if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:

sapl/relatorios/templates/pdf_espelho_gerar.py

@@ -163,4 +163,5 @@ def principal(imagem, lst_materias, dic_cabecalho, lst_rodape):
 
 #         return "/temp_folder/"+arquivoPdf
 
-# return principal(sessao,imagem,data,lst_materias,dic_cabecalho,lst_rodape,dic_filtro)
+# return
+# principal(sessao,imagem,data,lst_materias,dic_cabecalho,lst_rodape,dic_filtro)

sapl/relatorios/templates/pdf_espelho_preparar_pysc.py

@@ -11,7 +11,8 @@ casa={}
 aux = context.sapl_documentos.props_sapl.propertyItems()
 for item in aux:
     casa[item[0]] = item[1]
-localidade=context.zsql.localidade_obter_zsql(cod_localidade=casa["cod_localidade"])
+localidade = context.zsql.localidade_obter_zsql(
+    cod_localidade=casa["cod_localidade"])
 if len(casa["num_cep"]) == 8:
     cep = casa["num_cep"][:4] + "-" + casa["num_cep"][5:]
 else:
@@ -23,7 +24,8 @@ if cep!="":
         linha1 = linha1 + " - "
     linha1 = linha1 + "CEP " + cep
 if localidade[0].nom_localidade != "" and localidade[0].nom_localidade != None:
-  linha1 = linha1 + " - "+localidade[0].nom_localidade+" "+localidade[0].sgl_uf
+    linha1 = linha1 + " - " + \
+        localidade[0].nom_localidade + " " + localidade[0].sgl_uf
 if casa["num_tel"] != "" and casa["num_tel"] != None:
     linha1 = linha1 + " Tel.: " + casa["num_tel"]
 
@@ -60,8 +62,10 @@ if REQUEST.txt_check=='1':
     REQUEST = context.REQUEST
     for materia in context.zsql.materia_obter_zsql(cod_materia=cod_mat):
         dic = {}
-        dic['titulo']="INDICAÇÃO: "+str(materia.num_ident_basica)+" "+str(materia.ano_ident_basica)
-	dic['materia']=str(materia.num_ident_basica)+"/"+str(materia.ano_ident_basica)
+        dic['titulo'] = "INDICAÇÃO: " + \
+            str(materia.num_ident_basica) + " " + str(materia.ano_ident_basica)
+        dic['materia'] = str(materia.num_ident_basica) + \
+            "/" + str(materia.ano_ident_basica)
         dic['dat_apresentacao'] = materia.dat_apresentacao
         dic['txt_ementa'] = materia.txt_ementa
 
@@ -106,7 +110,8 @@ if REQUEST.txt_check=='1':
 
         dic['norma_juridica_vinculada'] = "Não há nenhuma norma jurídica vinculada"
         for norma in context.zsql.materia_buscar_norma_juridica_zsql(cod_materia=materia.cod_materia):
-            dic['norma_juridica_vinculada']=norma.des_norma+" "+str(norma.num_norma)+"/"+str(norma.ano_norma)
+            dic['norma_juridica_vinculada'] = norma.des_norma + " " + \
+                str(norma.num_norma) + "/" + str(norma.ano_norma)
 
         materias.append(dic)
 
@@ -117,8 +122,11 @@ else:
     for cod_mat in codigo:
         for materia in context.zsql.materia_obter_zsql(cod_materia=cod_mat):
             dic = {}
-	dic['titulo']="INDICAÇÃO: "+str(materia.num_ident_basica)+" "+str(materia.ano_ident_basica)
-        dic['materia']=str(materia.num_ident_basica)+"/"+str(materia.ano_ident_basica)
+            dic['titulo'] = "INDICAÇÃO: " + \
+                str(materia.num_ident_basica) + " " + \
+                str(materia.ano_ident_basica)
+            dic['materia'] = str(materia.num_ident_basica) + \
+                "/" + str(materia.ano_ident_basica)
             dic['dat_apresentacao'] = materia.dat_apresentacao
             dic['txt_ementa'] = materia.txt_ementa
 
@@ -163,7 +171,8 @@ else:
 
             dic['norma_juridica_vinculada'] = "Não há nenhuma norma jurídica vinculada"
             for norma in context.zsql.materia_buscar_norma_juridica_zsql(cod_materia=materia.cod_materia):
-	    dic['norma_juridica_vinculada']=norma.des_norma+" "+str(norma.num_norma)+"/"+str(norma.ano_norma)
+                dic['norma_juridica_vinculada'] = norma.des_norma + " " + \
+                    str(norma.num_norma) + "/" + str(norma.ano_norma)
 
             materias.append(dic)
 
@@ -193,7 +202,8 @@ filtro={} # Dicionário que conterá os dados do filtro
 #        filtro['situacao_atual']=status.sgl_status + ' - ' + status.des_status
 
 sessao = session.id
-caminho = context.pdf_espelho_gerar(sessao,imagem,data,materias,cabecalho,rodape,filtro)
+caminho = context.pdf_espelho_gerar(
+    sessao, imagem, data, materias, cabecalho, rodape, filtro)
 if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:

sapl/relatorios/templates/pdf_etiqueta_protocolo_preparar_pysc.py

@@ -11,7 +11,8 @@ casa={}
 aux = context.sapl_documentos.props_sapl.propertyItems()
 for item in aux:
     casa[item[0]] = item[1]
-localidade=context.zsql.localidade_obter_zsql(cod_localidade=casa["cod_localidade"])
+localidade = context.zsql.localidade_obter_zsql(
+    cod_localidade=casa["cod_localidade"])
 if len(casa["num_cep"]) == 8:
     cep = casa["num_cep"][:4] + "-" + casa["num_cep"][5:]
 else:
@@ -23,7 +24,8 @@ if cep!="":
         linha1 = linha1 + " - "
     linha1 = linha1 + "CEP " + cep
 if localidade[0].nom_localidade != "" and localidade[0].nom_localidade != None:
-  linha1 = linha1 + " - "+localidade[0].nom_localidade+" "+localidade[0].sgl_uf
+    linha1 = linha1 + " - " + \
+        localidade[0].nom_localidade + " " + localidade[0].sgl_uf
 if casa["num_tel"] != "" and casa["num_tel"] != None:
     linha1 = linha1 + " Tel.: " + casa["num_tel"]
 
@@ -57,16 +59,21 @@ else:
 protocolos = []
 REQUEST = context.REQUEST
 for protocolo in context.zsql.protocolo_pesquisar_zsql(tip_protocolo=REQUEST['rad_tip_protocolo'],
-                              cod_protocolo=REQUEST['txt_num_protocolo'], ano_protocolo=REQUEST['txt_ano_protocolo'],
-                              tip_documento=REQUEST['lst_tip_documento'], tip_processo=REQUEST['rad_tip_processo'], 
-                              tip_materia=REQUEST['lst_tip_materia'], des_assunto=REQUEST['txt_assunto'], 
-                              cod_autor=REQUEST['hdn_cod_autor'], des_interessado=REQUEST['txa_txt_interessado'], 
+                                                       cod_protocolo=REQUEST['txt_num_protocolo'], ano_protocolo=REQUEST[
+                                                           'txt_ano_protocolo'],
+                                                       tip_documento=REQUEST['lst_tip_documento'], tip_processo=REQUEST[
+                                                           'rad_tip_processo'],
+                                                       tip_materia=REQUEST[
+                                                           'lst_tip_materia'], des_assunto=REQUEST['txt_assunto'],
+                                                       cod_autor=REQUEST['hdn_cod_autor'], des_interessado=REQUEST[
+    'txa_txt_interessado'],
         dat_apres=REQUEST['dt_apres'], dat_apres2=REQUEST['dt_apres2']):
     dic = {}
 
     dic['titulo'] = str(protocolo.cod_protocolo)
 
-        dic['data']='Data: '+context.pysc.iso_to_port_pysc(protocolo.dat_protocolo)+' Horário: '+protocolo.hor_protocolo[0:2]+':'+protocolo.hor_protocolo[3:5]
+    dic['data'] = 'Data: ' + context.pysc.iso_to_port_pysc(
+        protocolo.dat_protocolo) + ' Horário: ' + protocolo.hor_protocolo[0:2] + ':' + protocolo.hor_protocolo[3:5]
 
     dic['txt_assunto'] = protocolo.txt_assunto_ementa
 
@@ -92,11 +99,13 @@ for protocolo in context.zsql.protocolo_pesquisar_zsql(tip_protocolo=REQUEST['ra
 
     dic['num_materia'] = ''
     for materia in context.zsql.materia_obter_zsql(num_protocolo=protocolo.cod_protocolo, ano_ident_basica=protocolo.ano_protocolo):
-               dic['num_materia']=materia.sgl_tipo_materia+' '+str(materia.num_ident_basica)+'/'+str(materia.ano_ident_basica)
+        dic['num_materia'] = materia.sgl_tipo_materia + ' ' + \
+            str(materia.num_ident_basica) + '/' + str(materia.ano_ident_basica)
 
     dic['num_documento'] = ''
     for documento in context.zsql.documento_administrativo_obter_zsql(num_protocolo=protocolo.cod_protocolo):
-               dic['num_documento']=documento.sgl_tipo_documento+' '+str(documento.num_documento)+'/'+ str(documento.ano_documento)
+        dic['num_documento'] = documento.sgl_tipo_documento + ' ' + \
+            str(documento.num_documento) + '/' + str(documento.ano_documento)
 
     dic['ident_processo'] = dic['num_materia'] or dic['num_documento']
 
@@ -120,7 +129,8 @@ filtro['autor']=REQUEST.hdn_cod_autor
 filtro['interessado'] = REQUEST.txa_txt_interessado
 
 sessao = session.id
-caminho = context.pdf_etiqueta_protocolo_gerar(sessao,imagem,data,protocolos,cabecalho,rodape,filtro)
+caminho = context.pdf_etiqueta_protocolo_gerar(
+    sessao, imagem, data, protocolos, cabecalho, rodape, filtro)
 if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:

sapl/relatorios/templates/pdf_materia_gerar.py

@@ -1,4 +1,4 @@
-##parameters=sessao,imagem,data,lst_materias,dic_cabecalho,lst_rodape,dic_filtro
+# parameters=sessao,imagem,data,lst_materias,dic_cabecalho,lst_rodape,dic_filtro
 
 """relatorio_materia.py
    External method para gerar o arquivo rml do resultado de uma pesquisa de matérias
@@ -17,27 +17,34 @@ def cabecalho(dic_cabecalho,imagem):
     tmp_data += '\t\t\t\t<image x="2.1cm" y="25.7cm" width="59" height="62" file="' + imagem + '"/>\n'
     tmp_data += '\t\t\t\t<lines>2cm 25cm 19cm 25cm</lines>\n'
     tmp_data += '\t\t\t\t<setFont name="Helvetica-Bold" size="16"/>\n'
-    tmp_data+='\t\t\t\t<drawString x="5cm" y="27.1cm">' + dic_cabecalho['nom_casa'] + '</drawString>\n'
+    tmp_data += '\t\t\t\t<drawString x="5cm" y="27.1cm">' + \
+        dic_cabecalho['nom_casa'] + '</drawString>\n'
     tmp_data += '\t\t\t\t<setFont name="Helvetica" size="13"/>\n'
-    tmp_data+='\t\t\t\t<drawString x="5cm" y="26.5cm">' + dic_cabecalho['nom_estado'] + '</drawString>\n'
+    tmp_data += '\t\t\t\t<drawString x="5cm" y="26.5cm">' + \
+        dic_cabecalho['nom_estado'] + '</drawString>\n'
     tmp_data += '\t\t\t\t<setFont name="Helvetica-Bold" size="13"/>\n'
     tmp_data += '\t\t\t\t<drawCentredString x="10.5cm" y="25.2cm">Relatório de Matérias Legislativas</drawCentredString>\n'
 
     return tmp_data
 
+
 def rodape(lst_rodape):
     """Gera o codigo rml do rodape"""
 
     tmp_data = ''
     tmp_data += '\t\t\t\t<lines>2cm 3.2cm 19cm 3.2cm</lines>\n'
     tmp_data += '\t\t\t\t<setFont name="Helvetica" size="8"/>\n'
-    tmp_data+='\t\t\t\t<drawString x="2cm" y="3.3cm">' + lst_rodape[2] + '</drawString>\n'
+    tmp_data += '\t\t\t\t<drawString x="2cm" y="3.3cm">' + \
+        lst_rodape[2] + '</drawString>\n'
     tmp_data += '\t\t\t\t<drawString x="17.9cm" y="3.3cm">Página <pageNumber/></drawString>\n'
-    tmp_data+='\t\t\t\t<drawCentredString x="10.5cm" y="2.7cm">' + lst_rodape[0] + '</drawCentredString>\n'
-    tmp_data+='\t\t\t\t<drawCentredString x="10.5cm" y="2.3cm">' + lst_rodape[1] + '</drawCentredString>\n'
+    tmp_data += '\t\t\t\t<drawCentredString x="10.5cm" y="2.7cm">' + \
+        lst_rodape[0] + '</drawCentredString>\n'
+    tmp_data += '\t\t\t\t<drawCentredString x="10.5cm" y="2.3cm">' + \
+        lst_rodape[1] + '</drawCentredString>\n'
 
     return tmp_data
 
+
 def paraStyle():
     """Gera o codigo rml que define o estilo dos paragrafos"""
 
@@ -56,6 +63,7 @@ def paraStyle():
 
     return tmp_data
 
+
 def materias(lst_materias):
     """Gera o codigo rml do conteudo da pesquisa de materias"""
 
@@ -74,15 +82,20 @@ def materias(lst_materias):
         tmp_data += '\t\t<condPageBreak height="1.5cm"/>\n'
 
         # materias
-        tmp_data+='\t\t<para style="P1"> <b>'+ dic['titulo'] +'</b>   -   <b>Autor: </b>' + dic['nom_autor'] + ' </para>\n'
+        tmp_data += '\t\t<para style="P1"> <b>' + \
+            dic['titulo'] + '</b>   -   <b>Autor: </b>' + \
+            dic['nom_autor'] + ' </para>\n'
         if dic['txt_ementa'] != None:
             txt_ementa = dic['txt_ementa'].replace('&', '&amp;')
             tmp_data += '\t\t<para style="P2"> ' + txt_ementa + ' </para>\n'
-        tmp_data+='\t\t<para style="P2"><b>Situação:</b> ' + dic['des_situacao'] + '/ <b>Norma Jurídica Vinculada:</b> ' + dic['norma_vinculada'] + '</para>\n'
+        tmp_data += '\t\t<para style="P2"><b>Situação:</b> ' + \
+            dic['des_situacao'] + '/ <b>Norma Jurídica Vinculada:</b> ' + \
+            dic['norma_vinculada'] + '</para>\n'
 
     tmp_data += '\t</story>\n'
     return tmp_data
 
+
 def principal(imagem, lst_materias, dic_cabecalho, lst_rodape):
     """Funcao pricipal que gera a estrutura global do arquivo rml"""
 
@@ -116,4 +129,5 @@ def principal(imagem, lst_materias, dic_cabecalho, lst_rodape):
 
 #     return "/temp_folder/"+arquivoPdf
 
-# return principal(sessao,imagem,data,lst_materias,dic_cabecalho,lst_rodape,dic_filtro)
+# return
+# principal(sessao,imagem,data,lst_materias,dic_cabecalho,lst_rodape,dic_filtro)

sapl/relatorios/templates/pdf_materia_preparar_pysc.py

@@ -13,7 +13,8 @@ casa={}
 aux = context.sapl_documentos.props_sapl.propertyItems()
 for item in aux:
     casa[item[0]] = item[1]
-localidade=context.zsql.localidade_obter_zsql(cod_localidade=casa["cod_localidade"])
+localidade = context.zsql.localidade_obter_zsql(
+    cod_localidade=casa["cod_localidade"])
 if len(casa["num_cep"]) == 8:
     cep = casa["num_cep"][:4] + "-" + casa["num_cep"][5:]
 else:
@@ -25,7 +26,8 @@ if cep!="":
         linha1 = linha1 + " - "
     linha1 = linha1 + "CEP " + cep
 if localidade[0].nom_localidade != "" and localidade[0].nom_localidade != None:
-  linha1 = linha1 + " - "+localidade[0].nom_localidade+" "+localidade[0].sgl_uf
+    linha1 = linha1 + " - " + \
+        localidade[0].nom_localidade + " " + localidade[0].sgl_uf
 if casa["num_tel"] != "" and casa["num_tel"] != None:
     linha1 = linha1 + " Tel.: " + casa["num_tel"]
 
@@ -59,17 +61,25 @@ else:
 materias = []
 REQUEST = context.REQUEST
 for materia in context.zsql.materia_pesquisar_zsql(tip_id_basica=REQUEST['lst_tip_materia'], num_ident_basica=REQUEST['txt_numero'],
-                                           ano_ident_basica=REQUEST['txt_ano'], ind_tramitacao=REQUEST['rad_tramitando'],                                             
-                                           des_assunto=REQUEST['txt_assunto'], nom_relator=REQUEST['txt_relator'],
-                                           cod_status=REQUEST['lst_status'], des_tipo_autor=REQUEST['lst_tip_autor'],
-                                           dat_apresentacao=REQUEST['dt_apres'], dat_apresentacao2=REQUEST['dt_apres2'],
-                                           dat_publicacao=REQUEST['dt_public'], dat_publicacao2=REQUEST['dt_public2'],
-                                           cod_partido=REQUEST['lst_cod_partido'],cod_autor=REQUEST['hdn_cod_autor'],
+                                                   ano_ident_basica=REQUEST[
+                                                       'txt_ano'], ind_tramitacao=REQUEST['rad_tramitando'],
+                                                   des_assunto=REQUEST[
+                                                       'txt_assunto'], nom_relator=REQUEST['txt_relator'],
+                                                   cod_status=REQUEST['lst_status'], des_tipo_autor=REQUEST[
+                                                       'lst_tip_autor'],
+                                                   dat_apresentacao=REQUEST[
+                                                       'dt_apres'], dat_apresentacao2=REQUEST['dt_apres2'],
+                                                   dat_publicacao=REQUEST[
+                                                       'dt_public'], dat_publicacao2=REQUEST['dt_public2'],
+                                                   cod_partido=REQUEST['lst_cod_partido'], cod_autor=REQUEST[
+                                                       'hdn_cod_autor'],
                                                    rd_ordem=REQUEST['rd_ordenacao'], rd_ordem_td=REQUEST['rd_ordem_td']):
 
     dic = {}
 
-        dic['titulo']=materia.sgl_tipo_materia+" "+materia.des_tipo_materia+" "+str(materia.num_ident_basica)+"/"+str(materia.ano_ident_basica)
+    dic['titulo'] = materia.sgl_tipo_materia + " " + materia.des_tipo_materia + \
+        " " + str(materia.num_ident_basica) + "/" + \
+        str(materia.ano_ident_basica)
     dic['txt_ementa'] = materia.txt_ementa
     dic['nom_autor'] = " "
     for autoria in context.zsql.autoria_obter_zsql(cod_materia=materia.cod_materia):
@@ -105,10 +115,11 @@ for materia in context.zsql.materia_pesquisar_zsql(tip_id_basica=REQUEST['lst_ti
     dic['des_situacao'] = des_status
     dic['ultima_acao'] = txt_tramitacao
 
-
     dic['norma_vinculada'] = " "
     for norma_vinculada in context.zsql.materia_buscar_norma_juridica_zsql(cod_materia=materia.cod_materia):
-            dic['norma_vinculada']=norma_vinculada.des_norma+" "+str(norma_vinculada.num_norma)+"/"+str(norma_vinculada.ano_norma)
+        dic['norma_vinculada'] = norma_vinculada.des_norma + " " + \
+            str(norma_vinculada.num_norma) + "/" + \
+            str(norma_vinculada.ano_norma)
 
     materias.append(dic)
 
@@ -129,7 +140,8 @@ if REQUEST.hdn_txt_autor=='  ': # Corrige bug do Netscape
 filtro['tipo_materia'] = ''
 if REQUEST.lst_tip_materia != '':
     for tipo_materia in context.zsql.tipo_materia_legislativa_obter_zsql(ind_excluido=0, tip_materia=REQUEST.lst_tip_materia):
-        filtro['tipo_materia']= tipo_materia.sgl_tipo_materia + ' - ' + tipo_materia.des_tipo_materia
+        filtro['tipo_materia'] = tipo_materia.sgl_tipo_materia + \
+            ' - ' + tipo_materia.des_tipo_materia
 
 filtro['partido'] = ''
 if REQUEST.lst_cod_partido != '':
@@ -145,10 +157,12 @@ elif REQUEST['rad_tramitando']=='0':
 filtro['situacao_atual'] = ''
 if REQUEST.lst_status != '':
     for status in context.zsql.status_tramitacao_obter_zsql(ind_excluido=0, cod_status=REQUEST.lst_status):
-        filtro['situacao_atual']=status.sgl_status + ' - ' + status.des_status
+        filtro['situacao_atual'] = status.sgl_status + \
+            ' - ' + status.des_status
 
 sessao = session.id
-caminho = context.pdf_materia_gerar(sessao,imagem,data,materias,cabecalho,rodape,filtro)
+caminho = context.pdf_materia_gerar(
+    sessao, imagem, data, materias, cabecalho, rodape, filtro)
 if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:

sapl/relatorios/templates/pdf_norma_gerar.py

@@ -1,4 +1,4 @@
-##parameters=sessao,imagem,data,lst_normas,dic_cabecalho,lst_rodape,dic_filtro
+# parameters=sessao,imagem,data,lst_normas,dic_cabecalho,lst_rodape,dic_filtro
 
 """relatorio_norma.py
    External method para gerar o arquivo rml do resultado de uma pesquisa de normas
@@ -17,7 +17,8 @@ def cabecalho(inf_basicas_dic,imagem):
     tmp_data += '\t\t\t\t<image x="2.1cm" y="25.7cm" width="59" height="62" file="' + imagem + '"/>\n'
     tmp_data += '\t\t\t\t<lines>2cm 25.4cm 19cm 25.4cm</lines>\n'
     tmp_data += '\t\t\t\t<setFont name="Helvetica-Bold" size="15"/>\n'
-    tmp_data+='\t\t\t\t<drawString x="5cm" y="27.2cm">' + dic_cabecalho['nom_casa'] + '</drawString>\n'
+    tmp_data += '\t\t\t\t<drawString x="5cm" y="27.2cm">' + \
+        dic_cabecalho['nom_casa'] + '</drawString>\n'
     tmp_data += '\t\t\t\t<setFont name="Helvetica" size="12"/>\n'
     tmp_data += '\t\t\t\t<drawString x="5cm" y="26.6cm">Sistema de Apoio ao Processo Legislativo</drawString>\n'
     tmp_data += '\t\t\t\t<setFont name="Helvetica-Bold" size="13"/>\n'
@@ -25,19 +26,24 @@ def cabecalho(inf_basicas_dic,imagem):
 
     return tmp_data
 
+
 def rodape(lst_rodape):
     """Gera o codigo rml do rodape"""
 
     tmp_data = ''
     tmp_data += '\t\t\t\t<lines>2cm 3.2cm 19cm 3.2cm</lines>\n'
     tmp_data += '\t\t\t\t<setFont name="Helvetica" size="8"/>\n'
-    tmp_data+='\t\t\t\t<drawString x="2cm" y="3.3cm">' + lst_rodape[2] + '</drawString>\n'
+    tmp_data += '\t\t\t\t<drawString x="2cm" y="3.3cm">' + \
+        lst_rodape[2] + '</drawString>\n'
     tmp_data += '\t\t\t\t<drawString x="17.9cm" y="3.3cm">Página <pageNumber/></drawString>\n'
-    tmp_data+='\t\t\t\t<drawCentredString x="10.5cm" y="2.7cm">' + lst_rodape[0] + '</drawCentredString>\n'
-    tmp_data+='\t\t\t\t<drawCentredString x="10.5cm" y="2.3cm">' + lst_rodape[1] + '</drawCentredString>\n'
+    tmp_data += '\t\t\t\t<drawCentredString x="10.5cm" y="2.7cm">' + \
+        lst_rodape[0] + '</drawCentredString>\n'
+    tmp_data += '\t\t\t\t<drawCentredString x="10.5cm" y="2.3cm">' + \
+        lst_rodape[1] + '</drawCentredString>\n'
 
     return tmp_data
 
+
 def paraStyle():
     """Gera o codigo rml que define o estilo dos paragrafos"""
 
@@ -56,6 +62,7 @@ def paraStyle():
 
     return tmp_data
 
+
 def normas(lst_normas):
     """Gera o codigo rml do conteudo da pesquisa de normas"""
 
@@ -86,11 +93,13 @@ def normas(lst_normas):
             txt_ementa = dic['txt_ementa'].replace('&', '&amp;')
             tmp_data += '\t\t<para style="P2">' + txt_ementa + '</para>\n'
         if dic['materia_vinculada'] != None:
-            tmp_data+='\t\t<para style="P2"><b>Matéria Legislativa:</b> ' + dic['materia_vinculada'] + '</para>\n'
+            tmp_data += '\t\t<para style="P2"><b>Matéria Legislativa:</b> ' + \
+                dic['materia_vinculada'] + '</para>\n'
 
     tmp_data += '\t</story>\n'
     return tmp_data
 
+
 def principal(imagem, lst_normas, dic_cabecalho, lst_rodape):
     """Funcao pricipal que gera a estrutura global do arquivo rml"""
 
@@ -124,4 +133,5 @@ def principal(imagem, lst_normas, dic_cabecalho, lst_rodape):
 
 #     return "/temp_folder/"+arquivoPdf
 
-# return principal(sessao,imagem,data,lst_normas,dic_cabecalho,lst_rodape,dic_filtro)
+# return
+# principal(sessao,imagem,data,lst_normas,dic_cabecalho,lst_rodape,dic_filtro)

sapl/relatorios/templates/pdf_norma_preparar_pysc.py

@@ -11,7 +11,8 @@ casa={}
 aux = context.sapl_documentos.props_sapl.propertyItems()
 for item in aux:
     casa[item[0]] = item[1]
-localidade=context.zsql.localidade_obter_zsql(cod_localidade=casa["cod_localidade"])
+localidade = context.zsql.localidade_obter_zsql(
+    cod_localidade=casa["cod_localidade"])
 if len(casa["num_cep"]) == 8:
     cep = casa["num_cep"][:4] + "-" + casa["num_cep"][5:]
 else:
@@ -23,7 +24,8 @@ if cep!="":
         linha1 = linha1 + " - "
     linha1 = linha1 + "CEP " + cep
 if localidade[0].nom_localidade != "" and localidade[0].nom_localidade != None:
-  linha1 = linha1 + " - "+localidade[0].nom_localidade+" "+localidade[0].sgl_uf
+    linha1 = linha1 + " - " + \
+        localidade[0].nom_localidade + " " + localidade[0].sgl_uf
 if casa["num_tel"] != "" and casa["num_tel"] != None:
     linha1 = linha1 + " Tel.: " + casa["num_tel"]
 
@@ -57,20 +59,27 @@ else:
 normas = []
 REQUEST = context.REQUEST
 for norma in context.zsql.norma_juridica_obter_zsql(tip_norma=REQUEST['lst_tip_norma'], num_norma=REQUEST['txt_numero'],
-                                           ano_norma=REQUEST['txt_ano'], des_assunto=REQUEST['txt_assunto'], 
-                                           cod_assunto=REQUEST['lst_assunto_norma'], dat_norma=REQUEST['dt_norma'],
-                                           dat_norma2=REQUEST['dt_norma2'], dat_publicacao=REQUEST['dt_public'],
+                                                    ano_norma=REQUEST['txt_ano'], des_assunto=REQUEST[
+                                                        'txt_assunto'],
+                                                    cod_assunto=REQUEST[
+                                                        'lst_assunto_norma'], dat_norma=REQUEST['dt_norma'],
+                                                    dat_norma2=REQUEST[
+                                                        'dt_norma2'], dat_publicacao=REQUEST['dt_public'],
                                                     dat_publicacao2=REQUEST['dt_public2'], rd_ordem=REQUEST['rd_ordenacao']):
 
     dic = {}
 
-        dic['titulo']=norma.sgl_tipo_norma+" Nº  "+str(norma.num_norma)+" de "+str(norma.dat_norma)+" - "+norma.des_tipo_norma
+    dic['titulo'] = norma.sgl_tipo_norma + " Nº  " + \
+        str(norma.num_norma) + " de " + \
+        str(norma.dat_norma) + " - " + norma.des_tipo_norma
     dic['txt_ementa'] = norma.txt_ementa
 
     dic['materia_vinculada'] = " "
     if norma.cod_materia != None:
         for materia_vinculada in context.zsql.materia_obter_zsql(cod_materia=str(norma.cod_materia)):
-               dic['materia_vinculada']=materia_vinculada.sgl_tipo_materia+" "+str(materia_vinculada.num_ident_basica)+"/"+str(materia_vinculada.ano_ident_basica)
+            dic['materia_vinculada'] = materia_vinculada.sgl_tipo_materia + " " + \
+                str(materia_vinculada.num_ident_basica) + "/" + \
+                str(materia_vinculada.ano_ident_basica)
 
     normas.append(dic)
 
@@ -84,10 +93,12 @@ filtro['assunto']=REQUEST.txt_assunto
 filtro['tipo_norma'] = ''
 if REQUEST.lst_tip_norma != '':
     for tipo_norma in context.zsql.tipo_norma_juridica_obter_zsql(ind_excluido=0, tip_norma=REQUEST.lst_tip_norma):
-        filtro['tipo_norma']= tipo_norma.sgl_tipo_norma + ' - ' + tipo_norma.des_tipo_norma
+        filtro['tipo_norma'] = tipo_norma.sgl_tipo_norma + \
+            ' - ' + tipo_norma.des_tipo_norma
 
 sessao = session.id
-caminho = context.pdf_norma_gerar(sessao,imagem,data,normas,cabecalho,rodape,filtro)
+caminho = context.pdf_norma_gerar(
+    sessao, imagem, data, normas, cabecalho, rodape, filtro)
 if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:

sapl/relatorios/templates/pdf_ordem_dia_preparar_pysc.py

@@ -9,35 +9,46 @@ if context.REQUEST['cod_sessao_plen']!='':
     pauta = []  # lista contendo a pauta da ordem do dia a ser impressa
     data = ""
     for dat_sessao in context.zsql.sessao_plenaria_obter_zsql(cod_sessao_plen=cod_sessao_plen, ind_excluido=0):
-        data = context.pysc.data_converter_pysc(dat_sessao.dat_inicio_sessao) # converte data para formato yyyy/mm/dd
-        dat_ordem = context.pysc.data_converter_pysc(dat_sessao.dat_inicio_sessao) # converte data para formato yyyy/mm/dd
+        # converte data para formato yyyy/mm/dd
+        data = context.pysc.data_converter_pysc(dat_sessao.dat_inicio_sessao)
+        dat_ordem = context.pysc.data_converter_pysc(
+            dat_sessao.dat_inicio_sessao)  # converte data para formato yyyy/mm/dd
     # seleciona dados da sessão plenária
     for sp in context.zsql.sessao_plenaria_obter_zsql(dat_inicio_sessao=data, ind_excluido=0):
         dicsp = {}  # dicionário que armazenará os dados a serem impressos de uma sessão plenária
-        ts = context.zsql.tipo_sessao_plenaria_obter_zsql(tip_sessao=sp.tip_sessao)[0]
-        dicsp["sessao"] = str(sp.num_sessao_plen)+"ª Sessao "+ts.nom_sessao+" da "+str(sp.num_sessao_leg)+"ª Sessao Legislativa da "+str(sp.num_legislatura)+"ª Legislatura"
-        dia = context.pysc.data_converter_por_extenso_pysc(data=sp.dat_inicio_sessao)
+        ts = context.zsql.tipo_sessao_plenaria_obter_zsql(
+            tip_sessao=sp.tip_sessao)[0]
+        dicsp["sessao"] = str(sp.num_sessao_plen) + "ª Sessao " + ts.nom_sessao + " da " + str(
+            sp.num_sessao_leg) + "ª Sessao Legislativa da " + str(sp.num_legislatura) + "ª Legislatura"
+        dia = context.pysc.data_converter_por_extenso_pysc(
+            data=sp.dat_inicio_sessao)
         hora = context.pysc.hora_formatar_pysc(hora=sp.hr_inicio_sessao)
-        dicsp["datasessao"] = "Dia "+str(dia)+" ("+str(sp.dia_sessao)+") - Inicio as "+hora
+        dicsp["datasessao"] = "Dia " + \
+            str(dia) + " (" + str(sp.dia_sessao) + ") - Inicio as " + hora
         splen.append(dicsp)
         # seleciona as matérias que compõem a pauta na data escolhida
     for ordem in context.zsql.ordem_dia_obter_zsql(dat_ordem=data, ind_excluido=0):
         # seleciona os detalhes de uma matéria
-        materia = context.zsql.materia_obter_zsql(cod_materia=ordem.cod_materia)[0]
+        materia = context.zsql.materia_obter_zsql(
+            cod_materia=ordem.cod_materia)[0]
         dic = {}  # dicionário que armazenará os dados a serem impressos de uma matéria
         dic["num_ordem"] = ordem.num_ordem
-        dic["id_materia"] = materia.des_tipo_materia+" - Nº "+str(materia.num_ident_basica)+"/"+str(materia.ano_ident_basica) 
+        dic["id_materia"] = materia.des_tipo_materia + " - Nº " + \
+            str(materia.num_ident_basica) + "/" + str(materia.ano_ident_basica)
         # dic["id_materia"] = materia.sgl_tipo_materia+" - "+str(materia.num_ident_basica)+"/"+str(materia.ano_ident_basica)+" - "+materia.des_tipo_materia
         dic["txt_ementa"] = ordem.txt_observacao
         # numeracao do processo 26/02/2011
         dic["des_numeracao"] = ""
-        numeracao = context.zsql.numeracao_obter_zsql(cod_materia=ordem.cod_materia)
+        numeracao = context.zsql.numeracao_obter_zsql(
+            cod_materia=ordem.cod_materia)
         if len(numeracao):
             numeracao = numeracao[0]
-           dic["des_numeracao"] = str(numeracao.num_materia)+"/"+str(numeracao.ano_materia) 
+            dic["des_numeracao"] = str(
+                numeracao.num_materia) + "/" + str(numeracao.ano_materia)
         dic["des_turno"] = ""
         dic["des_situacao"] = ""
-        tramitacao = context.zsql.tramitacao_obter_zsql(cod_materia=ordem.cod_materia, ind_ult_tramitacao=1)
+        tramitacao = context.zsql.tramitacao_obter_zsql(
+            cod_materia=ordem.cod_materia, ind_ult_tramitacao=1)
         if len(tramitacao):
             tramitacao = tramitacao[0]
             if tramitacao.sgl_turno != "":
@@ -50,7 +61,8 @@ if context.REQUEST['cod_sessao_plen']!='':
                 dic["des_situacao"] = " "
 
         dic["nom_autor"] = ''
-        autoria = context.zsql.autoria_obter_zsql(cod_materia=ordem.cod_materia, ind_primeiro_autor=1)        
+        autoria = context.zsql.autoria_obter_zsql(
+            cod_materia=ordem.cod_materia, ind_primeiro_autor=1)
         if len(autoria):  # se existe autor
             autoria = autoria[0]
         try:
@@ -59,11 +71,13 @@ if context.REQUEST['cod_sessao_plen']!='':
                 autor = autor[0]
 
             if autor.des_tipo_autor == "Parlamentar":
-             parlamentar = context.zsql.parlamentar_obter_zsql(cod_parlamentar=autor.cod_parlamentar)[0]		
+                parlamentar = context.zsql.parlamentar_obter_zsql(
+                    cod_parlamentar=autor.cod_parlamentar)[0]
                 dic["nom_autor"] = parlamentar.nom_parlamentar
 
             elif autor.des_tipo_autor == "Comissao":
-               comissao = context.zsql.comissao_obter_zsql(cod_comissao=autor.cod_comissao)[0]
+                comissao = context.zsql.comissao_obter_zsql(
+                    cod_comissao=autor.cod_comissao)[0]
                 dic["nom_autor"] = comissao.nom_comissao
             else:
                 dic["nom_autor"] = autor.nom_autor
@@ -71,9 +85,12 @@ if context.REQUEST['cod_sessao_plen']!='':
             pass
         lst_relator = []  # lista contendo os relatores da matéria
         for relatoria in context.zsql.relatoria_obter_zsql(cod_materia=ordem.cod_materia):
-            parlamentar = context.zsql.parlamentar_obter_zsql(cod_parlamentar=relatoria.cod_parlamentar)[0]
-            comissao = context.zsql.comissao_obter_zsql(cod_comissao=relatoria.cod_comissao)[0]
-            lst_relator.append(parlamentar.nom_parlamentar+" - "+comissao.nom_comissao)
+            parlamentar = context.zsql.parlamentar_obter_zsql(
+                cod_parlamentar=relatoria.cod_parlamentar)[0]
+            comissao = context.zsql.comissao_obter_zsql(
+                cod_comissao=relatoria.cod_comissao)[0]
+            lst_relator.append(parlamentar.nom_parlamentar +
+                               " - " + comissao.nom_comissao)
         if not len(lst_relator):
             lst_relator = ['']
         dic["lst_relator"] = lst_relator
@@ -81,14 +98,16 @@ if context.REQUEST['cod_sessao_plen']!='':
         # adiciona o dicionário na pauta
         pauta.append(dic)
 
-    # obtém as propriedades da casa legislativa para montar o cabeçalho e o rodapé da página
+    # obtém as propriedades da casa legislativa para montar o cabeçalho e o
+    # rodapé da página
     casa = {}
     aux = context.sapl_documentos.props_sapl.propertyItems()
     for item in aux:
         casa[item[0]] = item[1]
 
     # obtém a localidade
-    localidade = context.zsql.localidade_obter_zsql(cod_localidade=casa["cod_localidade"])
+    localidade = context.zsql.localidade_obter_zsql(
+        cod_localidade=casa["cod_localidade"])
 
     # monta o cabeçalho da página
     cabecalho = {}
@@ -103,7 +122,8 @@ if context.REQUEST['cod_sessao_plen']!='':
 
     # tenta buscar o logotipo da casa LOGO_CASA
     if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
-        imagem = context.sapl_documentos.props_sapl['logo_casa.gif'].absolute_url()
+        imagem = context.sapl_documentos.props_sapl[
+            'logo_casa.gif'].absolute_url()
     else:
         imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
@@ -118,7 +138,8 @@ if context.REQUEST['cod_sessao_plen']!='':
             linha1 = linha1 + "  "
         linha1 = linha1 + " CEP: " + num_cep
     if localidade[0].nom_localidade != None and localidade[0].nom_localidade != "":
-        linha1 = linha1 +"   "+localidade[0].nom_localidade +" - "+localidade[0].sgl_uf
+        linha1 = linha1 + "   " + \
+            localidade[0].nom_localidade + " - " + localidade[0].sgl_uf
     if casa["num_tel"] != None and casa["num_tel"] != "":
         linha1 = linha1 + "   Tel.: " + casa["num_tel"]
 
@@ -131,7 +152,8 @@ if context.REQUEST['cod_sessao_plen']!='':
     rodape = [linha1, linha2, dat_emissao]
 
     sessao = session.id
-    caminho = context.pdf_ordem_dia_gerar( sessao, imagem, dat_ordem, splen, pauta, cabecalho, rodape)
+    caminho = context.pdf_ordem_dia_gerar(
+        sessao, imagem, dat_ordem, splen, pauta, cabecalho, rodape)
     if caminho == 'aviso':
         return response.redirect('mensagem_emitir_proc')
     else:

sapl/relatorios/templates/pdf_pauta_sessao_gerar.py

@@ -23,7 +23,9 @@ def cabecalho(inf_basicas_dic, imagem):
     tmp += '\t\t\t\t<setFont name="Helvetica-Bold" size="12"/>\n'
     tmp += '\t\t\t\t<drawString x="4.2cm" y="25cm">Pauta da ' + str(inf_basicas_dic['num_sessao_plen']) + 'ª Reunião ' + str(inf_basicas_dic['nom_sessao']) + ' da ' + str(
         inf_basicas_dic['num_sessao_leg']) + 'ª Sessão Legislativa da </drawString>\n'
-    tmp += '\t\t\t\t<drawString x="6.7cm" y="24.5cm">' + str(inf_basicas_dic['num_legislatura']) + ' Legislatura </drawString>\n'
+    tmp += '\t\t\t\t<drawString x="6.7cm" y="24.5cm">' + \
+        str(inf_basicas_dic['num_legislatura']) + \
+        ' Legislatura </drawString>\n'
     return tmp
 
 

sapl/relatorios/templates/pdf_pauta_sessao_preparar_pysc.py

@@ -7,14 +7,16 @@ session= request.SESSION
 if context.REQUEST['data'] != '':
     dat_inicio_sessao = context.REQUEST['data']
     pauta = []  # lista contendo a pauta da ordem do dia a ser impressa
-    data = context.pysc.data_converter_pysc(dat_inicio_sessao) # converte data para formato yyyy/mm/dd
+    # converte data para formato yyyy/mm/dd
+    data = context.pysc.data_converter_pysc(dat_inicio_sessao)
     codigo = context.REQUEST['cod_sessao_plen']
 
     # seleciona as matérias que compõem a pauta na data escolhida
     for sessao in context.zsql.sessao_plenaria_obter_zsql(dat_inicio_sessao=data, cod_sessao_plen=codigo, ind_excluido=0):
         inf_basicas_dic = {}  # dicionário que armazenará as informacoes basicas da sessao plenaria
         # seleciona o tipo da sessao plenaria
-        tipo_sessao = context.zsql.tipo_sessao_plenaria_obter_zsql(tip_sessao=sessao.tip_sessao,ind_excluido=0)[0]
+        tipo_sessao = context.zsql.tipo_sessao_plenaria_obter_zsql(
+            tip_sessao=sessao.tip_sessao, ind_excluido=0)[0]
         inf_basicas_dic["nom_sessao"] = tipo_sessao.nom_sessao
         inf_basicas_dic["num_sessao_plen"] = sessao.num_sessao_plen
         inf_basicas_dic["nom_sessao"] = tipo_sessao.nom_sessao
@@ -30,40 +32,52 @@ if context.REQUEST['data']!='':
         for expediente_materia in context.zsql.votacao_expediente_materia_obter_zsql(dat_ordem=data, cod_sessao_plen=codigo, ind_excluido=0):
 
             # seleciona os detalhes de uma matéria
-            materia = context.zsql.materia_obter_zsql(cod_materia=expediente_materia.cod_materia)[0]
+            materia = context.zsql.materia_obter_zsql(
+                cod_materia=expediente_materia.cod_materia)[0]
 
             dic_expediente_materia = {}
             dic_expediente_materia["num_ordem"] = expediente_materia.num_ordem
-            dic_expediente_materia["id_materia"] = materia.sgl_tipo_materia+" - "+materia.des_tipo_materia+" No. "+str(materia.num_ident_basica)+"/"+str(materia.ano_ident_basica)
+            dic_expediente_materia["id_materia"] = materia.sgl_tipo_materia + " - " + materia.des_tipo_materia + \
+                " No. " + str(materia.num_ident_basica) + "/" + \
+                str(materia.ano_ident_basica)
             dic_expediente_materia["txt_ementa"] = materia.txt_ementa
-            dic_expediente_materia["ordem_observacao"] = expediente_materia.ordem_observacao
+            dic_expediente_materia[
+                "ordem_observacao"] = expediente_materia.ordem_observacao
 
             dic_expediente_materia["des_numeracao"] = ""
-            numeracao = context.zsql.numeracao_obter_zsql(cod_materia=expediente_materia.cod_materia)
+            numeracao = context.zsql.numeracao_obter_zsql(
+                cod_materia=expediente_materia.cod_materia)
             if len(numeracao):
                 numeracao = numeracao[0]
-               dic_expediente_materia["des_numeracao"] = str(numeracao.num_materia)+"/"+str(numeracao.ano_materia)
+                dic_expediente_materia["des_numeracao"] = str(
+                    numeracao.num_materia) + "/" + str(numeracao.ano_materia)
 
             dic_expediente_materia["nom_autor"] = ''
-            autoria = context.zsql.autoria_obter_zsql(cod_materia=expediente_materia.cod_materia, ind_primeiro_autor=1)        
+            autoria = context.zsql.autoria_obter_zsql(
+                cod_materia=expediente_materia.cod_materia, ind_primeiro_autor=1)
             if len(autoria) > 0:  # se existe autor
                 autoria = autoria[0]
-                autor = context.zsql.autor_obter_zsql(cod_autor=autoria.cod_autor)
+                autor = context.zsql.autor_obter_zsql(
+                    cod_autor=autoria.cod_autor)
                 if len(autor) > 0:
                     autor = autor[0]
 
                 if autor.des_tipo_autor == "Parlamentar":
-                    parlamentar = context.zsql.parlamentar_obter_zsql(cod_parlamentar=autor.cod_parlamentar)[0]     
-                    dic_expediente_materia["nom_autor"] = parlamentar.nom_parlamentar
+                    parlamentar = context.zsql.parlamentar_obter_zsql(
+                        cod_parlamentar=autor.cod_parlamentar)[0]
+                    dic_expediente_materia[
+                        "nom_autor"] = parlamentar.nom_parlamentar
                 elif autor.des_tipo_autor == "Comissao":
-                    comissao = context.zsql.comissao_obter_zsql(cod_comissao=autor.cod_comissao)[0]
+                    comissao = context.zsql.comissao_obter_zsql(
+                        cod_comissao=autor.cod_comissao)[0]
                     dic_expediente_materia["nom_autor"] = comissao.nom_comissao
                 else:
                     dic_expediente_materia["nom_autor"] = autor.nom_autor
 
             dic_expediente_materia["des_turno"] = ""
             dic_expediente_materia["des_situacao"] = ""
-            tramitacao = context.zsql.tramitacao_obter_zsql(cod_materia=expediente_materia.cod_materia, ind_ult_tramitacao=1)
+            tramitacao = context.zsql.tramitacao_obter_zsql(
+                cod_materia=expediente_materia.cod_materia, ind_ult_tramitacao=1)
             if len(tramitacao):
                 tramitacao = tramitacao[0]
                 if tramitacao.sgl_turno != "":
@@ -76,46 +90,55 @@ if context.REQUEST['data']!='':
                     dic_expediente_materia["des_situacao"] = " "
             lst_expediente_materia.append(dic_expediente_materia)
 
-        
         # Lista das matérias da Ordem do Dia, incluindo o status da tramitação
         lst_votacao = []
         for votacao in context.zsql.votacao_ordem_dia_obter_zsql(dat_ordem=data, cod_sessao_plen=codigo, ind_excluido=0):
 
             # seleciona os detalhes de uma matéria
-            materia = context.zsql.materia_obter_zsql(cod_materia=votacao.cod_materia)[0]
+            materia = context.zsql.materia_obter_zsql(
+                cod_materia=votacao.cod_materia)[0]
 
             dic_votacao = {}
             dic_votacao["num_ordem"] = votacao.num_ordem
-            dic_votacao["id_materia"] = materia.sgl_tipo_materia+" - "+materia.des_tipo_materia+" No. "+str(materia.num_ident_basica)+"/"+str(materia.ano_ident_basica)
+            dic_votacao["id_materia"] = materia.sgl_tipo_materia + " - " + materia.des_tipo_materia + \
+                " No. " + str(materia.num_ident_basica) + "/" + \
+                str(materia.ano_ident_basica)
             dic_votacao["txt_ementa"] = materia.txt_ementa
             dic_votacao["ordem_observacao"] = votacao.ordem_observacao
 
             dic_votacao["des_numeracao"] = ""
-            numeracao = context.zsql.numeracao_obter_zsql(cod_materia=votacao.cod_materia)
+            numeracao = context.zsql.numeracao_obter_zsql(
+                cod_materia=votacao.cod_materia)
             if len(numeracao):
                 numeracao = numeracao[0]
-               dic_votacao["des_numeracao"] = str(numeracao.num_materia)+"/"+str(numeracao.ano_materia)
+                dic_votacao["des_numeracao"] = str(
+                    numeracao.num_materia) + "/" + str(numeracao.ano_materia)
 
             dic_votacao["nom_autor"] = ''
-            autoria = context.zsql.autoria_obter_zsql(cod_materia=votacao.cod_materia, ind_primeiro_autor=1)        
+            autoria = context.zsql.autoria_obter_zsql(
+                cod_materia=votacao.cod_materia, ind_primeiro_autor=1)
             if len(autoria) > 0:  # se existe autor
                 autoria = autoria[0]
-                autor = context.zsql.autor_obter_zsql(cod_autor=autoria.cod_autor)
+                autor = context.zsql.autor_obter_zsql(
+                    cod_autor=autoria.cod_autor)
                 if len(autor) > 0:
                     autor = autor[0]
 
                 if autor.des_tipo_autor == "Parlamentar":
-                    parlamentar = context.zsql.parlamentar_obter_zsql(cod_parlamentar=autor.cod_parlamentar)[0]     
+                    parlamentar = context.zsql.parlamentar_obter_zsql(
+                        cod_parlamentar=autor.cod_parlamentar)[0]
                     dic_votacao["nom_autor"] = parlamentar.nom_parlamentar
                 elif autor.des_tipo_autor == "Comissao":
-                    comissao = context.zsql.comissao_obter_zsql(cod_comissao=autor.cod_comissao)[0]
+                    comissao = context.zsql.comissao_obter_zsql(
+                        cod_comissao=autor.cod_comissao)[0]
                     dic_votacao["nom_autor"] = comissao.nom_comissao
                 else:
                     dic_votacao["nom_autor"] = autor.nom_autor
 
             dic_votacao["des_turno"] = ""
             dic_votacao["des_situacao"] = ""
-            tramitacao = context.zsql.tramitacao_obter_zsql(cod_materia=votacao.cod_materia, ind_ult_tramitacao=1)
+            tramitacao = context.zsql.tramitacao_obter_zsql(
+                cod_materia=votacao.cod_materia, ind_ult_tramitacao=1)
             if len(tramitacao):
                 tramitacao = tramitacao[0]
                 if tramitacao.sgl_turno != "":
@@ -128,12 +151,14 @@ if context.REQUEST['data']!='':
                     dic_votacao["des_situacao"] = " "
             lst_votacao.append(dic_votacao)
 
-    # obtém as propriedades da casa legislativa para montar o cabeçalho e o rodapé da página
+    # obtém as propriedades da casa legislativa para montar o cabeçalho e o
+    # rodapé da página
     cabecalho = {}
 
     # tenta buscar o logotipo da casa LOGO_CASA
     if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
-        imagem = context.sapl_documentos.props_sapl['logo_casa.gif'].absolute_url()
+        imagem = context.sapl_documentos.props_sapl[
+            'logo_casa.gif'].absolute_url()
     else:
         imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
@@ -142,7 +167,8 @@ if context.REQUEST['data']!='':
     aux = context.sapl_documentos.props_sapl.propertyItems()
     for item in aux:
         casa[item[0]] = item[1]
-    localidade=context.zsql.localidade_obter_zsql(cod_localidade=casa["cod_localidade"])
+    localidade = context.zsql.localidade_obter_zsql(
+        cod_localidade=casa["cod_localidade"])
     data_emissao = DateTime().strftime("%d/%m/%Y")
     rodape = casa
     rodape['data_emissao'] = data_emissao
@@ -155,7 +181,8 @@ if context.REQUEST['data']!='':
 
 #    return lst_votacao
     sessao = session.id
-    caminho = context.pdf_pauta_sessao_gerar(rodape, sessao, imagem, inf_basicas_dic, lst_votacao, lst_expediente_materia)
+    caminho = context.pdf_pauta_sessao_gerar(
+        rodape, sessao, imagem, inf_basicas_dic, lst_votacao, lst_expediente_materia)
     if caminho == 'aviso':
         return response.redirect('mensagem_emitir_proc')
     else:

sapl/relatorios/templates/pdf_protocolo_gerar.py

@@ -1,4 +1,4 @@
-##parameters=sessao,imagem,data,lst_protocolos,dic_cabecalho,lst_rodape,dic_filtro
+# parameters=sessao,imagem,data,lst_protocolos,dic_cabecalho,lst_rodape,dic_filtro
 
 """relatorio_protocolo.py
    External method para gerar o arquivo rml do resultado de uma pesquisa de protocolos
@@ -17,7 +17,8 @@ def cabecalho(dic_cabecalho,imagem):
     tmp_data += '\t\t\t\t<image x="2.1cm" y="25.7cm" width="59" height="62" file="' + imagem + '"/>\n'
     tmp_data += '\t\t\t\t<lines>2cm 25.4cm 19cm 25.4cm</lines>\n'
     tmp_data += '\t\t\t\t<setFont name="Helvetica-Bold" size="15"/>\n'
-    tmp_data+='\t\t\t\t<drawString x="5cm" y="27.2cm">' + dic_cabecalho['nom_casa'] + '</drawString>\n'
+    tmp_data += '\t\t\t\t<drawString x="5cm" y="27.2cm">' + \
+        dic_cabecalho['nom_casa'] + '</drawString>\n'
     tmp_data += '\t\t\t\t<setFont name="Helvetica" size="12"/>\n'
     tmp_data += '\t\t\t\t<drawString x="5cm" y="26.6cm">Sistema de Apoio ao Processo Legislativo</drawString>\n'
     tmp_data += '\t\t\t\t<setFont name="Helvetica-Bold" size="13"/>\n'
@@ -25,19 +26,24 @@ def cabecalho(dic_cabecalho,imagem):
 
     return tmp_data
 
+
 def rodape(lst_rodape):
     """Gera o codigo rml do rodape"""
 
     tmp_data = ''
     tmp_data += '\t\t\t\t<lines>2cm 3.2cm 19cm 3.2cm</lines>\n'
     tmp_data += '\t\t\t\t<setFont name="Helvetica" size="8"/>\n'
-    tmp_data+='\t\t\t\t<drawString x="2cm" y="3.3cm">' + lst_rodape[2] + '</drawString>\n'
+    tmp_data += '\t\t\t\t<drawString x="2cm" y="3.3cm">' + \
+        lst_rodape[2] + '</drawString>\n'
     tmp_data += '\t\t\t\t<drawString x="17.9cm" y="3.3cm">Página <pageNumber/></drawString>\n'
-    tmp_data+='\t\t\t\t<drawCentredString x="10.5cm" y="2.7cm">' + lst_rodape[0] + '</drawCentredString>\n'
-    tmp_data+='\t\t\t\t<drawCentredString x="10.5cm" y="2.3cm">' + lst_rodape[1] + '</drawCentredString>\n'
+    tmp_data += '\t\t\t\t<drawCentredString x="10.5cm" y="2.7cm">' + \
+        lst_rodape[0] + '</drawCentredString>\n'
+    tmp_data += '\t\t\t\t<drawCentredString x="10.5cm" y="2.3cm">' + \
+        lst_rodape[1] + '</drawCentredString>\n'
 
     return tmp_data
 
+
 def paraStyle():
     """Gera o codigo rml que define o estilo dos paragrafos"""
 
@@ -56,6 +62,7 @@ def paraStyle():
 
     return tmp_data
 
+
 def protocolos(lst_protocolos):
     """Gera o codigo rml do conteudo da pesquisa de protocolos"""
 
@@ -78,7 +85,8 @@ def protocolos(lst_protocolos):
 
         # protocolos
         if dic['titulo'] != None:
-            tmp_data+='\t\t<para style="P1">Protocolo ' + dic['titulo'] + '</para>\n'
+            tmp_data += '\t\t<para style="P1">Protocolo ' + \
+                dic['titulo'] + '</para>\n'
             tmp_data += '\t\t<para style="P1">\n'
             tmp_data += '\t\t\t<font color="white"> </font>\n'
             tmp_data += '\t\t</para>\n'
@@ -86,21 +94,27 @@ def protocolos(lst_protocolos):
             txt_assunto = dic['txt_assunto'].replace('&', '&amp;')
             tmp_data += '\t\t<para style="P2">' + txt_assunto + '</para>\n'
         if dic['txt_interessado'] != None:
-           tmp_data+='\t\t<para style="P2"><b>Interessado:</b> ' + dic['txt_interessado'] + '</para>\n'
+            tmp_data += '\t\t<para style="P2"><b>Interessado:</b> ' + \
+                dic['txt_interessado'] + '</para>\n'
         elif dic['nom_autor'] != None:
-           tmp_data+='\t\t<para style="P2"><b>Autor:</b> ' + dic['nom_autor'] + '</para>\n'
+            tmp_data += '\t\t<para style="P2"><b>Autor:</b> ' + \
+                dic['nom_autor'] + '</para>\n'
         if dic['natureza'] != None:
-            tmp_data+='\t\t<para style="P2"><b>Natureza Processo:</b> ' + dic['natureza'] + '</para>\n'
+            tmp_data += '\t\t<para style="P2"><b>Natureza Processo:</b> ' + \
+                dic['natureza'] + '</para>\n'
         if dic['processo'] != None:
-            tmp_data+='\t\t<para style="P2"><b>Classificação:</b> ' + dic['processo'] + '</para>\n'
+            tmp_data += '\t\t<para style="P2"><b>Classificação:</b> ' + \
+                dic['processo'] + '</para>\n'
         if dic['data'] != None:
-            tmp_data+='\t\t<para style="P2"><b>Data Protocolo:</b> ' + dic['data'] + '</para>\n'
+            tmp_data += '\t\t<para style="P2"><b>Data Protocolo:</b> ' + \
+                dic['data'] + '</para>\n'
         if dic['anulado'] != "":
             tmp_data += '\t\t<para style="P2"><b>** PROTOCOLO ANULADO **</b> ' '</para>\n'
 
     tmp_data += '\t</story>\n'
     return tmp_data
 
+
 def principal(imagem, lst_protocolos, dic_cabecalho, lst_rodape):
     """Funcao pricipal que gera a estrutura global do arquivo rml"""
 
@@ -134,4 +148,5 @@ def principal(imagem, lst_protocolos, dic_cabecalho, lst_rodape):
 
 #     return "/temp_folder/"+arquivoPdf
 
-# return principal(sessao,imagem,data,lst_protocolos,dic_cabecalho,lst_rodape,dic_filtro)
+# return
+# principal(sessao,imagem,data,lst_protocolos,dic_cabecalho,lst_rodape,dic_filtro)

sapl/relatorios/templates/pdf_protocolo_preparar_pysc.py

@@ -11,7 +11,8 @@ casa={}
 aux = context.sapl_documentos.props_sapl.propertyItems()
 for item in aux:
     casa[item[0]] = item[1]
-localidade=context.zsql.localidade_obter_zsql(cod_localidade=casa["cod_localidade"])
+localidade = context.zsql.localidade_obter_zsql(
+    cod_localidade=casa["cod_localidade"])
 if len(casa["num_cep"]) == 8:
     cep = casa["num_cep"][:4] + "-" + casa["num_cep"][5:]
 else:
@@ -23,7 +24,8 @@ if cep!="":
         linha1 = linha1 + " - "
     linha1 = linha1 + "CEP " + cep
 if localidade[0].nom_localidade != "" and localidade[0].nom_localidade != None:
-  linha1 = linha1 + " - "+localidade[0].nom_localidade+" "+localidade[0].sgl_uf
+    linha1 = linha1 + " - " + \
+        localidade[0].nom_localidade + " " + localidade[0].sgl_uf
 if casa["num_tel"] != "" and casa["num_tel"] != None:
     linha1 = linha1 + " Tel.: " + casa["num_tel"]
 
@@ -57,16 +59,22 @@ else:
 protocolos = []
 REQUEST = context.REQUEST
 for protocolo in context.zsql.protocolo_pesquisar_zsql(tip_protocolo=REQUEST['rad_tip_protocolo'],
-                              cod_protocolo=REQUEST['txt_num_protocolo'], ano_protocolo=REQUEST['txt_ano_protocolo'],
-                              tip_documento=REQUEST['lst_tip_documento'], tip_processo=REQUEST['rad_tip_processo'], 
-                              tip_materia=REQUEST['lst_tip_materia'], des_assunto=REQUEST['txt_assunto'], 
-                              cod_autor=REQUEST['hdn_cod_autor'], des_interessado=REQUEST['txa_txt_interessado'], 
+                                                       cod_protocolo=REQUEST['txt_num_protocolo'], ano_protocolo=REQUEST[
+                                                           'txt_ano_protocolo'],
+                                                       tip_documento=REQUEST['lst_tip_documento'], tip_processo=REQUEST[
+                                                           'rad_tip_processo'],
+                                                       tip_materia=REQUEST[
+                                                           'lst_tip_materia'], des_assunto=REQUEST['txt_assunto'],
+                                                       cod_autor=REQUEST['hdn_cod_autor'], des_interessado=REQUEST[
+    'txa_txt_interessado'],
         dat_apres=REQUEST['dt_apres'], dat_apres2=REQUEST['dt_apres2']):
     dic = {}
 
-        dic['titulo']=str(protocolo.cod_protocolo)+'/'+str(protocolo.ano_protocolo)
+    dic['titulo'] = str(protocolo.cod_protocolo) + '/' + \
+        str(protocolo.ano_protocolo)
 
-        dic['data']=context.pysc.iso_to_port_pysc(protocolo.dat_protocolo)+' - <b>Horário:</b>'+protocolo.hor_protocolo
+    dic['data'] = context.pysc.iso_to_port_pysc(
+        protocolo.dat_protocolo) + ' - <b>Horário:</b>' + protocolo.hor_protocolo
 
     dic['txt_assunto'] = protocolo.txt_assunto_ementa
 
@@ -110,7 +118,8 @@ filtro['autor']=REQUEST.hdn_cod_autor
 filtro['interessado'] = REQUEST.txa_txt_interessado
 
 sessao = session.id
-caminho = context.pdf_protocolo_gerar(sessao,imagem,data,protocolos,cabecalho,rodape,filtro)
+caminho = context.pdf_protocolo_gerar(
+    sessao, imagem, data, protocolos, cabecalho, rodape, filtro)
 if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:

sapl/relatorios/templates/pdf_sessao_plenaria_gerar.py

@@ -26,7 +26,9 @@ def cabecalho(inf_basicas_dic, imagem):
     tmp += '\t\t\t\t<setFont name="Helvetica-Bold" size="12"/>\n'
     tmp += '\t\t\t\t<drawString x="4.2cm" y="25cm">Resumo da ' + str(inf_basicas_dic['num_sessao_plen']) + 'ª Reunião ' + str(inf_basicas_dic['nom_sessao']) + ' da ' + str(
         inf_basicas_dic['num_sessao_leg']) + 'ª Sessão Legislativa da </drawString>\n'
-    tmp += '\t\t\t\t<drawString x="6.7cm" y="24.5cm">' + str(inf_basicas_dic['num_legislatura']) + ' Legislatura </drawString>\n'
+    tmp += '\t\t\t\t<drawString x="6.7cm" y="24.5cm">' + \
+        str(inf_basicas_dic['num_legislatura']) + \
+        ' Legislatura </drawString>\n'
     return tmp
 
 
@@ -109,8 +111,11 @@ def inf_basicas(inf_basicas_dic):
         nom_sessao + '</para>\n'
     tmp += '\t\t<para style="P2" spaceAfter="5"><b>Abertura: </b> ' + \
         dat_inicio_sessao + ' <b>- </b> ' + hr_inicio_sessao + '</para>\n'
+
+    data_fim_sessao = dat_fim_sessao + ' <b>- </b> ' if dat_fim_sessao else ''
+
     tmp += '\t\t<para style="P2" spaceAfter="5"><b>Encerramento: </b> ' + \
-        dat_fim_sessao + ' <b>- </b> ' + hr_fim_sessao + '</para>\n'
+        dat_fim_sessao + hr_fim_sessao + '</para>\n'
 
     return tmp
 
@@ -183,7 +188,8 @@ def expediente_materia(lst_expediente_materia):
         txt_ementa = expediente_materia['txt_ementa'].replace('&', '&amp;')
         tmp += '<td><para style="P4">' + txt_ementa + '</para></td>\n'
         tmp += '<td><para style="P3"><b>' + \
-            str(expediente_materia['nom_resultado']) + '</b></para>\n' + '<para style="P3">'
+            str(expediente_materia['nom_resultado']) + \
+            '</b></para>\n' + '<para style="P3">'
         if expediente_materia['votacao_observacao'] != txt_ementa:
             tmp += str(expediente_materia['votacao_observacao'])
         else:
@@ -242,7 +248,8 @@ def votacao(lst_votacao):
         txt_ementa = votacao['txt_ementa'].replace('&', '&amp;')
         tmp += '<td><para style="P4">' + txt_ementa + '</para></td>\n'
         tmp += '<td><para style="P3"><b>' + \
-            str(votacao['nom_resultado']) + '</b></para>\n' + '<para style="P3">'
+            str(votacao['nom_resultado']) + \
+            '</b></para>\n' + '<para style="P3">'
         if votacao['votacao_observacao'] != txt_ementa:
             tmp += str(votacao['votacao_observacao'])
         else:

sapl/relatorios/templates/pdf_sessao_plenaria_preparar_pysc.py

@@ -7,14 +7,16 @@ session= request.SESSION
 if context.REQUEST['data'] != '':
     dat_inicio_sessao = context.REQUEST['data']
     pauta = []  # lista contendo a pauta da ordem do dia a ser impressa
-    data = context.pysc.data_converter_pysc(dat_inicio_sessao) # converte data para formato yyyy/mm/dd
+    # converte data para formato yyyy/mm/dd
+    data = context.pysc.data_converter_pysc(dat_inicio_sessao)
     codigo = context.REQUEST['cod_sessao_plen']
 
     # seleciona as matérias que compõem a pauta na data escolhida
     for sessao in context.zsql.sessao_plenaria_obter_zsql(dat_inicio_sessao=data, cod_sessao_plen=codigo, ind_excluido=0):
         inf_basicas_dic = {}  # dicionário que armazenará as informacoes basicas da sessao plenaria
         # seleciona o tipo da sessao plenaria
-        tipo_sessao = context.zsql.tipo_sessao_plenaria_obter_zsql(tip_sessao=sessao.tip_sessao,ind_excluido=0)[0]
+        tipo_sessao = context.zsql.tipo_sessao_plenaria_obter_zsql(
+            tip_sessao=sessao.tip_sessao, ind_excluido=0)[0]
         inf_basicas_dic["num_sessao_plen"] = sessao.num_sessao_plen
         inf_basicas_dic["nom_sessao"] = tipo_sessao.nom_sessao
         inf_basicas_dic["num_legislatura"] = sessao.num_legislatura
@@ -50,7 +52,8 @@ if context.REQUEST['data']!='':
         for tip_expediente in context.zsql.tipo_expediente_obter_zsql():
             for expediente in context.zsql.expediente_obter_zsql(cod_sessao_plen=sessao.cod_sessao_plen, cod_expediente=tip_expediente.cod_expediente, ind_excluido=0):
                 dic_expedientes = {}
-                dic_expedientes["nom_expediente"] = tip_expediente.nom_expediente
+                dic_expedientes[
+                    "nom_expediente"] = tip_expediente.nom_expediente
                 dic_expedientes["txt_expediente"] = expediente.txt_expediente
 
             if dic_expedientes:
@@ -61,19 +64,25 @@ if context.REQUEST['data']!='':
         for expediente_materia in context.zsql.votacao_expediente_materia_obter_zsql(dat_ordem=data, cod_sessao_plen=sessao.cod_sessao_plen, ind_excluido=0):
 
             # seleciona os detalhes de uma matéria
-            materia = context.zsql.materia_obter_zsql(cod_materia=expediente_materia.cod_materia)[0]
+            materia = context.zsql.materia_obter_zsql(
+                cod_materia=expediente_materia.cod_materia)[0]
 
             dic_expediente_materia = {}
             dic_expediente_materia["num_ordem"] = expediente_materia.num_ordem
-            dic_expediente_materia["id_materia"] = materia.sgl_tipo_materia+" "+materia.des_tipo_materia+" "+str(materia.num_ident_basica)+"/"+str(materia.ano_ident_basica)
+            dic_expediente_materia["id_materia"] = materia.sgl_tipo_materia + " " + materia.des_tipo_materia + \
+                " " + str(materia.num_ident_basica) + "/" + \
+                str(materia.ano_ident_basica)
             dic_expediente_materia["des_numeracao"] = ""
 
-            numeracao = context.zsql.numeracao_obter_zsql(cod_materia=expediente_materia.cod_materia)
+            numeracao = context.zsql.numeracao_obter_zsql(
+                cod_materia=expediente_materia.cod_materia)
             if len(numeracao):
                 numeracao = numeracao[0]
-               dic_expediente_materia["des_numeracao"] = str(numeracao.num_materia)+"/"+str(numeracao.ano_materia)
+                dic_expediente_materia["des_numeracao"] = str(
+                    numeracao.num_materia) + "/" + str(numeracao.ano_materia)
 
-            tram = context.zsql.tramitacao_turno_obter_zsql(cod_materia=materia.cod_materia, dat_inicio_sessao=data)
+            tram = context.zsql.tramitacao_turno_obter_zsql(
+                cod_materia=materia.cod_materia, dat_inicio_sessao=data)
             dic_expediente_materia["des_turno"] = ""
             if len(tram):
                 tram_turno = tram[0]
@@ -83,35 +92,46 @@ if context.REQUEST['data']!='':
                             dic_expediente_materia["des_turno"] = turno[1]
 
             dic_expediente_materia["txt_ementa"] = materia.txt_ementa
-            dic_expediente_materia["ordem_observacao"] = expediente_materia.ordem_observacao
+            dic_expediente_materia[
+                "ordem_observacao"] = expediente_materia.ordem_observacao
             dic_expediente_materia["nom_autor"] = ""
-            autoria = context.zsql.autoria_obter_zsql(cod_materia=expediente_materia.cod_materia, ind_primeiro_autor=1)        
+            autoria = context.zsql.autoria_obter_zsql(
+                cod_materia=expediente_materia.cod_materia, ind_primeiro_autor=1)
             if len(autoria) > 0:  # se existe autor
                 autoria = autoria[0]
-                autor = context.zsql.autor_obter_zsql(cod_autor=autoria.cod_autor)
+                autor = context.zsql.autor_obter_zsql(
+                    cod_autor=autoria.cod_autor)
                 if len(autor) > 0:
                     autor = autor[0]
                     try:
                         if autor.des_tipo_autor == "Parlamentar":
-                         parlamentar = context.zsql.parlamentar_obter_zsql(cod_parlamentar=autor.cod_parlamentar)[0]     
-                         dic_expediente_materia["nom_autor"] = parlamentar.nom_parlamentar
+                            parlamentar = context.zsql.parlamentar_obter_zsql(
+                                cod_parlamentar=autor.cod_parlamentar)[0]
+                            dic_expediente_materia[
+                                "nom_autor"] = parlamentar.nom_parlamentar
                         elif autor.des_tipo_autor == "Comissao":
-                         comissao = context.zsql.comissao_obter_zsql(cod_comissao=autor.cod_comissao)[0]
-                         dic_expediente_materia["nom_autor"] = comissao.nom_comissao
+                            comissao = context.zsql.comissao_obter_zsql(
+                                cod_comissao=autor.cod_comissao)[0]
+                            dic_expediente_materia[
+                                "nom_autor"] = comissao.nom_comissao
                         elif autor.nom_autor != "":
-                         dic_expediente_materia["nom_autor"] = autor.nom_autor
+                            dic_expediente_materia[
+                                "nom_autor"] = autor.nom_autor
                         else:
-                         dic_expediente_materia["nom_autor"] = autor.des_tipo_autor
+                            dic_expediente_materia[
+                                "nom_autor"] = autor.des_tipo_autor
                     except:
                         dic_expediente_materia["nom_autor"] = "NC-em"
 
             dic_expediente_materia["votacao_observacao"] = ""
             if expediente_materia.tip_resultado_votacao:
-                resultado = context.zsql.tipo_resultado_votacao_obter_zsql(tip_resultado_votacao=expediente_materia.tip_resultado_votacao, ind_excluido=0)
+                resultado = context.zsql.tipo_resultado_votacao_obter_zsql(
+                    tip_resultado_votacao=expediente_materia.tip_resultado_votacao, ind_excluido=0)
                 for i in resultado:
                     dic_expediente_materia["nom_resultado"] = i.nom_resultado
                     if expediente_materia.votacao_observacao:
-                        dic_expediente_materia["votacao_observacao"] = expediente_materia.votacao_observacao
+                        dic_expediente_materia[
+                            "votacao_observacao"] = expediente_materia.votacao_observacao
             else:
                 dic_expediente_materia["nom_resultado"] = "Matéria não votada"
                 dic_expediente_materia["votacao_observacao"] = "Vazio"
@@ -122,9 +142,12 @@ if context.REQUEST['data']!='':
         for orador_expediente in context.zsql.oradores_expediente_obter_zsql(cod_sessao_plen=sessao.cod_sessao_plen, ind_excluido=0):
             for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=orador_expediente.cod_parlamentar, ind_excluido=0):
                 dic_oradores_expediente = {}
-                dic_oradores_expediente["num_ordem"] = orador_expediente.num_ordem
-                dic_oradores_expediente["nom_parlamentar"] = parlamentar.nom_parlamentar
-                dic_oradores_expediente['sgl_partido'] = parlamentar.sgl_partido
+                dic_oradores_expediente[
+                    "num_ordem"] = orador_expediente.num_ordem
+                dic_oradores_expediente[
+                    "nom_parlamentar"] = parlamentar.nom_parlamentar
+                dic_oradores_expediente[
+                    'sgl_partido'] = parlamentar.sgl_partido
                 lst_oradores_expediente.append(dic_oradores_expediente)
 
         # Lista presença na ordem do dia
@@ -132,30 +155,39 @@ if context.REQUEST['data']!='':
         for presenca_ordem_dia in context.zsql.presenca_ordem_dia_obter_zsql(cod_sessao_plen=sessao.cod_sessao_plen, ind_excluido=0):
             for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=presenca_ordem_dia.cod_parlamentar, ind_excluido=0):
                 dic_presenca_ordem_dia = {}
-                dic_presenca_ordem_dia['nom_parlamentar'] = parlamentar.nom_parlamentar
+                dic_presenca_ordem_dia[
+                    'nom_parlamentar'] = parlamentar.nom_parlamentar
                 dic_presenca_ordem_dia['sgl_partido'] = parlamentar.sgl_partido
                 lst_presenca_ordem_dia.append(dic_presenca_ordem_dia)
 
-        # Lista das matérias da Ordem do Dia, incluindo o resultado das votacoes
+        # Lista das matérias da Ordem do Dia, incluindo o resultado das
+        # votacoes
         lst_votacao = []
         for votacao in context.zsql.votacao_ordem_dia_obter_zsql(dat_ordem=data, cod_sessao_plen=sessao.cod_sessao_plen, ind_excluido=0):
 
             # seleciona os detalhes de uma matéria
-            materia = context.zsql.materia_obter_zsql(cod_materia=votacao.cod_materia)[0]
+            materia = context.zsql.materia_obter_zsql(
+                cod_materia=votacao.cod_materia)[0]
 
             dic_votacao = {}
             dic_votacao["num_ordem"] = votacao.num_ordem
-            dic_votacao["id_materia"] = materia.sgl_tipo_materia+" "+materia.des_tipo_materia+" "+str(materia.num_ident_basica)+"/"+str(materia.ano_ident_basica)
+            dic_votacao["id_materia"] = materia.sgl_tipo_materia + " " + materia.des_tipo_materia + \
+                " " + str(materia.num_ident_basica) + "/" + \
+                str(materia.ano_ident_basica)
             dic_votacao["des_numeracao"] = ""
-            numeracao = context.zsql.numeracao_obter_zsql(cod_materia=votacao.cod_materia)
+            numeracao = context.zsql.numeracao_obter_zsql(
+                cod_materia=votacao.cod_materia)
             if len(numeracao):
                 numeracao = numeracao[0]
-               dic_votacao["des_numeracao"] = str(numeracao.num_materia)+"/"+str(numeracao.ano_materia)
+                dic_votacao["des_numeracao"] = str(
+                    numeracao.num_materia) + "/" + str(numeracao.ano_materia)
             dic_votacao["des_turno"] = ""
-            tramitacao = context.zsql.tramitacao_obter_zsql(cod_materia=materia.cod_materia, ind_ult_tramitacao=1)
+            tramitacao = context.zsql.tramitacao_obter_zsql(
+                cod_materia=materia.cod_materia, ind_ult_tramitacao=1)
             if len(tramitacao):
                 tramitacao = tramitacao[0]
-            tram = context.zsql.tramitacao_turno_obter_zsql(cod_materia=materia.cod_materia, dat_inicio_sessao=data)
+            tram = context.zsql.tramitacao_turno_obter_zsql(
+                cod_materia=materia.cod_materia, dat_inicio_sessao=data)
             if len(tram):
                 tram_turno = tram[0]
                 if tram_turno.sgl_turno != "":
@@ -165,18 +197,23 @@ if context.REQUEST['data']!='':
             dic_votacao["txt_ementa"] = materia.txt_ementa
             dic_votacao["ordem_observacao"] = votacao.ordem_observacao
             dic_votacao["nom_autor"] = ""
-            autoria = context.zsql.autoria_obter_zsql(cod_materia=votacao.cod_materia, ind_primeiro_autor=1)        
+            autoria = context.zsql.autoria_obter_zsql(
+                cod_materia=votacao.cod_materia, ind_primeiro_autor=1)
             if len(autoria) > 0:  # se existe autor
                 autoria = autoria[0]
-                autor = context.zsql.autor_obter_zsql(cod_autor=autoria.cod_autor)
+                autor = context.zsql.autor_obter_zsql(
+                    cod_autor=autoria.cod_autor)
                 if len(autor) > 0:
                     autor = autor[0]
                     try:
                         if autor.des_tipo_autor == "Parlamentar":
-                        parlamentar = context.zsql.parlamentar_obter_zsql(cod_parlamentar=autor.cod_parlamentar)[0]     
-                        dic_votacao["nom_autor"] = parlamentar.nom_parlamentar
+                            parlamentar = context.zsql.parlamentar_obter_zsql(
+                                cod_parlamentar=autor.cod_parlamentar)[0]
+                            dic_votacao[
+                                "nom_autor"] = parlamentar.nom_parlamentar
                         elif autor.des_tipo_autor == "Comissao":
-                        comissao = context.zsql.comissao_obter_zsql(cod_comissao=autor.cod_comissao)[0]
+                            comissao = context.zsql.comissao_obter_zsql(
+                                cod_comissao=autor.cod_comissao)[0]
                             dic_votacao["nom_autor"] = comissao.nom_comissao
                         elif autor.nom_autor != "":
                             dic_votacao["nom_autor"] = autor.nom_autor
@@ -187,11 +224,13 @@ if context.REQUEST['data']!='':
 
             dic_votacao["votacao_observacao"] = ""
             if votacao.tip_resultado_votacao:
-                resultado = context.zsql.tipo_resultado_votacao_obter_zsql(tip_resultado_votacao=votacao.tip_resultado_votacao, ind_excluido=0)
+                resultado = context.zsql.tipo_resultado_votacao_obter_zsql(
+                    tip_resultado_votacao=votacao.tip_resultado_votacao, ind_excluido=0)
                 for i in resultado:
                     dic_votacao["nom_resultado"] = i.nom_resultado
                     if votacao.votacao_observacao:
-                        dic_votacao["votacao_observacao"] = votacao.votacao_observacao
+                        dic_votacao[
+                            "votacao_observacao"] = votacao.votacao_observacao
             else:
                 dic_votacao["nom_resultado"] = "Matéria não votada"
                 dic_votacao["votacao_observacao"] = "Vazio"
@@ -207,12 +246,14 @@ if context.REQUEST['data']!='':
                 dic_oradores['sgl_partido'] = parlamentar.sgl_partido
                 lst_oradores.append(dic_oradores)
 
-    # obtém as propriedades da casa legislativa para montar o cabeçalho e o rodapé da página
+    # obtém as propriedades da casa legislativa para montar o cabeçalho e o
+    # rodapé da página
     cabecalho = {}
 
     # tenta buscar o logotipo da casa LOGO_CASA
     if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
-        imagem = context.sapl_documentos.props_sapl['logo_casa.gif'].absolute_url()
+        imagem = context.sapl_documentos.props_sapl[
+            'logo_casa.gif'].absolute_url()
     else:
         imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
@@ -221,7 +262,8 @@ if context.REQUEST['data']!='':
     aux = context.sapl_documentos.props_sapl.propertyItems()
     for item in aux:
         casa[item[0]] = item[1]
-    localidade=context.zsql.localidade_obter_zsql(cod_localidade=casa["cod_localidade"])
+    localidade = context.zsql.localidade_obter_zsql(
+        cod_localidade=casa["cod_localidade"])
     data_emissao = DateTime().strftime("%d/%m/%Y")
     rodape = casa
     rodape['data_emissao'] = data_emissao
@@ -234,7 +276,8 @@ if context.REQUEST['data']!='':
 
 #    return lst_votacao
     sessao = session.id
-    caminho = context.pdf_sessao_plenaria_gerar(rodape, sessao, imagem, inf_basicas_dic, lst_mesa, lst_presenca_sessao, lst_expedientes, lst_expediente_materia, lst_oradores_expediente, lst_presenca_ordem_dia, lst_votacao, lst_oradores)
+    caminho = context.pdf_sessao_plenaria_gerar(rodape, sessao, imagem, inf_basicas_dic, lst_mesa, lst_presenca_sessao,
+                                                lst_expedientes, lst_expediente_materia, lst_oradores_expediente, lst_presenca_ordem_dia, lst_votacao, lst_oradores)
     if caminho == 'aviso':
         return response.redirect('mensagem_emitir_proc')
     else:

sapl/relatorios/views.py

@@ -15,11 +15,10 @@ from sapl.protocoloadm.models import (DocumentoAdministrativo, Protocolo,
                                       TramitacaoAdministrativo)
 from sapl.sessao.models import (ExpedienteMateria, ExpedienteSessao,
                                 IntegranteMesa, Orador, OradorExpediente,
-                                OrdemDia, PresencaOrdemDia, RegistroVotacao,
-                                SessaoPlenaria, SessaoPlenariaPresenca,
-                                TipoExpediente)
+                                OrdemDia, PresencaOrdemDia, SessaoPlenaria,
+                                SessaoPlenariaPresenca)
 from sapl.settings import STATIC_ROOT
-from sapl.utils import UF
+from sapl.utils import UF, filiacao_data
 
 from .templates import (pdf_capa_processo_gerar,
                         pdf_documento_administrativo_gerar, pdf_espelho_gerar,
@@ -510,12 +509,8 @@ def get_sessao_plenaria(sessao, casa):
     for parlamentar in [p.parlamentar for p in presenca]:
         dic_presenca = {}
         dic_presenca["nom_parlamentar"] = parlamentar.nome_parlamentar
-            partido = Filiacao.objects.filter(
-                parlamentar=parlamentar).first()
-            if partido:
-                partido_sigla = partido.partido.sigla
-            else:
-                partido_sigla = ''
+        partido_sigla = filiacao_data(parlamentar, sessao.data_inicio)
+
         dic_presenca['sgl_partido'] = partido_sigla
         lst_presenca_sessao.append(dic_presenca)
 
@@ -651,12 +646,8 @@ def get_sessao_plenaria(sessao, casa):
         dic_presenca_ordem_dia = {}
         dic_presenca_ordem_dia['nom_parlamentar'] = (
             parlamentar.nome_parlamentar)
-            partido_sigla = Filiacao.objects.filter(
-                parlamentar=parlamentar).first()
-            if not partido_sigla:
-                sigla = ''
-            else:
-                sigla = partido_sigla.partido.sigla
+        sigla = filiacao_data(parlamentar, sessao.data_inicio)
+
         dic_presenca_ordem_dia['sgl_partido'] = sigla
         lst_presenca_ordem_dia.append(dic_presenca_ordem_dia)
 
@@ -702,8 +693,9 @@ def get_sessao_plenaria(sessao, casa):
                     if tramitacao.turno == turno[0]:
                         dic_votacao["des_turno"] = turno[1]
 
-        dic_votacao["txt_ementa"] = materia.ementa
-        dic_votacao["ordem_observacao"] = votacao.observacao
+        # https://github.com/interlegis/sapl/issues/1009
+        dic_votacao["txt_ementa"] = html.unescape(materia.ementa)
+        dic_votacao["ordem_observacao"] = html.unescape(votacao.observacao)
 
         dic_votacao["nom_autor"] = ' '
         autoria = Autoria.objects.filter(

sapl/rules/map_rules.py

@@ -53,6 +53,7 @@ __listdetailchange__ = [RP_LIST, RP_DETAIL, RP_CHANGE]
 rules_group_administrativo = {
     'group': SAPL_GROUP_ADMINISTRATIVO,
     'rules': [
+        (materia.MateriaLegislativa, ['can_access_impressos']),
         (protocoloadm.DocumentoAdministrativo, __base__),
         (protocoloadm.DocumentoAcessorioAdministrativo, __base__),
         (protocoloadm.TramitacaoAdministrativo, __base__),
@@ -69,6 +70,7 @@ rules_group_protocolo = {
         (protocoloadm.DocumentoAcessorioAdministrativo, __listdetailchange__),
 
         (materia.MateriaLegislativa, __listdetailchange__),
+        (materia.MateriaLegislativa, ['can_access_impressos']),
         (materia.DocumentoAcessorio, __listdetailchange__),
         (materia.Anexada, __base__),
         (materia.Autoria, __base__),
@@ -98,7 +100,7 @@ rules_group_materia = {
         (materia.DespachoInicial, __base__),
         (materia.DocumentoAcessorio, __base__),
 
-        (materia.MateriaLegislativa, __base__),
+        (materia.MateriaLegislativa, __base__ + ['can_access_impressos']),
         (materia.Numeracao, __base__),
         (materia.Tramitacao, __base__),
         (norma.LegislacaoCitada, __base__),
@@ -209,6 +211,7 @@ rules_group_geral = {
 
         (materia.AssuntoMateria, __base__),  # não há implementação
         (materia.MateriaAssunto, __base__),  # não há implementação
+        (materia.MateriaLegislativa, ['can_access_impressos']),
         (materia.TipoProposicao, __base__),
         (materia.TipoMateriaLegislativa, __base__),
         (materia.RegimeTramitacao, __base__),

sapl/sessao/forms.py

@@ -10,7 +10,8 @@ from django.utils.translation import ugettext_lazy as _
 
 from sapl.crispy_layout_mixin import form_actions, to_row
 from sapl.materia.forms import MateriaLegislativaFilterSet
-from sapl.materia.models import MateriaLegislativa, TipoMateriaLegislativa
+from sapl.materia.models import (MateriaLegislativa, StatusTramitacao,
+                                 TipoMateriaLegislativa)
 from sapl.parlamentares.models import Parlamentar
 from sapl.utils import (RANGE_DIAS_MES, RANGE_MESES,
                         MateriaPesquisaOrderingFilter, autor_label,
@@ -52,6 +53,48 @@ ORDENACAO_RESUMO = [('cont_mult', 'Conteúdo Multimídia'),
                     ('oradores_expli', 'Oradores das Explicações Pessoais')]
 
 
+class SessaoPlenariaForm(ModelForm):
+
+    class Meta:
+        model = SessaoPlenaria
+        exclude = ['cod_andamento_sessao']
+
+    def clean(self):
+        super(SessaoPlenariaForm, self).clean()
+
+        if not self.is_valid():
+            return self.cleaned_data
+
+        instance = self.instance
+
+        num = self.cleaned_data['numero']
+        sl = self.cleaned_data['sessao_legislativa']
+        leg = self.cleaned_data['legislatura']
+        tipo = self.cleaned_data['tipo']
+
+        error = ValidationError(
+            "Número de Sessão Plenária já existente "
+            "para a Legislatura, Sessão Legislativa e Tipo informados. "
+            "Favor escolher um número distinto.")
+
+        sessoes = SessaoPlenaria.objects.filter(numero=num,
+                                                sessao_legislativa=sl,
+                                                legislatura=leg,
+                                                tipo=tipo).\
+            values_list('id', flat=True)
+
+        qtd_sessoes = len(sessoes)
+
+        if qtd_sessoes > 0:
+            if instance.pk:  # update
+                if instance.pk not in sessoes or qtd_sessoes > 1:
+                    raise error
+            else:  # create
+                raise error
+
+        return self.cleaned_data
+
+
 class BancadaForm(ModelForm):
 
     class Meta:
@@ -255,10 +298,15 @@ class SessaoPlenariaFilterSet(django_filters.FilterSet):
 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 = ['numero',
+        fields = ['tramitacao__status',
+                  'numero',
                   'numero_protocolo',
                   'ano',
                   'tipo',
@@ -280,15 +328,17 @@ class AdicionarVariasMateriasFilterSet(MateriaLegislativaFilterSet):
         self.filters['relatoria__parlamentar_id'].label = 'Relatoria'
 
         row1 = to_row(
-            [('tipo', 12)])
+            [('tramitacao__status', 12)])
         row2 = to_row(
+            [('tipo', 12)])
+        row3 = to_row(
             [('numero', 4),
              ('ano', 4),
              ('numero_protocolo', 4)])
-        row3 = to_row(
+        row4 = to_row(
             [('data_apresentacao', 6),
              ('data_publicacao', 6)])
-        row4 = to_row(
+        row5 = to_row(
             [('autoria__autor', 0),
              (Button('pesquisar',
                      'Pesquisar Autor',
@@ -296,17 +346,17 @@ class AdicionarVariasMateriasFilterSet(MateriaLegislativaFilterSet):
              (Button('limpar',
                      'limpar Autor',
                      css_class='btn btn-primary btn-sm'), 10)])
-        row5 = to_row(
+        row6 = to_row(
             [('autoria__autor__tipo', 6),
              # ('autoria__autor__partido', 6)
              ])
-        row6 = to_row(
+        row7 = to_row(
             [('relatoria__parlamentar_id', 6),
              ('local_origem_externa', 6)])
-        row7 = to_row(
+        row8 = to_row(
             [('em_tramitacao', 6),
              ('o', 6)])
-        row8 = to_row(
+        row9 = to_row(
             [('ementa', 12)])
 
         self.form.helper = FormHelper()
@@ -316,7 +366,7 @@ class AdicionarVariasMateriasFilterSet(MateriaLegislativaFilterSet):
                      row1, row2, row3,
                      HTML(autor_label),
                      HTML(autor_modal),
-                     row4, row5, row6, row7, row8,
+                     row4, row5, row6, row7, row8, row9,
                      form_actions(save_label='Pesquisar'))
         )
 

sapl/sessao/migrations/0010_auto_20170810_1033.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.11 on 2017-08-10 10:33
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('sessao', '0009_auto_20170619_1441'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='registrovotacao',
+            name='data_hora_atualizacao',
+            field=models.DateTimeField(auto_now=True, null=True, verbose_name='Data'),
+        ),
+        migrations.AddField(
+            model_name='registrovotacao',
+            name='data_hora_criacao',
+            field=models.DateTimeField(auto_now_add=True, null=True, verbose_name='Data Criação'),
+        ),
+    ]

sapl/sessao/migrations/0010_auto_20170814_1804.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.13 on 2017-08-14 18:04
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('sessao', '0009_auto_20170619_1441'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tiporesultadovotacao',
+            name='natureza',
+            field=models.CharField(choices=[('A', 'Aprovado'), ('R', 'Rejeitado')], max_length=100, null=True, verbose_name='Natureza do Tipo'),
+        ),
+        migrations.AlterField(
+            model_name='tiporesultadovotacao',
+            name='nome',
+            field=models.CharField(max_length=100, verbose_name='Nome do Tipo'),
+        ),
+    ]