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/management/commands/migracao_25_31.py

@@ -5,7 +5,7 @@ from sapl.legacy import migration
 
 class Command(BaseCommand):
 
-    help ='Migração de dados do SAPL 2.5 para o SAPL 3.1'
+    help = 'Migração de dados do SAPL 2.5 para o SAPL 3.1'
 
     def add_arguments(self, parser):
         parser.add_argument(

sapl/legacy/management/commands/migracao_documentos.py

@@ -5,7 +5,7 @@ from sapl.legacy.migracao_documentos import migrar_documentos
 
 class Command(BaseCommand):
 
-    help ='Migração documentos do SAPL 2.5 para o SAPL 3.1'
+    help = 'Migração documentos do SAPL 2.5 para o SAPL 3.1'
 
     def handle(self, *args, **options):
         migrar_documentos()

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(
@@ -244,7 +244,7 @@ class AnularProcoloAdmForm(ModelForm):
 
         if exists:
             raise forms.ValidationError(
-                _("Protocolo %s/%s não pode ser removido pois existem"
+                _("Protocolo %s/%s não pode ser removido pois existem "
                     "documentos vinculados a ele." % (numero, ano)))
 
     class Meta:
@@ -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,14 +52,13 @@ relatorio_materia_por_ano_autor_tipo = (
 historico_tramitacoes = (app_relatorios + ':historico_tramitacoes')
 
 
-
 def has_iframe(url, request):
 
     iframe = request.GET.get(
         'iframe',
         EMPTY_STRING)
     if iframe:
-        iframe_qs= ("iframe=" + iframe)
+        iframe_qs = ("iframe=" + iframe)
         url += ("&" if "?" in url else "?")
         url += iframe_qs
 

sapl/relatorios/templates/pdf_capa_processo_preparar_pysc.py

@@ -1,138 +1,149 @@
 import os
 
-request=context.REQUEST
-response=request.RESPONSE
-session= request.SESSION
+request = context.REQUEST
+response = request.RESPONSE
+session = request.SESSION
 
-data=DateTime().strftime('%d/%m/%Y')
+data = DateTime().strftime('%d/%m/%Y')
 
-#Abaixo é gerada a string para o rodapé da página
-casa={}
-aux=context.sapl_documentos.props_sapl.propertyItems()
+# Abaixo é gerada a string para o rodapé da página
+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"])
-if len(casa["num_cep"])==8:
- cep=casa["num_cep"][:4]+"-"+casa["num_cep"][5:]
+    casa[item[0]] = item[1]
+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:
- cep=""
+    cep = ""
 
-linha1=casa["end_casa"]
-if cep!="":
-  if casa["end_casa"]!="" and casa["end_casa"]!=None:
+linha1 = casa["end_casa"]
+if cep != "":
+    if casa["end_casa"] != "" and casa["end_casa"] != None:
         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
-if casa["num_tel"]!="" and casa["num_tel"]!=None:
-  linha1 = linha1 + " Tel.: "+ casa["num_tel"]
-
-linha2=casa["end_web_casa"]
-if casa["end_email_casa"]!="" and casa["end_email_casa"]!=None:
-  if casa["end_web_casa"]!="" and casa["end_web_casa"]!=None:
+    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
+if casa["num_tel"] != "" and casa["num_tel"] != None:
+    linha1 = linha1 + " Tel.: " + casa["num_tel"]
+
+linha2 = casa["end_web_casa"]
+if casa["end_email_casa"] != "" and casa["end_email_casa"] != None:
+    if casa["end_web_casa"] != "" and casa["end_web_casa"] != None:
         linha2 = linha2 + " - "
-  linha2 =  linha2 + "E-mail: "+casa["end_email_casa"]
+    linha2 = linha2 + "E-mail: " + casa["end_email_casa"]
 
-data_emissao=DateTime().strftime("%d/%m/%Y")
-rodape=[linha1,linha2,data_emissao]
+data_emissao = DateTime().strftime("%d/%m/%Y")
+rodape = [linha1, linha2, data_emissao]
 
-#Por fim, gera-se as entradas para o cabeçalho
-estados=context.zsql.localidade_obter_zsql(tip_localidade="u")
+# Por fim, gera-se as entradas para o cabeçalho
+estados = context.zsql.localidade_obter_zsql(tip_localidade="u")
 for uf in estados:
- if localidade[0].sgl_uf==uf.sgl_uf:
-  nom_estado=uf.nom_localidade
+    if localidade[0].sgl_uf == uf.sgl_uf:
+        nom_estado = uf.nom_localidade
         break
-cabecalho={}
-cabecalho["nom_casa"]=casa["nom_casa"]
-cabecalho["nom_estado"]="Estado de "+nom_estado
+cabecalho = {}
+cabecalho["nom_casa"] = casa["nom_casa"]
+cabecalho["nom_estado"] = "Estado de " + nom_estado
 
 # tenta buscar o logotipo da casa LOGO_CASA
-if hasattr(context.sapl_documentos.props_sapl,'logo_casa.gif'):
+if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
     imagem = context.sapl_documentos.props_sapl['logo_casa.gif'].absolute_url()
 else:
     imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
-#Por fim, utiliza o PythonScript para pesquisar os protocolos e gerar os dados
+# Por fim, utiliza o PythonScript para pesquisar os protocolos e gerar os dados
 
-protocolos=[]
-REQUEST=context.REQUEST
+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 = {}
 
-        dic['titulo']=str(protocolo.cod_protocolo)
+    dic['titulo'] = str(protocolo.cod_protocolo)
 
-        dic['ano']=str(protocolo.ano_protocolo)
+    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
+    dic['txt_assunto'] = protocolo.txt_assunto_ementa
 
-        dic['txt_interessado']=protocolo.txt_interessado
+    dic['txt_interessado'] = protocolo.txt_interessado
 
     dic['nom_autor'] = " "
-        if protocolo.cod_autor!=None:
+    if protocolo.cod_autor != None:
         for autor in context.zsql.autor_obter_zsql(cod_autor=protocolo.cod_autor):
-                if autor.des_tipo_autor=='Parlamentar':
+            if autor.des_tipo_autor == 'Parlamentar':
                 for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=autor.cod_parlamentar):
-                        dic['nom_autor']=parlamentar.nom_completo
-                elif autor.des_tipo_autor=='Comissao':
+                    dic['nom_autor'] = parlamentar.nom_completo
+            elif autor.des_tipo_autor == 'Comissao':
                 for comissao in context.zsql.comissao_obter_zsql(cod_comissao=autor.cod_comissao):
-                        dic['nom_autor']=comissao.nom_comissao
+                    dic['nom_autor'] = comissao.nom_comissao
             else:
-                    dic['nom_autor']=autor.nom_autor
+                dic['nom_autor'] = autor.nom_autor
     else:
-            dic['nom_autor']=protocolo.txt_interessado
+        dic['nom_autor'] = protocolo.txt_interessado
 
-        dic['natureza']=''
-        if protocolo.tip_processo==0:
-           dic['natureza']='Administrativo'
-        if protocolo.tip_processo==1:
-           dic['natureza']='Legislativo'
+    dic['natureza'] = ''
+    if protocolo.tip_processo == 0:
+        dic['natureza'] = 'Administrativo'
+    if protocolo.tip_processo == 1:
+        dic['natureza'] = 'Legislativo'
 
-        dic['ident_processo']=protocolo.des_tipo_materia or protocolo.des_tipo_documento
+    dic['ident_processo'] = protocolo.des_tipo_materia or protocolo.des_tipo_documento
 
-        dic['sgl_processo']=protocolo.sgl_tipo_materia or protocolo.sgl_tipo_documento
+    dic['sgl_processo'] = protocolo.sgl_tipo_materia or protocolo.sgl_tipo_documento
 
-        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'] = ''
+    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_documento']=''
+    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['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'] = ''
+    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['anulado']=''
-        if protocolo.ind_anulado==1:
-           dic['anulado']='Nulo'
+    dic['anulado'] = ''
+    if protocolo.ind_anulado == 1:
+        dic['anulado'] = 'Nulo'
 
     protocolos.append(dic)
 
-filtro={} # Dicionário que conterá os dados do filtro
+filtro = {}  # Dicionário que conterá os dados do filtro
 
 # Atribuições diretas do REQUEST
-filtro['numero']=REQUEST.txt_num_protocolo
-filtro['ano']=REQUEST.txt_ano_protocolo
-filtro['tipo_protocolo']=REQUEST.rad_tip_protocolo
-filtro['tipo_processo']=REQUEST.rad_tip_processo
-filtro['assunto']=REQUEST.txt_assunto
-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)
-if caminho=='aviso':
+filtro['numero'] = REQUEST.txt_num_protocolo
+filtro['ano'] = REQUEST.txt_ano_protocolo
+filtro['tipo_protocolo'] = REQUEST.rad_tip_protocolo
+filtro['tipo_processo'] = REQUEST.rad_tip_processo
+filtro['assunto'] = REQUEST.txt_assunto
+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)
+if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:
     response.redirect(caminho)

sapl/relatorios/templates/pdf_detalhe_materia_gerar.py

@@ -11,326 +11,402 @@ import time
 from trml2pdf import parseString
 
 
-def cabecalho(dic_inf_basicas,imagem):
+def cabecalho(dic_inf_basicas, imagem):
     """
     Função que gera o código rml do cabeçalho da página
     """
 
-    tmp=''
-    tmp+='\t\t\t\t<image x="2.1cm" y="25.7cm" width="59" height="62" file="' + imagem + '"/>\n'
-    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<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'
+    tmp = ''
+    tmp += '\t\t\t\t<image x="2.1cm" y="25.7cm" width="59" height="62" file="' + imagem + '"/>\n'
+    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<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<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'
     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<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'
     return tmp
 
+
 def rodape(dic_rodape):
     """
     Função que gera o codigo rml do rodape da pagina.
     """
 
-    tmp=''
+    tmp = ''
     linha1 = dic_rodape['end_casa']
-    if dic_rodape['end_casa']!="" and dic_rodape['end_casa']!=None:
+    if dic_rodape['end_casa'] != "" and dic_rodape['end_casa'] != None:
         linha1 = linha1 + " - "
-    if dic_rodape['num_cep']!="" and dic_rodape['num_cep']!=None:
+    if dic_rodape['num_cep'] != "" and dic_rodape['num_cep'] != None:
         linha1 = linha1 + "CEP " + dic_rodape['num_cep']
-    if dic_rodape['nom_localidade']!="" and dic_rodape['nom_localidade']!=None:
+    if dic_rodape['nom_localidade'] != "" and dic_rodape['nom_localidade'] != None:
         linha1 = linha1 + " - " + dic_rodape['nom_localidade']
-    if dic_rodape['sgl_uf']!="" and dic_rodape['sgl_uf']!=None:
+    if dic_rodape['sgl_uf'] != "" and dic_rodape['sgl_uf'] != None:
         inha1 = linha1 + " " + dic_rodape['sgl_uf']
-    if dic_rodape['num_tel']!="" and dic_rodape['num_tel']!=None:
-        linha1 = linha1 + " Tel: "+ dic_rodape['num_tel']
-    if dic_rodape['end_web_casa']!="" and dic_rodape['end_web_casa']!=None:
+    if dic_rodape['num_tel'] != "" and dic_rodape['num_tel'] != None:
+        linha1 = linha1 + " Tel: " + dic_rodape['num_tel']
+    if dic_rodape['end_web_casa'] != "" and dic_rodape['end_web_casa'] != None:
         linha2 = dic_rodape['end_web_casa']
-    if dic_rodape['end_email_casa']!="" and dic_rodape['end_email_casa']!=None:
+    if dic_rodape['end_email_casa'] != "" and dic_rodape['end_email_casa'] != None:
         linha2 = linha2 + " - E-mail: " + dic_rodape['end_email_casa']
-    if dic_rodape['data_emissao']!="" and dic_rodape['data_emissao']!=None:
+    if dic_rodape['data_emissao'] != "" and dic_rodape['data_emissao'] != None:
         data_emissao = dic_rodape['data_emissao']
 
-    tmp+='\t\t\t\t<lines>2cm 3.2cm 19cm 3.2cm</lines>\n'
-    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<lines>2cm 3.2cm 19cm 3.2cm</lines>\n'
+    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'
 
     return tmp
 
+
 def paraStyle():
     """Função que gera o código rml que define o estilo dos parágrafos"""
 
-    tmp=''
-    tmp+='\t<stylesheet>\n'
-    tmp+='\t\t<blockTableStyle id="Standard_Outline">\n'
-    tmp+='\t\t\t<blockAlignment value="LEFT"/>\n'
-    tmp+='\t\t\t<blockValign value="TOP"/>\n'
-    tmp+='\t\t</blockTableStyle>\n'
-    tmp+='\t\t<initialize>\n'
-    tmp+='\t\t\t<paraStyle name="all" alignment="justify"/>\n'
-    tmp+='\t\t</initialize>\n'
-    #titulo do parágrafo: é por default centralizado
-    tmp+='\t\t<paraStyle name="style.Title" fontName="Helvetica" fontSize="11" leading="13" alignment="RIGHT"/>\n'
-    tmp+='\t\t<paraStyle name="P1" fontName="Helvetica-Bold" fontSize="12.0" textColor="gray" leading="14" spaceBefore="6" alignment="LEFT"/>\n'
-    tmp+='\t\t<paraStyle name="P2" fontName="Helvetica" fontSize="10.0" leading="10" alignment="LEFT"/>\n'
-    tmp+='\t\t<paraStyle name="texto_projeto" fontName="Helvetica" fontSize="12.0" leading="12" spaceAfter="10" alignment="JUSTIFY"/>\n'
-    tmp+='\t</stylesheet>\n'
+    tmp = ''
+    tmp += '\t<stylesheet>\n'
+    tmp += '\t\t<blockTableStyle id="Standard_Outline">\n'
+    tmp += '\t\t\t<blockAlignment value="LEFT"/>\n'
+    tmp += '\t\t\t<blockValign value="TOP"/>\n'
+    tmp += '\t\t</blockTableStyle>\n'
+    tmp += '\t\t<initialize>\n'
+    tmp += '\t\t\t<paraStyle name="all" alignment="justify"/>\n'
+    tmp += '\t\t</initialize>\n'
+    # titulo do parágrafo: é por default centralizado
+    tmp += '\t\t<paraStyle name="style.Title" fontName="Helvetica" fontSize="11" leading="13" alignment="RIGHT"/>\n'
+    tmp += '\t\t<paraStyle name="P1" fontName="Helvetica-Bold" fontSize="12.0" textColor="gray" leading="14" spaceBefore="6" alignment="LEFT"/>\n'
+    tmp += '\t\t<paraStyle name="P2" fontName="Helvetica" fontSize="10.0" leading="10" alignment="LEFT"/>\n'
+    tmp += '\t\t<paraStyle name="texto_projeto" fontName="Helvetica" fontSize="12.0" leading="12" spaceAfter="10" alignment="JUSTIFY"/>\n'
+    tmp += '\t</stylesheet>\n'
 
     return tmp
 
+
 def inf_basicas(dic_inf_basicas):
     """
     Função que gera o código rml das funções básicas do relatório
     """
 
-    tmp=''
-    #Texto do projeto
+    tmp = ''
+    # 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'
+    if texto_projeto != "" and texto_projeto != None:
+        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'
+    # 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'
+    if dic_inf_basicas['publicada'] == 0:
+        tmp += '\t\t<para style="P2"><b>Publicada:</b> Não</para>\n'
     else:
-        tmp+='\t\t<para style="P2"><b>Publicada:</b> Sim</para>\n'
+        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'
+    if dic_inf_basicas['tramitacao'] == 0:
+        tmp += '\t\t<para style="P2"><b>Tramitação:</b> Não</para>\n'
     else:
-        tmp+='\t\t<para style="P2"><b>Tramitação:</b> Sim</para>\n'
+        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'
+        tmp += '\t\t<para style="P2"><b>Matéria Complementar:</b> Não</para>\n'
     else:
-        tmp+='\t\t<para style="P2"><b>Matéria Complementar:</b> Sim</para>\n'
+        tmp += '\t\t<para style="P2"><b>Matéria Complementar:</b> Sim</para>\n'
 
     if dic_inf_basicas['polemica'] == 0:
-        tmp+='\t\t<para style="P2"><b>Polêmica:</b> Não</para>\n'
+        tmp += '\t\t<para style="P2"><b>Polêmica:</b> Não</para>\n'
     else:
-        tmp+='\t\t<para style="P2"><b>Polêmica:</b> Sim</para>\n'
+        tmp += '\t\t<para style="P2"><b>Polêmica:</b> Sim</para>\n'
 
     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
     """
 
-    tmp=''
-    tmp+='\t\t<para style="P1">Origem Externa</para>\n'
+    tmp = ''
+    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'
+    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'
+        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'
     return tmp
 
+
 def autoria(lst_autoria):
 
-    tmp=''
-    tmp+='\t\t<para style="P1">Autores</para>\n'
+    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=''
-    tmp+='\t\t<para style="P1">Despachos Iniciais</para>\n'
+    tmp = ''
+    tmp += '\t\t<para style="P1">Despachos Iniciais</para>\n'
     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'
+        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'
     return tmp
 
+
 def tramitacoes(dic_tramitacoes):
 
-    tmp=''
-    tmp+='\t\t<para style="P1">Última Tramitação</para>\n'
+    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'
-        if dic_tramitacoes['urgente']==0:
-            tmp+='\t\t<para style="P2"><b>Urgente:</b> Não</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>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'
-        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>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'
 
-    except: pass
+    except:
+        pass
     return tmp
 
+
 def relatorias(lst_relatorias):
 
-    tmp=''
-    tmp+='\t\t<para style="P1">Relatorias</para>\n'
+    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'
+    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'
+    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'
+    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'
-
-        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>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'
-
-        if dic_dados['ementa']!=None:
-            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'
+        if dic_dados['tipo'] != None:
+            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>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'
+
+        if dic_dados['ementa'] != None:
+            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'
     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=''):
+
+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=''):
     """
     Função principal responsável por chamar as funções que irão gerar o código rml apropriado
     """
 
-    arquivoPdf=str(int(time.time()*100))+".pdf"
-
-    tmp=''
-    tmp+='<?xml version="1.0" encoding="utf-8" standalone="no" ?>\n'
-    tmp+='<!DOCTYPE document SYSTEM "rml_1_0.dtd">\n'
-    tmp+='<document filename="relatorio.pdf">\n'
-    tmp+='\t<template pageSize="(21cm, 29.7cm)" title="Relatorio de Materias" author="Interlegis" allowSplitting="20">\n'
-    tmp+='\t\t<pageTemplate id="first">\n'
-    tmp+='\t\t\t<pageGraphics>\n'
-    tmp+=cabecalho(dic_inf_basicas,imagem)
-    tmp+=rodape(dic_rodape)
-    tmp+='\t\t\t</pageGraphics>\n'
-    tmp+='\t\t\t<frame id="first" x1="2cm" y1="4cm" width="17cm" height="20.5cm"/>\n'
-    tmp+='\t\t</pageTemplate>\n'
-    tmp+='\t</template>\n'
-    tmp+=paraStyle()
-    tmp+='\t<story>\n'
-    tmp+=inf_basicas(dic_inf_basicas)
-    tmp+=orig_externa(dic_orig_externa)
-    tmp+=mat_anexadas(lst_mat_anexadas)
-    tmp+=autoria(lst_autoria)
-    tmp+=despachos_iniciais(lst_des_iniciais)
-    tmp+=tramitacoes(dic_tramitacoes)
-    tmp+=relatorias(lst_relatorias)
-    tmp+=numeracoes(lst_numeracoes)
-    tmp+=legislacoes_citadas(lst_leg_citadas)
-    tmp+=documentos_acessorios(lst_acessorios)
-    tmp+='\t</story>\n'
-    tmp+='</document>\n'
-    tmp_pdf=parseString(tmp)
+    arquivoPdf = str(int(time.time() * 100)) + ".pdf"
+
+    tmp = ''
+    tmp += '<?xml version="1.0" encoding="utf-8" standalone="no" ?>\n'
+    tmp += '<!DOCTYPE document SYSTEM "rml_1_0.dtd">\n'
+    tmp += '<document filename="relatorio.pdf">\n'
+    tmp += '\t<template pageSize="(21cm, 29.7cm)" title="Relatorio de Materias" author="Interlegis" allowSplitting="20">\n'
+    tmp += '\t\t<pageTemplate id="first">\n'
+    tmp += '\t\t\t<pageGraphics>\n'
+    tmp += cabecalho(dic_inf_basicas, imagem)
+    tmp += rodape(dic_rodape)
+    tmp += '\t\t\t</pageGraphics>\n'
+    tmp += '\t\t\t<frame id="first" x1="2cm" y1="4cm" width="17cm" height="20.5cm"/>\n'
+    tmp += '\t\t</pageTemplate>\n'
+    tmp += '\t</template>\n'
+    tmp += paraStyle()
+    tmp += '\t<story>\n'
+    tmp += inf_basicas(dic_inf_basicas)
+    tmp += orig_externa(dic_orig_externa)
+    tmp += mat_anexadas(lst_mat_anexadas)
+    tmp += autoria(lst_autoria)
+    tmp += despachos_iniciais(lst_des_iniciais)
+    tmp += tramitacoes(dic_tramitacoes)
+    tmp += relatorias(lst_relatorias)
+    tmp += numeracoes(lst_numeracoes)
+    tmp += legislacoes_citadas(lst_leg_citadas)
+    tmp += documentos_acessorios(lst_acessorios)
+    tmp += '\t</story>\n'
+    tmp += '</document>\n'
+    tmp_pdf = parseString(tmp)
 
     return tmp_pdf
 #     if hasattr(context.temp_folder,arquivoPdf):

sapl/relatorios/templates/pdf_detalhe_materia_preparar_pysc.py

@@ -1,89 +1,94 @@
 import os
 
-request=context.REQUEST
-response=request.RESPONSE
-session= request.SESSION
+request = context.REQUEST
+response = request.RESPONSE
+session = request.SESSION
 
-cabecalho={}
+cabecalho = {}
 
 # tenta buscar o logotipo da casa LOGO_CASA
-if hasattr(context.sapl_documentos.props_sapl,'logo_casa.gif'):
+if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
     imagem = context.sapl_documentos.props_sapl['logo_casa.gif'].absolute_url()
 else:
     imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
-#Abaixo é gerado o dic do rodapé da página (linha 7)
-casa={}
-aux=context.sapl_documentos.props_sapl.propertyItems()
+# Abaixo é gerado o dic do rodapé da página (linha 7)
+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"])
-data_emissao= DateTime().strftime("%d/%m/%Y")
-rodape= casa 
-rodape['data_emissao']= data_emissao
+    casa[item[0]] = item[1]
+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
 
 inf_basicas_dic = {}
-inf_basicas_dic['nom_camara']= casa['nom_casa']
-REQUEST=context.REQUEST
-for local in context.zsql.localidade_obter_zsql(cod_localidade = casa['cod_localidade']):
-  rodape['nom_localidade']= "   "+local.nom_localidade
-  rodape['sgl_uf']= local.sgl_uf
+inf_basicas_dic['nom_camara'] = casa['nom_casa']
+REQUEST = context.REQUEST
+for local in context.zsql.localidade_obter_zsql(cod_localidade=casa['cod_localidade']):
+    rodape['nom_localidade'] = "   " + local.nom_localidade
+    rodape['sgl_uf'] = local.sgl_uf
 
 orig_externa_dic = {}
 
 for materia in context.zsql.materia_obter_zsql(cod_materia=REQUEST['cod_materia']):
-#Abaixo é gerado os dados para o bloco Informações Básicas (ln 23)
- inf_basicas_dic['texto_projeto']= materia.txt_ementa
- inf_basicas_dic['apresentada']= materia.dat_apresentacao
- inf_basicas_dic['formato']= materia.tip_apresentacao
- 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['nom_projeto']= materia.des_tipo_materia
+    # Abaixo é gerado os dados para o bloco Informações Básicas (ln 23)
+    inf_basicas_dic['texto_projeto'] = materia.txt_ementa
+    inf_basicas_dic['apresentada'] = materia.dat_apresentacao
+    inf_basicas_dic['formato'] = materia.tip_apresentacao
+    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['nom_projeto'] = materia.des_tipo_materia
 
     for tramitacao in context.zsql.regime_tramitacao_obter_zsql(cod_regime_tramitacao=materia.cod_regime_tramitacao):
-#  """#tratando possíveis erros"""
-#  if tramitacao.des_regime_tramitacao==None: tramitacao.des_regime_tramitacao=""
-#  if materia.num_dias_prazo==None: materia.num_dias_prazo=""
-#  if materia.dat_fim_prazo==None: materia.dat_fim_prazo=""
-#  if materia.ind_complementar==None: materia.ind_complementar=""
-#  if materia.ind_polemica==None: materia.ind_polemica=""
-#  if materia.nom_apelido==None: materia.nom_apelido=""
-#  if materia.txt_indexacao==None: materia.txt_indexacao=""
-#  if materia.txt_observacao==None: materia.txt_observacao=""
-#  """#atribuindo valores"""
-  inf_basicas_dic['reg_tramitacao']= tramitacao.des_regime_tramitacao
-  inf_basicas_dic['prazo']= materia.num_dias_prazo
-  inf_basicas_dic['fim_prazo']= materia.dat_fim_prazo
-  inf_basicas_dic['mat_complementar']= materia.ind_complementar
-  inf_basicas_dic['polemica']= materia.ind_polemica
-  inf_basicas_dic['apelido']= materia.nom_apelido
-  inf_basicas_dic['indexacao']= materia.txt_indexacao
-  inf_basicas_dic['observacao']= materia.txt_observacao
+        #  """#tratando possíveis erros"""
+        #  if tramitacao.des_regime_tramitacao==None: tramitacao.des_regime_tramitacao=""
+        #  if materia.num_dias_prazo==None: materia.num_dias_prazo=""
+        #  if materia.dat_fim_prazo==None: materia.dat_fim_prazo=""
+        #  if materia.ind_complementar==None: materia.ind_complementar=""
+        #  if materia.ind_polemica==None: materia.ind_polemica=""
+        #  if materia.nom_apelido==None: materia.nom_apelido=""
+        #  if materia.txt_indexacao==None: materia.txt_indexacao=""
+        #  if materia.txt_observacao==None: materia.txt_observacao=""
+        #  """#atribuindo valores"""
+        inf_basicas_dic['reg_tramitacao'] = tramitacao.des_regime_tramitacao
+        inf_basicas_dic['prazo'] = materia.num_dias_prazo
+        inf_basicas_dic['fim_prazo'] = materia.dat_fim_prazo
+        inf_basicas_dic['mat_complementar'] = materia.ind_complementar
+        inf_basicas_dic['polemica'] = materia.ind_polemica
+        inf_basicas_dic['apelido'] = materia.nom_apelido
+        inf_basicas_dic['indexacao'] = materia.txt_indexacao
+        inf_basicas_dic['observacao'] = materia.txt_observacao
 
 
 # #o bloco abaixo gera o dicionario da origem externa (ln 47)
- for origem in context.zsql.origem_obter_zsql(cod_origem = materia.cod_local_origem_externa):
-#  #tratando possíveis erros
-#  if origem.sgl_origem==None: origem.sgl_origem=""
-#  if origem.nom_origem==None: origem.nom_origem=""
-#  if materia.tip_origem_externa==None: materia.tip_origem_externa=""
-#  if materia.dat_origem_externa==None: materia.dat_origem_externa=""
-#  if materia.num_origem_externa==None: materia.num_origem_externa=""
-#  if materia.ano_origem_externa==None: materia.ano_origem_externa=""
+    for origem in context.zsql.origem_obter_zsql(cod_origem=materia.cod_local_origem_externa):
+        #  #tratando possíveis erros
+        #  if origem.sgl_origem==None: origem.sgl_origem=""
+        #  if origem.nom_origem==None: origem.nom_origem=""
+        #  if materia.tip_origem_externa==None: materia.tip_origem_externa=""
+        #  if materia.dat_origem_externa==None: materia.dat_origem_externa=""
+        #  if materia.num_origem_externa==None: materia.num_origem_externa=""
+        #  if materia.ano_origem_externa==None: materia.ano_origem_externa=""
 
-  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['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)
 
 # #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,32 +96,33 @@ 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['data']= anexada.dat_anexacao 
-  dic_mat['data_fim']= anexada.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['data'] = anexada.dat_anexacao
+        dic_mat['data_fim'] = anexada.dat_desanexacao
         lst_mat_anexadas.append(dic_mat)
 
 # #o bloco abaixo gera o dicionario dos autores(ln 66)
     lst_autoria = []
 # dic_autor = {}
- for autoria in context.zsql.autoria_obter_zsql(cod_materia = materia.cod_materia):
+    for autoria in context.zsql.autoria_obter_zsql(cod_materia=materia.cod_materia):
         dic_autor = {}
         if autoria.ind_primeiro_autor:
-   dic_autor['tipo']= "primeiro autor"
+            dic_autor['tipo'] = "primeiro autor"
         else:
-   dic_autor['tipo']= " "
+            dic_autor['tipo'] = " "
 
-  for autor in context.zsql.autor_obter_zsql(cod_autor = autoria.cod_autor):
-   dic_autor['cargo']= " "
-   if autor.des_tipo_autor=='Parlamentar':
+        for autor in context.zsql.autor_obter_zsql(cod_autor=autoria.cod_autor):
+            dic_autor['cargo'] = " "
+            if autor.des_tipo_autor == 'Parlamentar':
                 for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=autor.cod_parlamentar):
-     dic_autor['nom_autor']=parlamentar.nom_completo
-   elif autor.des_tipo_autor=='Comissao':
+                    dic_autor['nom_autor'] = parlamentar.nom_completo
+            elif autor.des_tipo_autor == 'Comissao':
                 for comissao in context.zsql.comissao_obter_zsql(cod_comissao=autor.cod_comissao):
-     dic_autor['nom_autor']=comissao.nom_comissao
+                    dic_autor['nom_autor'] = comissao.nom_comissao
             else:
-    dic_autor['nom_autor']=autor.nom_autor
-    dic_autor['cargo']= autor.des_cargo
+                dic_autor['nom_autor'] = autor.nom_autor
+                dic_autor['cargo'] = autor.des_cargo
             lst_autoria.append(dic_autor)
 
 #   """#tratando possíveis erros"""
@@ -131,95 +137,104 @@ for materia in context.zsql.materia_obter_zsql(cod_materia=REQUEST['cod_materia'
 #       dic_autor['tipo']= " "
 
 # #o bloco abaixo gera o dicionario de despachos iniciais (ln 79)
- lst_des_iniciais=[]
- for despacho in context.zsql.despacho_inicial_obter_zsql(cod_materia = materia.cod_materia):
-   for comissao in context.zsql.comissao_obter_zsql(cod_comissao = despacho.cod_comissao_sel):
-     dic_dados={}
-     if comissao.nom_comissao==None:
-       comissao.nom_comissao=''
-     if comissao.sgl_comissao==None:
-       comissao.sgl_comissao='' 
-     dic_dados['nom_comissao']=comissao.nom_comissao+ " - "+ comissao.sgl_comissao
+    lst_des_iniciais = []
+    for despacho in context.zsql.despacho_inicial_obter_zsql(cod_materia=materia.cod_materia):
+        for comissao in context.zsql.comissao_obter_zsql(cod_comissao=despacho.cod_comissao_sel):
+            dic_dados = {}
+            if comissao.nom_comissao == None:
+                comissao.nom_comissao = ''
+            if comissao.sgl_comissao == None:
+                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)
     dic_tramitacoes = {}
     for tramitacao in context.zsql.tramitacao_obter_zsql(cod_materia=REQUEST['cod_materia'], ind_ult_tramitacao=1):
-   dic_tramitacoes['data']= tramitacao.dat_tramitacao
-   dic_tramitacoes['data_enc']= tramitacao.dat_encaminha
-   dic_tramitacoes['turno']= tramitacao.sgl_turno
-   dic_tramitacoes['status']= tramitacao.des_status
-   dic_tramitacoes['urgente']= tramitacao.ind_urgencia
-   dic_tramitacoes['data_fim']= tramitacao.dat_fim_prazo 
-   dic_tramitacoes['texto_acao']= tramitacao.txt_tramitacao
+        dic_tramitacoes['data'] = tramitacao.dat_tramitacao
+        dic_tramitacoes['data_enc'] = tramitacao.dat_encaminha
+        dic_tramitacoes['turno'] = tramitacao.sgl_turno
+        dic_tramitacoes['status'] = tramitacao.des_status
+        dic_tramitacoes['urgente'] = tramitacao.ind_urgencia
+        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---------------------------------
-     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:
-         for unidade_dest in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao = tramitacao.cod_unid_tram_dest): 
-            #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
-            #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
+        for unidade in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao=tramitacao.cod_unid_tram_local):
+            #-----------------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:
+                        for unidade_dest in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao=tramitacao.cod_unid_tram_dest):
+                            # 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
+                            # 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
                     else:
-         dic_tramitacoes['unidade']= comissao.nom_comissao
-         dic_tramitacoes['destino']= "None"
-     #---------------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:
-         for unidade_dest in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao = tramitacao.cod_unid_tram_dest):
-            #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
-            #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'] = comissao.nom_comissao
+                        dic_tramitacoes['destino'] = "None"
+            #---------------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:
+                        for unidade_dest in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao=tramitacao.cod_unid_tram_dest):
+                            # 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
+                            # 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
                     else:
-         dic_tramitacoes['unidade']= orgao.nom_orgao
-         dic_tramitacoes['destino']= "None"     
+                        dic_tramitacoes['unidade'] = orgao.nom_orgao
+                        dic_tramitacoes['destino'] = "None"
 
 # #o bloco abaixo gera o dicionario de relatorias(ln 106)
 
     lst_relatorias = []
     dic_comissao = {}
- for relatoria in context.zsql.relatoria_obter_zsql(cod_materia = materia.cod_materia):
-  for comissao in context.zsql.comissao_obter_zsql(cod_comissao = relatoria.cod_comissao):
-   for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar = relatoria.cod_parlamentar):
-    dic_comissao['nom_comissao']= comissao.nom_comissao
-    dic_comissao['data_desig']= relatoria.dat_desig_relator
-    dic_comissao['parlamentar']= parlamentar.nom_completo
-    dic_comissao['data_dest']= relatoria.dat_destit_relator
-    if relatoria.tip_fim_relatoria==None or relatoria.tip_fim_relatoria=='0': 
+    for relatoria in context.zsql.relatoria_obter_zsql(cod_materia=materia.cod_materia):
+        for comissao in context.zsql.comissao_obter_zsql(cod_comissao=relatoria.cod_comissao):
+            for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=relatoria.cod_parlamentar):
+                dic_comissao['nom_comissao'] = comissao.nom_comissao
+                dic_comissao['data_desig'] = relatoria.dat_desig_relator
+                dic_comissao['parlamentar'] = parlamentar.nom_completo
+                dic_comissao['data_dest'] = relatoria.dat_destit_relator
+                if relatoria.tip_fim_relatoria == None or relatoria.tip_fim_relatoria == '0':
                     num = 0
-     dic_comissao['motivo']=""
+                    dic_comissao['motivo'] = ""
                 else:
-     num=relatoria.tip_fim_relatoria
-     for tipo_fim in context.zsql.tipo_fim_relatoria_obter_zsql(tip_fim_relatoria = num):
-      dic_comissao['motivo']= tipo_fim.des_fim_relatoria
+                    num = relatoria.tip_fim_relatoria
+                    for tipo_fim in context.zsql.tipo_fim_relatoria_obter_zsql(tip_fim_relatoria=num):
+                        dic_comissao['motivo'] = tipo_fim.des_fim_relatoria
             lst_relatorias.append(dic_comissao)
 
 # #o bloco abaixo gera o dicionario de Numeracoes(ln 121)
 
     lst_numeracoes = []
- 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['ano']= numeracao.ano_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['ano'] = numeracao.ano_materia
         lst_numeracoes.append(dic_dados)
 
 
@@ -227,41 +242,43 @@ 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)
-  dic_dados['disposicao']= legislacao.des_disposicoes
-  dic_dados['parte']= legislacao.des_parte
-  dic_dados['livro']= legislacao.des_livro
-  dic_dados['titulo']= legislacao.des_titulo
-  dic_dados['capitulo']= legislacao.des_capitulo
-  dic_dados['secao']= legislacao.des_secao
-  dic_dados['subsecao']= legislacao.des_subsecao
-  dic_dados['artigo']= legislacao.des_artigo
-  dic_dados['paragrafo']= legislacao.des_paragrafo
-  dic_dados['inciso']= legislacao.des_inciso
-  dic_dados['alinea']= legislacao.des_alinea
-  dic_dados['item']= legislacao.des_item
+    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)
+        dic_dados['disposicao'] = legislacao.des_disposicoes
+        dic_dados['parte'] = legislacao.des_parte
+        dic_dados['livro'] = legislacao.des_livro
+        dic_dados['titulo'] = legislacao.des_titulo
+        dic_dados['capitulo'] = legislacao.des_capitulo
+        dic_dados['secao'] = legislacao.des_secao
+        dic_dados['subsecao'] = legislacao.des_subsecao
+        dic_dados['artigo'] = legislacao.des_artigo
+        dic_dados['paragrafo'] = legislacao.des_paragrafo
+        dic_dados['inciso'] = legislacao.des_inciso
+        dic_dados['alinea'] = legislacao.des_alinea
+        dic_dados['item'] = legislacao.des_item
         lst_legis_citadas.append(dic_dados)
 
 
 # #o bloco abaixo gera o dicionario de Documentos Acessórios(153)
 
     lst_acessorios = []
- for documento in context.zsql.documento_acessorio_obter_zsql(cod_materia = materia.cod_materia):
+    for documento in context.zsql.documento_acessorio_obter_zsql(cod_materia=materia.cod_materia):
         dic_dados = {}
-  dic_dados['tipo']= documento.tip_documento
-  dic_dados['nome']= documento.nom_documento
-  dic_dados['data']= documento.dat_documento
-  dic_dados['autor']= documento.nom_autor_documento
-  dic_dados['ementa']= documento.txt_ementa
-  dic_dados['indexacao']= documento.txt_indexacao
+        dic_dados['tipo'] = documento.tip_documento
+        dic_dados['nome'] = documento.nom_documento
+        dic_dados['data'] = documento.dat_documento
+        dic_dados['autor'] = documento.nom_autor_documento
+        dic_dados['ementa'] = documento.txt_ementa
+        dic_dados['indexacao'] = documento.txt_indexacao
         lst_acessorios.append(dic_dados)
 
-caminho=context.pdf_detalhe_materia_gerar(imagem, rodape,inf_basicas_dic,orig_externa_dic,lst_mat_anexadas,lst_autoria,
-                                          lst_des_iniciais,dic_tramitacoes,lst_relatorias,lst_numeracoes,
-                                          lst_legis_citadas,lst_acessorios,sessao=session.id)
-if caminho=='aviso':
+caminho = context.pdf_detalhe_materia_gerar(imagem, rodape, inf_basicas_dic, orig_externa_dic, lst_mat_anexadas, lst_autoria,
+                                            lst_des_iniciais, dic_tramitacoes, lst_relatorias, lst_numeracoes,
+                                            lst_legis_citadas, lst_acessorios, sessao=session.id)
+if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:
     response.redirect(caminho)

sapl/relatorios/templates/pdf_documento_administrativo_preparar_pysc.py

@@ -1,124 +1,135 @@
 import os
 
-request=context.REQUEST
-response=request.RESPONSE
-session= request.SESSION
+request = context.REQUEST
+response = request.RESPONSE
+session = request.SESSION
 
-data=DateTime().strftime('%d/%m/%Y')
+data = DateTime().strftime('%d/%m/%Y')
 
-#Abaixo é gerada a string para o rodapé da página
-casa={}
-aux=context.sapl_documentos.props_sapl.propertyItems()
+# Abaixo é gerada a string para o rodapé da página
+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"])
-if len(casa["num_cep"])==8:
- cep=casa["num_cep"][:4]+"-"+casa["num_cep"][5:]
+    casa[item[0]] = item[1]
+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:
- cep=""
+    cep = ""
 
-linha1=casa["end_casa"]
-if cep!="":
-  if casa["end_casa"]!="" and casa["end_casa"]!=None:
+linha1 = casa["end_casa"]
+if cep != "":
+    if casa["end_casa"] != "" and casa["end_casa"] != None:
         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
-if casa["num_tel"]!="" and casa["num_tel"]!=None:
-  linha1 = linha1 + " Tel.: "+ casa["num_tel"]
-
-linha2=casa["end_web_casa"]
-if casa["end_email_casa"]!="" and casa["end_email_casa"]!=None:
-  if casa["end_web_casa"]!="" and casa["end_web_casa"]!=None:
+    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
+if casa["num_tel"] != "" and casa["num_tel"] != None:
+    linha1 = linha1 + " Tel.: " + casa["num_tel"]
+
+linha2 = casa["end_web_casa"]
+if casa["end_email_casa"] != "" and casa["end_email_casa"] != None:
+    if casa["end_web_casa"] != "" and casa["end_web_casa"] != None:
         linha2 = linha2 + " - "
-  linha2 =  linha2 + "E-mail: "+casa["end_email_casa"]
+    linha2 = linha2 + "E-mail: " + casa["end_email_casa"]
 
-data_emissao=DateTime().strftime("%d/%m/%Y")
-rodape=[linha1,linha2,data_emissao]
+data_emissao = DateTime().strftime("%d/%m/%Y")
+rodape = [linha1, linha2, data_emissao]
 
-#Por fim, gera-se as entradas para o cabeçalho
-estados=context.zsql.localidade_obter_zsql(tip_localidade="u")
+# Por fim, gera-se as entradas para o cabeçalho
+estados = context.zsql.localidade_obter_zsql(tip_localidade="u")
 for uf in estados:
- if localidade[0].sgl_uf==uf.sgl_uf:
-  nom_estado=uf.nom_localidade
+    if localidade[0].sgl_uf == uf.sgl_uf:
+        nom_estado = uf.nom_localidade
         break
-cabecalho={}
-cabecalho["nom_casa"]=casa["nom_casa"]
-cabecalho["nom_estado"]="Estado de "+nom_estado
+cabecalho = {}
+cabecalho["nom_casa"] = casa["nom_casa"]
+cabecalho["nom_estado"] = "Estado de " + nom_estado
 
 # tenta buscar o logotipo da casa LOGO_CASA
-if hasattr(context.sapl_documentos.props_sapl,'logo_casa.gif'):
+if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
     imagem = context.sapl_documentos.props_sapl['logo_casa.gif'].absolute_url()
 else:
     imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
-#Por fim, utiliza o PythonScript para pesquisar os documentos e gerar os dados
+# Por fim, utiliza o PythonScript para pesquisar os documentos e gerar os dados
 
-documentos=[]
-REQUEST=context.REQUEST
+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 = {}
 
-        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      
+    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
 
     des_status = ''
-        txt_tramitacao=''
+    txt_tramitacao = ''
 
-        dic['localizacao_atual']=" "
-        for tramitacao in context.zsql.tramitacao_administrativo_obter_zsql(cod_documento=documento.cod_documento,ind_ult_tramitacao=1):
+    dic['localizacao_atual'] = " "
+    for tramitacao in context.zsql.tramitacao_administrativo_obter_zsql(cod_documento=documento.cod_documento, ind_ult_tramitacao=1):
         if tramitacao.cod_unid_tram_dest:
             cod_unid_tram = tramitacao.cod_unid_tram_dest
         else:
             cod_unid_tram = tramitacao.cod_unid_tram_local
 
-            for unidade_tramitacao in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao = cod_unid_tram):
+        for unidade_tramitacao in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao=cod_unid_tram):
             if unidade_tramitacao.cod_orgao:
-                    dic['localizacao_atual']=unidade_tramitacao.nom_orgao
+                dic['localizacao_atual'] = unidade_tramitacao.nom_orgao
             else:
-                    dic['localizacao_atual']=unidade_tramitacao.nom_comissao
+                dic['localizacao_atual'] = unidade_tramitacao.nom_comissao
 
-            des_status=tramitacao.des_status
-            txt_tramitacao=tramitacao.txt_tramitacao
+        des_status = tramitacao.des_status
+        txt_tramitacao = tramitacao.txt_tramitacao
 
-        dic['des_situacao']=des_status
-        dic['ultima_acao']=txt_tramitacao
+    dic['des_situacao'] = des_status
+    dic['ultima_acao'] = txt_tramitacao
 
     documentos.append(dic)
 
-filtro={} # Dicionário que conterá os dados do filtro
+filtro = {}  # Dicionário que conterá os dados do filtro
 
 # Atribuições diretas do REQUEST
-filtro['numero']=REQUEST.txt_num_documento
-filtro['ano']=REQUEST.txt_ano_documento
-filtro['interessado']=REQUEST.txa_txt_interessado
-filtro['assunto']=REQUEST.txa_txt_assunto
+filtro['numero'] = REQUEST.txt_num_documento
+filtro['ano'] = REQUEST.txt_ano_documento
+filtro['interessado'] = REQUEST.txa_txt_interessado
+filtro['assunto'] = REQUEST.txa_txt_assunto
 
-filtro['tipo_documento']=''
-if REQUEST.lst_tip_documento!='':
+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['tramitando']=''
-if REQUEST.rad_tramitando=='1':
-    filtro['tramitacao']='Sim'
-elif REQUEST['rad_tramitando']=='0':
-    filtro['tramitacao']='Não'
-
-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
-
-sessao=session.id
-caminho = context.pdf_documento_administrativo_gerar(sessao,imagem,data,documentos,cabecalho,rodape,filtro)
-if caminho=='aviso':
+        filtro['tipo_documento'] = tipo_documento.sgl_tipo_documento + \
+            ' - ' + tipo_documento.des_tipo_documento
+
+filtro['tramitando'] = ''
+if REQUEST.rad_tramitando == '1':
+    filtro['tramitacao'] = 'Sim'
+elif REQUEST['rad_tramitando'] == '0':
+    filtro['tramitacao'] = 'Não'
+
+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
+
+sessao = session.id
+caminho = context.pdf_documento_administrativo_gerar(
+    sessao, imagem, data, documentos, cabecalho, rodape, filtro)
+if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:
     response.redirect(caminho)

sapl/relatorios/templates/pdf_espelho_gerar.py

@@ -69,12 +69,12 @@ def materias(lst_materias):
 
     for dic in lst_materias:
         # espaco inicial
-#		tmp_data+='\t\t<para style="P2">\n'
-#		tmp_data+='\t\t\t<font color="white"> </font>\n'
-#		tmp_data+='\t\t</para>\n'
-#		tmp_data+='\t\t<para style="P2">\n'
-#		tmp_data+='\t\t\t<font color="white"> </font>\n'
-#		tmp_data+='\t\t</para>\n'
+        #		tmp_data+='\t\t<para style="P2">\n'
+        #		tmp_data+='\t\t\t<font color="white"> </font>\n'
+        #		tmp_data+='\t\t</para>\n'
+        #		tmp_data+='\t\t<para style="P2">\n'
+        #		tmp_data+='\t\t\t<font color="white"> </font>\n'
+        #		tmp_data+='\t\t</para>\n'
 
         # condicao para a quebra de pagina
         tmp_data += '\t\t<condPageBreak height="16cm"/>\n'
@@ -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

@@ -1,200 +1,210 @@
 import os
 
-request=context.REQUEST
-response=request.RESPONSE
-session= request.SESSION
+request = context.REQUEST
+response = request.RESPONSE
+session = request.SESSION
 
-data=DateTime().strftime('%d/%m/%Y')
+data = DateTime().strftime('%d/%m/%Y')
 
-#Abaixo é gerada a string para o rodapé da página
-casa={}
-aux=context.sapl_documentos.props_sapl.propertyItems()
+# Abaixo é gerada a string para o rodapé da página
+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"])
-if len(casa["num_cep"])==8:
- cep=casa["num_cep"][:4]+"-"+casa["num_cep"][5:]
+    casa[item[0]] = item[1]
+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:
- cep=""
+    cep = ""
 
-linha1=casa["end_casa"]
-if cep!="":
-  if casa["end_casa"]!="" and casa["end_casa"]!=None:
+linha1 = casa["end_casa"]
+if cep != "":
+    if casa["end_casa"] != "" and casa["end_casa"] != None:
         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
-if casa["num_tel"]!="" and casa["num_tel"]!=None:
-  linha1 = linha1 + " Tel.: "+ casa["num_tel"]
-
-linha2=casa["end_web_casa"]
-if casa["end_email_casa"]!="" and casa["end_email_casa"]!=None:
-  if casa["end_web_casa"]!="" and casa["end_web_casa"]!=None:
+    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
+if casa["num_tel"] != "" and casa["num_tel"] != None:
+    linha1 = linha1 + " Tel.: " + casa["num_tel"]
+
+linha2 = casa["end_web_casa"]
+if casa["end_email_casa"] != "" and casa["end_email_casa"] != None:
+    if casa["end_web_casa"] != "" and casa["end_web_casa"] != None:
         linha2 = linha2 + " - "
-  linha2 =  linha2 + "E-mail: "+casa["end_email_casa"]
+    linha2 = linha2 + "E-mail: " + casa["end_email_casa"]
 
-data_emissao=DateTime().strftime("%d/%m/%Y")
-rodape=[linha1,linha2,data_emissao]
+data_emissao = DateTime().strftime("%d/%m/%Y")
+rodape = [linha1, linha2, data_emissao]
 
-#Por fim, gera-se as entradas para o cabeçalho
-estados=context.zsql.localidade_obter_zsql(tip_localidade="u")
+# Por fim, gera-se as entradas para o cabeçalho
+estados = context.zsql.localidade_obter_zsql(tip_localidade="u")
 for uf in estados:
- if localidade[0].sgl_uf==uf.sgl_uf:
-  nom_estado=uf.nom_localidade
+    if localidade[0].sgl_uf == uf.sgl_uf:
+        nom_estado = uf.nom_localidade
         break
-cabecalho={}
-cabecalho["nom_casa"]=casa["nom_casa"]
-cabecalho["nom_estado"]="Estado de "+nom_estado
+cabecalho = {}
+cabecalho["nom_casa"] = casa["nom_casa"]
+cabecalho["nom_estado"] = "Estado de " + nom_estado
 
 # tenta buscar o logotipo da casa LOGO_CASA
-if hasattr(context.sapl_documentos.props_sapl,'logo_casa.gif'):
+if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
     imagem = context.sapl_documentos.props_sapl['logo_casa.gif'].absolute_url()
 else:
     imagem = context.sapl_site.sapl_skin.imagens.absolute_url() + "/brasao_transp.gif"
 
-#Verifica o tamanho da lista das materias selecionadas vindas do form
-REQUEST=context.REQUEST
-if REQUEST.txt_check=='1':
+# Verifica o tamanho da lista das materias selecionadas vindas do form
+REQUEST = context.REQUEST
+if REQUEST.txt_check == '1':
     cod_mat = REQUEST['check_ind']
-  materias=[]
-  REQUEST=context.REQUEST
+    materias = []
+    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['dat_apresentacao']=materia.dat_apresentacao
-	dic['txt_ementa']=materia.txt_ementa
+        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['dat_apresentacao'] = materia.dat_apresentacao
+        dic['txt_ementa'] = materia.txt_ementa
 
         dic['nom_autor'] = " "
         for autoria in context.zsql.autoria_obter_zsql(cod_materia=materia.cod_materia, ind_primeiro_autor=1):
             for autor in context.zsql.autor_obter_zsql(cod_autor=autoria.cod_autor):
-                if autor.des_tipo_autor=='Parlamentar':
+                if autor.des_tipo_autor == 'Parlamentar':
                     for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=autor.cod_parlamentar):
-                        dic['nom_autor']=parlamentar.nom_completo
-                elif autor.des_tipo_autor=='Comissao':
+                        dic['nom_autor'] = parlamentar.nom_completo
+                elif autor.des_tipo_autor == 'Comissao':
                     for comissao in context.zsql.comissao_obter_zsql(cod_comissao=autor.cod_comissao):
-                        dic['nom_autor']=comissao.nom_comissao
+                        dic['nom_autor'] = comissao.nom_comissao
                 else:
-                    dic['nom_autor']=autor.nom_autor
+                    dic['nom_autor'] = autor.nom_autor
 
         des_status = ''
-        txt_tramitacao=''
+        txt_tramitacao = ''
         data_ultima_acao = ''
 
-	dic['localizacao_atual']=" "
-        for tramitacao in context.zsql.tramitacao_obter_zsql(cod_materia=materia.cod_materia,ind_ult_tramitacao=1):
+        dic['localizacao_atual'] = " "
+        for tramitacao in context.zsql.tramitacao_obter_zsql(cod_materia=materia.cod_materia, ind_ult_tramitacao=1):
             if tramitacao.cod_unid_tram_dest:
                 cod_unid_tram = tramitacao.cod_unid_tram_dest
             else:
                 cod_unid_tram = tramitacao.cod_unid_tram_local
 
-            for unidade_tramitacao in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao = cod_unid_tram):
+            for unidade_tramitacao in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao=cod_unid_tram):
                 if unidade_tramitacao.cod_orgao:
-                    dic['localizacao_atual']=unidade_tramitacao.nom_orgao
+                    dic['localizacao_atual'] = unidade_tramitacao.nom_orgao
                 elif unidade_tramitacao.cod_parlamentar:
-                    dic['localizacao_atual']=unidade_tramitacao.nom_parlamentar
+                    dic['localizacao_atual'] = unidade_tramitacao.nom_parlamentar
                 else:
-                    dic['localizacao_atual']=unidade_tramitacao.nom_comissao
+                    dic['localizacao_atual'] = unidade_tramitacao.nom_comissao
 
-            des_status=tramitacao.des_status
-            txt_tramitacao=tramitacao.txt_tramitacao
+            des_status = tramitacao.des_status
+            txt_tramitacao = tramitacao.txt_tramitacao
             data_ultima_acao = tramitacao.dat_tramitacao
 
-	dic['des_situacao']=des_status
-        dic['ultima_acao']=txt_tramitacao
-        dic['data_ultima_acao']=data_ultima_acao
+        dic['des_situacao'] = des_status
+        dic['ultima_acao'] = txt_tramitacao
+        dic['data_ultima_acao'] = data_ultima_acao
 
         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)
 
 else:
     codigo = REQUEST.check_ind
-  materias=[]
-  REQUEST=context.REQUEST
+    materias = []
+    REQUEST = context.REQUEST
     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['dat_apresentacao']=materia.dat_apresentacao
-        dic['txt_ementa']=materia.txt_ementa
+            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['dat_apresentacao'] = materia.dat_apresentacao
+            dic['txt_ementa'] = materia.txt_ementa
 
             dic['nom_autor'] = " "
             for autoria in context.zsql.autoria_obter_zsql(cod_materia=materia.cod_materia, ind_primeiro_autor=1):
                 for autor in context.zsql.autor_obter_zsql(cod_autor=autoria.cod_autor):
-                if autor.des_tipo_autor=='Parlamentar':
+                    if autor.des_tipo_autor == 'Parlamentar':
                         for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=autor.cod_parlamentar):
-                        dic['nom_autor']=parlamentar.nom_completo
-                elif autor.des_tipo_autor=='Comissao':
+                            dic['nom_autor'] = parlamentar.nom_completo
+                    elif autor.des_tipo_autor == 'Comissao':
                         for comissao in context.zsql.comissao_obter_zsql(cod_comissao=autor.cod_comissao):
-                        dic['nom_autor']=comissao.nom_comissao
+                            dic['nom_autor'] = comissao.nom_comissao
                     else:
-                    dic['nom_autor']=autor.nom_autor
+                        dic['nom_autor'] = autor.nom_autor
 
             des_status = ''
-        txt_tramitacao=''
+            txt_tramitacao = ''
             data_ultima_acao = ''
 
-        dic['localizacao_atual']=" "
-        for tramitacao in context.zsql.tramitacao_obter_zsql(cod_materia=materia.cod_materia,ind_ult_tramitacao=1):
+            dic['localizacao_atual'] = " "
+            for tramitacao in context.zsql.tramitacao_obter_zsql(cod_materia=materia.cod_materia, ind_ult_tramitacao=1):
                 if tramitacao.cod_unid_tram_dest:
                     cod_unid_tram = tramitacao.cod_unid_tram_dest
                 else:
                     cod_unid_tram = tramitacao.cod_unid_tram_local
 
-            for unidade_tramitacao in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao = cod_unid_tram):
+                for unidade_tramitacao in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao=cod_unid_tram):
                     if unidade_tramitacao.cod_orgao:
-                    dic['localizacao_atual']=unidade_tramitacao.nom_orgao
+                        dic['localizacao_atual'] = unidade_tramitacao.nom_orgao
                     elif unidade_tramitacao.cod_parlamentar:
-		    dic['localizacao_atual']=unidade_tramitacao.nom_parlamentar
+                        dic['localizacao_atual'] = unidade_tramitacao.nom_parlamentar
                     else:
-                    dic['localizacao_atual']=unidade_tramitacao.nom_comissao
+                        dic['localizacao_atual'] = unidade_tramitacao.nom_comissao
 
-            des_status=tramitacao.des_status
-            txt_tramitacao=tramitacao.txt_tramitacao
+                des_status = tramitacao.des_status
+                txt_tramitacao = tramitacao.txt_tramitacao
                 data_ultima_acao = tramitacao.dat_tramitacao
 
-        dic['des_situacao']=des_status
-        dic['ultima_acao']=txt_tramitacao
-	dic['data_ultima_acao']=data_ultima_acao
+            dic['des_situacao'] = des_status
+            dic['ultima_acao'] = txt_tramitacao
+            dic['data_ultima_acao'] = data_ultima_acao
 
             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)
 
-filtro={} # Dicionário que conterá os dados do filtro
+filtro = {}  # Dicionário que conterá os dados do filtro
 
 # Atribuições diretas do REQUEST
-#filtro['data_apres']=REQUEST.data
+# filtro['data_apres']=REQUEST.data
 
-#filtro['tipo_materia']=''
-#for tipo_materia in context.zsql.tipo_materia_legislativa_obter_zsql(ind_excluido=0, tip_materia=9):
+# filtro['tipo_materia']=''
+# for tipo_materia in context.zsql.tipo_materia_legislativa_obter_zsql(ind_excluido=0, tip_materia=9):
 #    filtro['tipo_materia']= tipo_materia.sgl_tipo_materia + ' - ' + tipo_materia.des_tipo_materia
 
-#filtro['partido']=''
-#if REQUEST.lst_cod_partido!='':
+# filtro['partido']=''
+# if REQUEST.lst_cod_partido!='':
 #    for partido in context.zsql.partido_obter_zsql(ind_excluido=0,cod_partido=REQUEST.lst_cod_partido):
 #        filtro['partido']=partido.sgl_partido + ' - ' + partido.nom_partido
 
-#filtro['tramitando']=''
-#if REQUEST.rad_tramitando=='1':
+# filtro['tramitando']=''
+# if REQUEST.rad_tramitando=='1':
 #    filtro['tramitacao']='Sim'
-#elif REQUEST['rad_tramitando']=='0':
+# elif REQUEST['rad_tramitando']=='0':
 #    filtro['tramitacao']='Não'
 
-#filtro['situacao_atual']=''
-#if REQUEST.lst_status!='':
+# filtro['situacao_atual']=''
+# if REQUEST.lst_status!='':
 #    for status in context.zsql.status_tramitacao_obter_zsql(ind_exluido=0,cod_status=REQUEST.lst_status):
 #        filtro['situacao_atual']=status.sgl_status + ' - ' + status.des_status
 
-sessao=session.id
-caminho = context.pdf_espelho_gerar(sessao,imagem,data,materias,cabecalho,rodape,filtro)
-if caminho=='aviso':
+sessao = session.id
+caminho = context.pdf_espelho_gerar(
+    sessao, imagem, data, materias, cabecalho, rodape, filtro)
+if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:
     response.redirect(caminho)

sapl/relatorios/templates/pdf_etiqueta_protocolo_preparar_pysc.py

@@ -1,127 +1,137 @@
 import os
 
-request=context.REQUEST
-response=request.RESPONSE
-session= request.SESSION
+request = context.REQUEST
+response = request.RESPONSE
+session = request.SESSION
 
-data=DateTime().strftime('%d/%m/%Y')
+data = DateTime().strftime('%d/%m/%Y')
 
-#Abaixo é gerada a string para o rodapé da página
-casa={}
-aux=context.sapl_documentos.props_sapl.propertyItems()
+# Abaixo é gerada a string para o rodapé da página
+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"])
-if len(casa["num_cep"])==8:
- cep=casa["num_cep"][:4]+"-"+casa["num_cep"][5:]
+    casa[item[0]] = item[1]
+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:
- cep=""
+    cep = ""
 
-linha1=casa["end_casa"]
-if cep!="":
-  if casa["end_casa"]!="" and casa["end_casa"]!=None:
+linha1 = casa["end_casa"]
+if cep != "":
+    if casa["end_casa"] != "" and casa["end_casa"] != None:
         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
-if casa["num_tel"]!="" and casa["num_tel"]!=None:
-  linha1 = linha1 + " Tel.: "+ casa["num_tel"]
-
-linha2=casa["end_web_casa"]
-if casa["end_email_casa"]!="" and casa["end_email_casa"]!=None:
-  if casa["end_web_casa"]!="" and casa["end_web_casa"]!=None:
+    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
+if casa["num_tel"] != "" and casa["num_tel"] != None:
+    linha1 = linha1 + " Tel.: " + casa["num_tel"]
+
+linha2 = casa["end_web_casa"]
+if casa["end_email_casa"] != "" and casa["end_email_casa"] != None:
+    if casa["end_web_casa"] != "" and casa["end_web_casa"] != None:
         linha2 = linha2 + " - "
-  linha2 =  linha2 + "E-mail: "+casa["end_email_casa"]
+    linha2 = linha2 + "E-mail: " + casa["end_email_casa"]
 
-data_emissao=DateTime().strftime("%d/%m/%Y")
-rodape=[linha1,linha2,data_emissao]
+data_emissao = DateTime().strftime("%d/%m/%Y")
+rodape = [linha1, linha2, data_emissao]
 
-#Por fim, gera-se as entradas para o cabeçalho
-estados=context.zsql.localidade_obter_zsql(tip_localidade="u")
+# Por fim, gera-se as entradas para o cabeçalho
+estados = context.zsql.localidade_obter_zsql(tip_localidade="u")
 for uf in estados:
- if localidade[0].sgl_uf==uf.sgl_uf:
-  nom_estado=uf.nom_localidade
+    if localidade[0].sgl_uf == uf.sgl_uf:
+        nom_estado = uf.nom_localidade
         break
-cabecalho={}
-cabecalho["nom_casa"]=casa["nom_casa"]
-cabecalho["nom_estado"]="Estado de "+nom_estado
+cabecalho = {}
+cabecalho["nom_casa"] = casa["nom_casa"]
+cabecalho["nom_estado"] = "Estado de " + nom_estado
 
 # tenta buscar o logotipo da casa LOGO_CASA
-if hasattr(context.sapl_documentos.props_sapl,'logo_casa.gif'):
+if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
     imagem = context.sapl_documentos.props_sapl['logo_casa.gif'].absolute_url()
 else:
     imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
-#Por fim, utiliza o PythonScript para pesquisar os protocolos e gerar os dados
+# Por fim, utiliza o PythonScript para pesquisar os protocolos e gerar os dados
 
-protocolos=[]
-REQUEST=context.REQUEST
+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 = {}
 
-        dic['titulo']=str(protocolo.cod_protocolo)
+    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
+    dic['txt_assunto'] = protocolo.txt_assunto_ementa
 
-        dic['txt_interessado']=protocolo.txt_interessado
+    dic['txt_interessado'] = protocolo.txt_interessado
 
     dic['nom_autor'] = " "
-        if protocolo.cod_autor!=None:
+    if protocolo.cod_autor != None:
         for autor in context.zsql.autor_obter_zsql(cod_autor=protocolo.cod_autor):
-                if autor.des_tipo_autor=='Parlamentar':
+            if autor.des_tipo_autor == 'Parlamentar':
                 for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=autor.cod_parlamentar):
-                        dic['nom_autor']=parlamentar.nom_completo
-                elif autor.des_tipo_autor=='Comissao':
+                    dic['nom_autor'] = parlamentar.nom_completo
+            elif autor.des_tipo_autor == 'Comissao':
                 for comissao in context.zsql.comissao_obter_zsql(cod_comissao=autor.cod_comissao):
-                        dic['nom_autor']=comissao.nom_comissao
+                    dic['nom_autor'] = comissao.nom_comissao
             else:
-                    dic['nom_autor']=autor.nom_autor
+                dic['nom_autor'] = autor.nom_autor
 
-        dic['natureza']=''
-        if protocolo.tip_processo==0:
-           dic['natureza']='Administrativo'
-        if protocolo.tip_processo==1:
-           dic['natureza']='Legislativo'
+    dic['natureza'] = ''
+    if protocolo.tip_processo == 0:
+        dic['natureza'] = 'Administrativo'
+    if protocolo.tip_processo == 1:
+        dic['natureza'] = 'Legislativo'
 
-        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'] = ''
+    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_documento']=''
+    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']
+    dic['ident_processo'] = dic['num_materia'] or dic['num_documento']
 
-        dic['processo']=protocolo.des_tipo_materia or protocolo.des_tipo_documento
+    dic['processo'] = protocolo.des_tipo_materia or protocolo.des_tipo_documento
 
-        dic['anulado']=''
-        if protocolo.ind_anulado==1:
-           dic['anulado']='Nulo'
+    dic['anulado'] = ''
+    if protocolo.ind_anulado == 1:
+        dic['anulado'] = 'Nulo'
 
     protocolos.append(dic)
 
-filtro={} # Dicionário que conterá os dados do filtro
+filtro = {}  # Dicionário que conterá os dados do filtro
 
 # Atribuições diretas do REQUEST
-filtro['numero']=REQUEST.txt_num_protocolo
-filtro['ano']=REQUEST.txt_ano_protocolo
-filtro['tipo_protocolo']=REQUEST.rad_tip_protocolo
-filtro['tipo_processo']=REQUEST.rad_tip_processo
-filtro['assunto']=REQUEST.txt_assunto
-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)
-if caminho=='aviso':
+filtro['numero'] = REQUEST.txt_num_protocolo
+filtro['ano'] = REQUEST.txt_ano_protocolo
+filtro['tipo_protocolo'] = REQUEST.rad_tip_protocolo
+filtro['tipo_processo'] = REQUEST.rad_tip_processo
+filtro['assunto'] = REQUEST.txt_assunto
+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)
+if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:
     response.redirect(caminho)

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
@@ -11,100 +11,113 @@ import time
 from trml2pdf import parseString
 
 
-def cabecalho(dic_cabecalho,imagem):
+def cabecalho(dic_cabecalho, imagem):
     """Gera o codigo rml do cabecalho"""
-    tmp_data=''
-    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<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<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'
+    tmp_data = ''
+    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<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<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="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 = ''
+    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="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'
 
     return tmp_data
 
+
 def paraStyle():
     """Gera o codigo rml que define o estilo dos paragrafos"""
 
-    tmp_data=''
-    tmp_data+='\t<stylesheet>\n'
-    tmp_data+='\t\t<blockTableStyle id="Standard_Outline">\n'
-    tmp_data+='\t\t\t<blockAlignment value="LEFT"/>\n'
-    tmp_data+='\t\t\t<blockValign value="TOP"/>\n'
-    tmp_data+='\t\t</blockTableStyle>\n'
-    tmp_data+='\t\t<initialize>\n'
-    tmp_data+='\t\t\t<paraStyle name="all" alignment="justify"/>\n'
-    tmp_data+='\t\t</initialize>\n'
-    tmp_data+='\t\t<paraStyle name="P1" fontName="Helvetica-Bold" fontSize="10.0" leading="12" spaceAfter="2" alignment="left"/>\n'
-    tmp_data+='\t\t<paraStyle name="P2" fontName="Helvetica" fontSize="9.0" leading="12" spaceAfter="2" alignment="justify"/>\n'
-    tmp_data+='\t</stylesheet>\n'
+    tmp_data = ''
+    tmp_data += '\t<stylesheet>\n'
+    tmp_data += '\t\t<blockTableStyle id="Standard_Outline">\n'
+    tmp_data += '\t\t\t<blockAlignment value="LEFT"/>\n'
+    tmp_data += '\t\t\t<blockValign value="TOP"/>\n'
+    tmp_data += '\t\t</blockTableStyle>\n'
+    tmp_data += '\t\t<initialize>\n'
+    tmp_data += '\t\t\t<paraStyle name="all" alignment="justify"/>\n'
+    tmp_data += '\t\t</initialize>\n'
+    tmp_data += '\t\t<paraStyle name="P1" fontName="Helvetica-Bold" fontSize="10.0" leading="12" spaceAfter="2" alignment="left"/>\n'
+    tmp_data += '\t\t<paraStyle name="P2" fontName="Helvetica" fontSize="9.0" leading="12" spaceAfter="2" alignment="justify"/>\n'
+    tmp_data += '\t</stylesheet>\n'
 
     return tmp_data
 
+
 def materias(lst_materias):
     """Gera o codigo rml do conteudo da pesquisa de materias"""
 
-    tmp_data=''
+    tmp_data = ''
 
-    #inicio do bloco que contem os flowables
-    tmp_data+='\t<story>\n'
+    # inicio do bloco que contem os flowables
+    tmp_data += '\t<story>\n'
 
     for dic in lst_materias:
-        #espaco inicial
-        tmp_data+='\t\t<para style="P2">\n'
-        tmp_data+='\t\t\t<font color="white"> </font>\n'
-        tmp_data+='\t\t</para>\n'
-
-        #condicao para a quebra de pagina
-        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'
-        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</story>\n'
+        # espaco inicial
+        tmp_data += '\t\t<para style="P2">\n'
+        tmp_data += '\t\t\t<font color="white"> </font>\n'
+        tmp_data += '\t\t</para>\n'
+
+        # condicao para a quebra de pagina
+        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'
+        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</story>\n'
     return tmp_data
 
+
 def principal(imagem, lst_materias, dic_cabecalho, lst_rodape):
     """Funcao pricipal que gera a estrutura global do arquivo rml"""
 
-    arquivoPdf=str(int(time.time()*100))+".pdf"
-
-    tmp_data=''
-    tmp_data+='<?xml version="1.0" encoding="utf-8" standalone="no" ?>\n'
-    tmp_data+='<!DOCTYPE document SYSTEM "rml_1_0.dtd">\n'
-    tmp_data+='<document filename="relatorio.pdf">\n'
-    tmp_data+='\t<template pageSize="(21cm, 29.7cm)" title="Relatorio de Materias" author="Interlegis" allowSplitting="20">\n'
-    tmp_data+='\t\t<pageTemplate id="first">\n'
-    tmp_data+='\t\t\t<pageGraphics>\n'
-    tmp_data+=cabecalho(dic_cabecalho,imagem)
-    tmp_data+=rodape(lst_rodape)
-    tmp_data+='\t\t\t</pageGraphics>\n'
-    tmp_data+='\t\t\t<frame id="first" x1="2cm" y1="4cm" width="17cm" height="21cm"/>\n'
-    tmp_data+='\t\t</pageTemplate>\n'
-    tmp_data+='\t</template>\n'
-    tmp_data+=paraStyle()
-    tmp_data+=materias(lst_materias)
-    tmp_data+='</document>\n'
-    tmp_pdf=parseString(tmp_data)
+    arquivoPdf = str(int(time.time() * 100)) + ".pdf"
+
+    tmp_data = ''
+    tmp_data += '<?xml version="1.0" encoding="utf-8" standalone="no" ?>\n'
+    tmp_data += '<!DOCTYPE document SYSTEM "rml_1_0.dtd">\n'
+    tmp_data += '<document filename="relatorio.pdf">\n'
+    tmp_data += '\t<template pageSize="(21cm, 29.7cm)" title="Relatorio de Materias" author="Interlegis" allowSplitting="20">\n'
+    tmp_data += '\t\t<pageTemplate id="first">\n'
+    tmp_data += '\t\t\t<pageGraphics>\n'
+    tmp_data += cabecalho(dic_cabecalho, imagem)
+    tmp_data += rodape(lst_rodape)
+    tmp_data += '\t\t\t</pageGraphics>\n'
+    tmp_data += '\t\t\t<frame id="first" x1="2cm" y1="4cm" width="17cm" height="21cm"/>\n'
+    tmp_data += '\t\t</pageTemplate>\n'
+    tmp_data += '\t</template>\n'
+    tmp_data += paraStyle()
+    tmp_data += materias(lst_materias)
+    tmp_data += '</document>\n'
+    tmp_pdf = parseString(tmp_data)
 
     return tmp_pdf
 
@@ -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

@@ -1,155 +1,169 @@
 import os
 
-request=context.REQUEST
-#print request
-#return printed
-response=request.RESPONSE
-session= request.SESSION
+request = context.REQUEST
+# print request
+# return printed
+response = request.RESPONSE
+session = request.SESSION
 
-data=DateTime().strftime('%d/%m/%Y')
+data = DateTime().strftime('%d/%m/%Y')
 
-#Abaixo é gerada a string para o rodapé da página
-casa={}
-aux=context.sapl_documentos.props_sapl.propertyItems()
+# Abaixo é gerada a string para o rodapé da página
+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"])
-if len(casa["num_cep"])==8:
- cep=casa["num_cep"][:4]+"-"+casa["num_cep"][5:]
+    casa[item[0]] = item[1]
+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:
- cep=""
+    cep = ""
 
-linha1=casa["end_casa"]
-if cep!="":
-  if casa["end_casa"]!="" and casa["end_casa"]!=None:
+linha1 = casa["end_casa"]
+if cep != "":
+    if casa["end_casa"] != "" and casa["end_casa"] != None:
         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
-if casa["num_tel"]!="" and casa["num_tel"]!=None:
-  linha1 = linha1 + " Tel.: "+ casa["num_tel"]
-
-linha2=casa["end_web_casa"]
-if casa["end_email_casa"]!="" and casa["end_email_casa"]!=None:
-  if casa["end_web_casa"]!="" and casa["end_web_casa"]!=None:
+    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
+if casa["num_tel"] != "" and casa["num_tel"] != None:
+    linha1 = linha1 + " Tel.: " + casa["num_tel"]
+
+linha2 = casa["end_web_casa"]
+if casa["end_email_casa"] != "" and casa["end_email_casa"] != None:
+    if casa["end_web_casa"] != "" and casa["end_web_casa"] != None:
         linha2 = linha2 + " - "
-  linha2 =  linha2 + "E-mail: "+casa["end_email_casa"]
+    linha2 = linha2 + "E-mail: " + casa["end_email_casa"]
 
-data_emissao=DateTime().strftime("%d/%m/%Y")
-rodape=[linha1,linha2,data_emissao]
+data_emissao = DateTime().strftime("%d/%m/%Y")
+rodape = [linha1, linha2, data_emissao]
 
-#Por fim, gera-se as entradas para o cabeçalho
-estados=context.zsql.localidade_obter_zsql(tip_localidade="u")
+# Por fim, gera-se as entradas para o cabeçalho
+estados = context.zsql.localidade_obter_zsql(tip_localidade="u")
 for uf in estados:
- if localidade[0].sgl_uf==uf.sgl_uf:
-  nom_estado=uf.nom_localidade
+    if localidade[0].sgl_uf == uf.sgl_uf:
+        nom_estado = uf.nom_localidade
         break
-cabecalho={}
-cabecalho["nom_casa"]=casa["nom_casa"]
-cabecalho["nom_estado"]="Estado de "+nom_estado
+cabecalho = {}
+cabecalho["nom_casa"] = casa["nom_casa"]
+cabecalho["nom_estado"] = "Estado de " + nom_estado
 
 # tenta buscar o logotipo da casa LOGO_CASA
-if hasattr(context.sapl_documentos.props_sapl,'logo_casa.gif'):
+if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
     imagem = context.sapl_documentos.props_sapl['logo_casa.gif'].absolute_url()
 else:
     imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
-#Por fim, utiliza o PythonScript para pesquisar as matérias e gerar os dados
+# Por fim, utiliza o PythonScript para pesquisar as matérias e gerar os dados
 
-materias=[]
-REQUEST=context.REQUEST
+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'],
-                                           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['txt_ementa']=materia.txt_ementa 
+                                                   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['txt_ementa'] = materia.txt_ementa
     dic['nom_autor'] = " "
     for autoria in context.zsql.autoria_obter_zsql(cod_materia=materia.cod_materia):
         for autor in context.zsql.autor_obter_zsql(cod_autor=autoria.cod_autor):
-                if autor.des_tipo_autor=='Parlamentar':
+            if autor.des_tipo_autor == 'Parlamentar':
                 for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=autor.cod_parlamentar):
-                        dic['nom_autor']=parlamentar.nom_completo
-                elif autor.des_tipo_autor=='Comissao':
+                    dic['nom_autor'] = parlamentar.nom_completo
+            elif autor.des_tipo_autor == 'Comissao':
                 for comissao in context.zsql.comissao_obter_zsql(cod_comissao=autor.cod_comissao):
-                        dic['nom_autor']=comissao.nom_comissao
+                    dic['nom_autor'] = comissao.nom_comissao
             else:
-                    dic['nom_autor']=autor.nom_autor
+                dic['nom_autor'] = autor.nom_autor
 
     des_status = ''
-        txt_tramitacao=''
+    txt_tramitacao = ''
 
-        dic['localizacao_atual']=" "
-        for tramitacao in context.zsql.tramitacao_obter_zsql(cod_materia=materia.cod_materia,ind_ult_tramitacao=1):
+    dic['localizacao_atual'] = " "
+    for tramitacao in context.zsql.tramitacao_obter_zsql(cod_materia=materia.cod_materia, ind_ult_tramitacao=1):
         if tramitacao.cod_unid_tram_dest:
             cod_unid_tram = tramitacao.cod_unid_tram_dest
         else:
             cod_unid_tram = tramitacao.cod_unid_tram_local
 
-            for unidade_tramitacao in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao = cod_unid_tram):
+        for unidade_tramitacao in context.zsql.unidade_tramitacao_obter_zsql(cod_unid_tramitacao=cod_unid_tram):
             if unidade_tramitacao.cod_orgao:
-                    dic['localizacao_atual']=unidade_tramitacao.nom_orgao
+                dic['localizacao_atual'] = unidade_tramitacao.nom_orgao
             else:
-                    dic['localizacao_atual']=unidade_tramitacao.nom_comissao
+                dic['localizacao_atual'] = unidade_tramitacao.nom_comissao
 
-            des_status=tramitacao.des_status
-            txt_tramitacao=tramitacao.txt_tramitacao
+        des_status = tramitacao.des_status
+        txt_tramitacao = tramitacao.txt_tramitacao
 
-        dic['des_situacao']=des_status
-        dic['ultima_acao']=txt_tramitacao
+    dic['des_situacao'] = des_status
+    dic['ultima_acao'] = txt_tramitacao
 
-
-        dic['norma_vinculada']=" "
+    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)
 
-filtro={} # Dicionário que conterá os dados do filtro
+filtro = {}  # Dicionário que conterá os dados do filtro
 
 # Atribuições diretas do REQUEST
-filtro['numero']=REQUEST.txt_numero
-filtro['ano']=REQUEST.txt_ano
-filtro['autor']=REQUEST.hdn_txt_autor
-filtro['tipo_autor']=REQUEST.lst_tip_autor
-filtro['relator']=REQUEST.txt_relator
-filtro['assunto']=REQUEST.txt_assunto
+filtro['numero'] = REQUEST.txt_numero
+filtro['ano'] = REQUEST.txt_ano
+filtro['autor'] = REQUEST.hdn_txt_autor
+filtro['tipo_autor'] = REQUEST.lst_tip_autor
+filtro['relator'] = REQUEST.txt_relator
+filtro['assunto'] = REQUEST.txt_assunto
 
 # Atribuição do restante dos dados que precisam de processamento
-if REQUEST.hdn_txt_autor=='  ': # Corrige bug do Netscape
-    filtro['autor']=''
+if REQUEST.hdn_txt_autor == '  ':  # Corrige bug do Netscape
+    filtro['autor'] = ''
 
-filtro['tipo_materia']=''
-if REQUEST.lst_tip_materia!='':
+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['partido']=''
-if REQUEST.lst_cod_partido!='':
-    for partido in context.zsql.partido_obter_zsql(ind_excluido=0,cod_partido=REQUEST.lst_cod_partido):
-        filtro['partido']=partido.sgl_partido + ' - ' + partido.nom_partido
-
-filtro['tramitando']=''
-if REQUEST.rad_tramitando=='1':
-    filtro['tramitacao']='Sim'
-elif REQUEST['rad_tramitando']=='0':
-    filtro['tramitacao']='Não'
-
-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
-
-sessao=session.id
-caminho = context.pdf_materia_gerar(sessao,imagem,data,materias,cabecalho,rodape,filtro)
-if caminho=='aviso':
+        filtro['tipo_materia'] = tipo_materia.sgl_tipo_materia + \
+            ' - ' + tipo_materia.des_tipo_materia
+
+filtro['partido'] = ''
+if REQUEST.lst_cod_partido != '':
+    for partido in context.zsql.partido_obter_zsql(ind_excluido=0, cod_partido=REQUEST.lst_cod_partido):
+        filtro['partido'] = partido.sgl_partido + ' - ' + partido.nom_partido
+
+filtro['tramitando'] = ''
+if REQUEST.rad_tramitando == '1':
+    filtro['tramitacao'] = 'Sim'
+elif REQUEST['rad_tramitando'] == '0':
+    filtro['tramitacao'] = 'Não'
+
+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
+
+sessao = session.id
+caminho = context.pdf_materia_gerar(
+    sessao, imagem, data, materias, cabecalho, rodape, filtro)
+if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:
     response.redirect(caminho)

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
@@ -11,108 +11,117 @@ import time
 from trml2pdf import parseString
 
 
-def cabecalho(inf_basicas_dic,imagem):
+def cabecalho(inf_basicas_dic, imagem):
     """Gera o codigo rml do cabecalho"""
-    tmp_data=''
-    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<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'
-    tmp_data+='\t\t\t\t<drawString x="2.2cm" y="24.6cm">Relatório de Normas Jurídicas</drawString>\n'
+    tmp_data = ''
+    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<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'
+    tmp_data += '\t\t\t\t<drawString x="2.2cm" y="24.6cm">Relatório de Normas Jurídicas</drawString>\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="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 = ''
+    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="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'
 
     return tmp_data
 
+
 def paraStyle():
     """Gera o codigo rml que define o estilo dos paragrafos"""
 
-    tmp_data=''
-    tmp_data+='\t<stylesheet>\n'
-    tmp_data+='\t\t<blockTableStyle id="Standard_Outline">\n'
-    tmp_data+='\t\t\t<blockAlignment value="LEFT"/>\n'
-    tmp_data+='\t\t\t<blockValign value="TOP"/>\n'
-    tmp_data+='\t\t</blockTableStyle>\n'
-    tmp_data+='\t\t<initialize>\n'
-    tmp_data+='\t\t\t<paraStyle name="all" alignment="justify"/>\n'
-    tmp_data+='\t\t</initialize>\n'
-    tmp_data+='\t\t<paraStyle name="P1" fontName="Helvetica-Bold" fontSize="10.0" leading="10" alignment="CENTER"/>\n'
-    tmp_data+='\t\t<paraStyle name="P2" fontName="Helvetica" fontSize="10.0" leading="13" alignment="justify"/>\n'
-    tmp_data+='\t</stylesheet>\n'
+    tmp_data = ''
+    tmp_data += '\t<stylesheet>\n'
+    tmp_data += '\t\t<blockTableStyle id="Standard_Outline">\n'
+    tmp_data += '\t\t\t<blockAlignment value="LEFT"/>\n'
+    tmp_data += '\t\t\t<blockValign value="TOP"/>\n'
+    tmp_data += '\t\t</blockTableStyle>\n'
+    tmp_data += '\t\t<initialize>\n'
+    tmp_data += '\t\t\t<paraStyle name="all" alignment="justify"/>\n'
+    tmp_data += '\t\t</initialize>\n'
+    tmp_data += '\t\t<paraStyle name="P1" fontName="Helvetica-Bold" fontSize="10.0" leading="10" alignment="CENTER"/>\n'
+    tmp_data += '\t\t<paraStyle name="P2" fontName="Helvetica" fontSize="10.0" leading="13" alignment="justify"/>\n'
+    tmp_data += '\t</stylesheet>\n'
 
     return tmp_data
 
+
 def normas(lst_normas):
     """Gera o codigo rml do conteudo da pesquisa de normas"""
 
-    tmp_data=''
+    tmp_data = ''
 
-    #inicio do bloco que contem os flowables
-    tmp_data+='\t<story>\n'
+    # inicio do bloco que contem os flowables
+    tmp_data += '\t<story>\n'
 
     for dic in lst_normas:
-        #espaco inicial
-        tmp_data+='\t\t<para style="P2">\n'
-        tmp_data+='\t\t\t<font color="white"> </font>\n'
-        tmp_data+='\t\t</para>\n'
-        tmp_data+='\t\t<para style="P2">\n'
-        tmp_data+='\t\t\t<font color="white"> </font>\n'
-        tmp_data+='\t\t</para>\n'
-
-        #condicao para a quebra de pagina
-        tmp_data+='\t\t<condPageBreak height="4cm"/>\n'
-
-        #normas 
-        if dic['titulo']!=None:
-            tmp_data+='\t\t<para style="P1">' + 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'
-        if dic['txt_ementa']!=None:
-            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</story>\n'
+        # espaco inicial
+        tmp_data += '\t\t<para style="P2">\n'
+        tmp_data += '\t\t\t<font color="white"> </font>\n'
+        tmp_data += '\t\t</para>\n'
+        tmp_data += '\t\t<para style="P2">\n'
+        tmp_data += '\t\t\t<font color="white"> </font>\n'
+        tmp_data += '\t\t</para>\n'
+
+        # condicao para a quebra de pagina
+        tmp_data += '\t\t<condPageBreak height="4cm"/>\n'
+
+        # normas
+        if dic['titulo'] != None:
+            tmp_data += '\t\t<para style="P1">' + 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'
+        if dic['txt_ementa'] != None:
+            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</story>\n'
     return tmp_data
 
+
 def principal(imagem, lst_normas, dic_cabecalho, lst_rodape):
     """Funcao pricipal que gera a estrutura global do arquivo rml"""
 
-    arquivoPdf=str(int(time.time()*100))+".pdf"
-
-    tmp_data=''
-    tmp_data+='<?xml version="1.0" encoding="utf-8" standalone="no" ?>\n'
-    tmp_data+='<!DOCTYPE document SYSTEM "rml_1_0.dtd">\n'
-    tmp_data+='<document filename="relatorio.pdf">\n'
-    tmp_data+='\t<template pageSize="(21cm, 29.7cm)" title="Relatório de Normas Jurídicas" author="Luciano De Fazio" allowSplitting="20">\n'
-    tmp_data+='\t\t<pageTemplate id="first">\n'
-    tmp_data+='\t\t\t<pageGraphics>\n'
-    tmp_data+=cabecalho(dic_cabecalho,imagem)
-    tmp_data+=rodape(lst_rodape)
-    tmp_data+='\t\t\t</pageGraphics>\n'
-    tmp_data+='\t\t\t<frame id="first" x1="2cm" y1="3cm" width="17cm" height="21cm"/>\n'
-    tmp_data+='\t\t</pageTemplate>\n'
-    tmp_data+='\t</template>\n'
-    tmp_data+=paraStyle()
-    tmp_data+=normas(lst_normas)
-    tmp_data+='</document>\n'
-    tmp_pdf=parseString(tmp_data)
+    arquivoPdf = str(int(time.time() * 100)) + ".pdf"
+
+    tmp_data = ''
+    tmp_data += '<?xml version="1.0" encoding="utf-8" standalone="no" ?>\n'
+    tmp_data += '<!DOCTYPE document SYSTEM "rml_1_0.dtd">\n'
+    tmp_data += '<document filename="relatorio.pdf">\n'
+    tmp_data += '\t<template pageSize="(21cm, 29.7cm)" title="Relatório de Normas Jurídicas" author="Luciano De Fazio" allowSplitting="20">\n'
+    tmp_data += '\t\t<pageTemplate id="first">\n'
+    tmp_data += '\t\t\t<pageGraphics>\n'
+    tmp_data += cabecalho(dic_cabecalho, imagem)
+    tmp_data += rodape(lst_rodape)
+    tmp_data += '\t\t\t</pageGraphics>\n'
+    tmp_data += '\t\t\t<frame id="first" x1="2cm" y1="3cm" width="17cm" height="21cm"/>\n'
+    tmp_data += '\t\t</pageTemplate>\n'
+    tmp_data += '\t</template>\n'
+    tmp_data += paraStyle()
+    tmp_data += normas(lst_normas)
+    tmp_data += '</document>\n'
+    tmp_pdf = parseString(tmp_data)
 
     return tmp_pdf
 
@@ -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

@@ -1,94 +1,105 @@
 import os
 
-request=context.REQUEST
-response=request.RESPONSE
-session= request.SESSION
+request = context.REQUEST
+response = request.RESPONSE
+session = request.SESSION
 
-data=DateTime().strftime('%d/%m/%Y')
+data = DateTime().strftime('%d/%m/%Y')
 
-#Abaixo é gerada a string para o rodapé da página
-casa={}
-aux=context.sapl_documentos.props_sapl.propertyItems()
+# Abaixo é gerada a string para o rodapé da página
+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"])
-if len(casa["num_cep"])==8:
- cep=casa["num_cep"][:4]+"-"+casa["num_cep"][5:]
+    casa[item[0]] = item[1]
+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:
- cep=""
+    cep = ""
 
-linha1=casa["end_casa"]
-if cep!="":
-  if casa["end_casa"]!="" and casa["end_casa"]!=None:
+linha1 = casa["end_casa"]
+if cep != "":
+    if casa["end_casa"] != "" and casa["end_casa"] != None:
         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
-if casa["num_tel"]!="" and casa["num_tel"]!=None:
-  linha1 = linha1 + " Tel.: "+ casa["num_tel"]
-
-linha2=casa["end_web_casa"]
-if casa["end_email_casa"]!="" and casa["end_email_casa"]!=None:
-  if casa["end_web_casa"]!="" and casa["end_web_casa"]!=None:
+    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
+if casa["num_tel"] != "" and casa["num_tel"] != None:
+    linha1 = linha1 + " Tel.: " + casa["num_tel"]
+
+linha2 = casa["end_web_casa"]
+if casa["end_email_casa"] != "" and casa["end_email_casa"] != None:
+    if casa["end_web_casa"] != "" and casa["end_web_casa"] != None:
         linha2 = linha2 + " - "
-  linha2 =  linha2 + "E-mail: "+casa["end_email_casa"]
+    linha2 = linha2 + "E-mail: " + casa["end_email_casa"]
 
-data_emissao=DateTime().strftime("%d/%m/%Y")
-rodape=[linha1,linha2,data_emissao]
+data_emissao = DateTime().strftime("%d/%m/%Y")
+rodape = [linha1, linha2, data_emissao]
 
-#Por fim, gera-se as entradas para o cabeçalho
-estados=context.zsql.localidade_obter_zsql(tip_localidade="u")
+# Por fim, gera-se as entradas para o cabeçalho
+estados = context.zsql.localidade_obter_zsql(tip_localidade="u")
 for uf in estados:
- if localidade[0].sgl_uf==uf.sgl_uf:
-  nom_estado=uf.nom_localidade
+    if localidade[0].sgl_uf == uf.sgl_uf:
+        nom_estado = uf.nom_localidade
         break
-cabecalho={}
-cabecalho["nom_casa"]=casa["nom_casa"]
-cabecalho["nom_estado"]="Estado de "+nom_estado
+cabecalho = {}
+cabecalho["nom_casa"] = casa["nom_casa"]
+cabecalho["nom_estado"] = "Estado de " + nom_estado
 
 # tenta buscar o logotipo da casa LOGO_CASA
-if hasattr(context.sapl_documentos.props_sapl,'logo_casa.gif'):
+if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
     imagem = context.sapl_documentos.props_sapl['logo_casa.gif'].absolute_url()
 else:
     imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
-#Por fim, utiliza o PythonScript para pesquisar as normas e gerar os dados
+# Por fim, utiliza o PythonScript para pesquisar as normas e gerar os dados
 
-normas=[]
-REQUEST=context.REQUEST
+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'],
-                                           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['txt_ementa']=norma.txt_ementa 
-
-        dic['materia_vinculada']=" "
-        if norma.cod_materia!=None:
+                                                    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['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)
 
-filtro={} # Dicionário que conterá os dados do filtro
+filtro = {}  # Dicionário que conterá os dados do filtro
 
 # Atribuições diretas do REQUEST
-filtro['numero']=REQUEST.txt_numero
-filtro['ano']=REQUEST.txt_ano
-filtro['assunto']=REQUEST.txt_assunto
+filtro['numero'] = REQUEST.txt_numero
+filtro['ano'] = REQUEST.txt_ano
+filtro['assunto'] = REQUEST.txt_assunto
 
-filtro['tipo_norma']=''
-if REQUEST.lst_tip_norma!='':
+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)
-if caminho=='aviso':
+sessao = session.id
+caminho = context.pdf_norma_gerar(
+    sessao, imagem, data, normas, cabecalho, rodape, filtro)
+if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:
     response.redirect(caminho)

sapl/relatorios/templates/pdf_ordem_dia_preparar_pysc.py

@@ -1,56 +1,68 @@
 import os
 
-request=context.REQUEST
-response=request.RESPONSE
-session= request.SESSION
-if context.REQUEST['cod_sessao_plen']!='':
+request = context.REQUEST
+response = request.RESPONSE
+session = request.SESSION
+if context.REQUEST['cod_sessao_plen'] != '':
     cod_sessao_plen = context.REQUEST['cod_sessao_plen']
     splen = []  # lista contendo as sessões plenárias na data indicada
     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
+    for dat_sessao in context.zsql.sessao_plenaria_obter_zsql(cod_sessao_plen=cod_sessao_plen, ind_excluido=0):
+        # 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)
+        dic["des_numeracao"] = ""
+        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_turno"]=""
+            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 != "":
-                for turno in [("P","Primeiro"), ("S","Segundo"), ("U","Único"), ("L","Suplementar"), ("A","Votação Única em Regime de Urgência"), ("B","1ª Votação"), ("C","2ª e 3ª Votações")]:
+                for turno in [("P", "Primeiro"), ("S", "Segundo"), ("U", "Único"), ("L", "Suplementar"), ("A", "Votação Única em Regime de Urgência"), ("B", "1ª Votação"), ("C", "2ª e 3ª Votações")]:
                     if tramitacao.sgl_turno == turno[0]:
                         dic["des_turno"] = turno[1]
 
             dic["des_situacao"] = tramitacao.des_status
-            if dic["des_situacao"]==None:
+            if dic["des_situacao"] == None:
                 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()
+    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 = {}
@@ -99,40 +118,43 @@ if context.REQUEST['cod_sessao_plen']!='':
             break
 
     cabecalho["nom_casa"] = casa["nom_casa"]
-    cabecalho["nom_estado"] = "Estado do "+nom_estado
+    cabecalho["nom_estado"] = "Estado do " + nom_estado
 
     # 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()
+    if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
+        imagem = context.sapl_documentos.props_sapl[
+            'logo_casa.gif'].absolute_url()
     else:
         imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
     # monta o rodapé da página
     num_cep = casa["num_cep"]
     if len(casa["num_cep"]) == 8:
-        num_cep=casa["num_cep"][:4]+"-"+casa["num_cep"][5:]
+        num_cep = casa["num_cep"][:4] + "-" + casa["num_cep"][5:]
 
     linha1 = casa["end_casa"]
-    if num_cep!=None and num_cep!="":
-        if casa["end_casa"]!="" and casa["end_casa"]!=None:
-            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
-    if casa["num_tel"]!=None and casa["num_tel"]!="":
-        linha1 = linha1 +"   Tel.: "+casa["num_tel"]
+    if num_cep != None and num_cep != "":
+        if casa["end_casa"] != "" and casa["end_casa"] != None:
+            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
+    if casa["num_tel"] != None and casa["num_tel"] != "":
+        linha1 = linha1 + "   Tel.: " + casa["num_tel"]
 
     linha2 = casa["end_web_casa"]
-    if casa["end_email_casa"]!=None and casa["end_email_casa"]!="": 
-        if casa["end_web_casa"]!="" and casa["end_web_casa"]!=None:
-            linha2= linha2 + " - "
-        linha2 = linha2 +"E-mail: "+casa["end_email_casa"]
+    if casa["end_email_casa"] != None and casa["end_email_casa"] != "":
+        if casa["end_web_casa"] != "" and casa["end_web_casa"] != None:
+            linha2 = linha2 + " - "
+        linha2 = linha2 + "E-mail: " + casa["end_email_casa"]
     dat_emissao = DateTime().strftime("%d/%m/%Y")
     rodape = [linha1, linha2, dat_emissao]
 
-    sessao=session.id
-    caminho = context.pdf_ordem_dia_gerar( sessao, imagem, dat_ordem, splen, pauta, cabecalho, rodape)
-    if caminho=='aviso':
+    sessao = session.id
+    caminho = context.pdf_ordem_dia_gerar(
+        sessao, imagem, dat_ordem, splen, pauta, cabecalho, rodape)
+    if caminho == 'aviso':
         return response.redirect('mensagem_emitir_proc')
     else:
         response.redirect(caminho)

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

@@ -1,20 +1,22 @@
 import os
 
-request=context.REQUEST
-response=request.RESPONSE
-session= request.SESSION
+request = context.REQUEST
+response = request.RESPONSE
+session = request.SESSION
 
-if context.REQUEST['data']!='':
+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
@@ -26,137 +28,162 @@ if context.REQUEST['data']!='':
         inf_basicas_dic["hr_fim_sessao"] = sessao.hr_fim_sessao
 
         # Lista das matérias do Expediente, incluindo o status da tramitação
-        lst_expediente_materia=[]
-        for expediente_materia in context.zsql.votacao_expediente_materia_obter_zsql(dat_ordem=data,cod_sessao_plen=codigo,ind_excluido=0):
+        lst_expediente_materia = []
+        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)
+            dic_expediente_materia["des_numeracao"] = ""
+            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_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 != "":
-                    for turno in [("P","Primeiro"), ("S","Segundo"), ("U","Único"), ("F","Final"), ("L","Suplementar"), ("A","Votação Única em Regime de Urgência"), ("B","1ª Votação"), ("C","2ª e 3ª Votações")]:
+                    for turno in [("P", "Primeiro"), ("S", "Segundo"), ("U", "Único"), ("F", "Final"), ("L", "Suplementar"), ("A", "Votação Única em Regime de Urgência"), ("B", "1ª Votação"), ("C", "2ª e 3ª Votações")]:
                         if tramitacao.sgl_turno == turno[0]:
                             dic_expediente_materia["des_turno"] = turno[1]
 
                 dic_expediente_materia["des_situacao"] = tramitacao.des_status
-                if dic_expediente_materia["des_situacao"]==None:
+                if dic_expediente_materia["des_situacao"] == None:
                     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):
+        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)
+            dic_votacao["des_numeracao"] = ""
+            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_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 != "":
-                    for turno in [("P","Primeiro"), ("S","Segundo"), ("U","Único"), ("L","Suplementar"), ("A","Votação Única em Regime de Urgência"), ("B","1ª Votação"), ("C","2ª e 3ª Votações")]:
+                    for turno in [("P", "Primeiro"), ("S", "Segundo"), ("U", "Único"), ("L", "Suplementar"), ("A", "Votação Única em Regime de Urgência"), ("B", "1ª Votação"), ("C", "2ª e 3ª Votações")]:
                         if tramitacao.sgl_turno == turno[0]:
                             dic_votacao["des_turno"] = turno[1]
 
                 dic_votacao["des_situacao"] = tramitacao.des_status
-                if dic_votacao["des_situacao"]==None:
+                if dic_votacao["des_situacao"] == None:
                     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
-    cabecalho={}
+    # 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()
+    if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
+        imagem = context.sapl_documentos.props_sapl[
+            'logo_casa.gif'].absolute_url()
     else:
         imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
-    #Abaixo é gerado o dic do rodapé da página (linha 7)
-    casa={}
-    aux=context.sapl_documentos.props_sapl.propertyItems()
+    # Abaixo é gerado o dic do rodapé da página (linha 7)
+    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"])
-    data_emissao= DateTime().strftime("%d/%m/%Y")
-    rodape= casa
-    rodape['data_emissao']= data_emissao
-
-    inf_basicas_dic['nom_camara']= casa['nom_casa']
-    REQUEST=context.REQUEST
-    for local in context.zsql.localidade_obter_zsql(cod_localidade = casa['cod_localidade']):
-        rodape['nom_localidade']= "   "+local.nom_localidade
-        rodape['sgl_uf']= local.sgl_uf
+        casa[item[0]] = item[1]
+    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
+
+    inf_basicas_dic['nom_camara'] = casa['nom_casa']
+    REQUEST = context.REQUEST
+    for local in context.zsql.localidade_obter_zsql(cod_localidade=casa['cod_localidade']):
+        rodape['nom_localidade'] = "   " + local.nom_localidade
+        rodape['sgl_uf'] = local.sgl_uf
 
 #    return lst_votacao
-    sessao=session.id
-    caminho = context.pdf_pauta_sessao_gerar(rodape, sessao, imagem, inf_basicas_dic, lst_votacao, lst_expediente_materia)
-    if caminho=='aviso':
+    sessao = session.id
+    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:
         response.redirect(caminho)

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
@@ -11,118 +11,132 @@ import time
 from trml2pdf import parseString
 
 
-def cabecalho(dic_cabecalho,imagem):
+def cabecalho(dic_cabecalho, imagem):
     """Gera o codigo rml do cabecalho"""
-    tmp_data=''
-    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<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'
-    tmp_data+='\t\t\t\t<drawString x="2.2cm" y="24.6cm">Relatório de Controle do Protocolo</drawString>\n'
+    tmp_data = ''
+    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<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'
+    tmp_data += '\t\t\t\t<drawString x="2.2cm" y="24.6cm">Relatório de Controle do Protocolo</drawString>\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="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 = ''
+    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="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'
 
     return tmp_data
 
+
 def paraStyle():
     """Gera o codigo rml que define o estilo dos paragrafos"""
 
-    tmp_data=''
-    tmp_data+='\t<stylesheet>\n'
-    tmp_data+='\t\t<blockTableStyle id="Standard_Outline">\n'
-    tmp_data+='\t\t\t<blockAlignment value="LEFT"/>\n'
-    tmp_data+='\t\t\t<blockValign value="TOP"/>\n'
-    tmp_data+='\t\t</blockTableStyle>\n'
-    tmp_data+='\t\t<initialize>\n'
-    tmp_data+='\t\t\t<paraStyle name="all" alignment="justify"/>\n'
-    tmp_data+='\t\t</initialize>\n'
-    tmp_data+='\t\t<paraStyle name="P1" fontName="Helvetica-Bold" fontSize="10.0" leading="10" alignment="CENTER"/>\n'
-    tmp_data+='\t\t<paraStyle name="P2" fontName="Helvetica" fontSize="10.0" leading="13" alignment="justify"/>\n'
-    tmp_data+='\t</stylesheet>\n'
+    tmp_data = ''
+    tmp_data += '\t<stylesheet>\n'
+    tmp_data += '\t\t<blockTableStyle id="Standard_Outline">\n'
+    tmp_data += '\t\t\t<blockAlignment value="LEFT"/>\n'
+    tmp_data += '\t\t\t<blockValign value="TOP"/>\n'
+    tmp_data += '\t\t</blockTableStyle>\n'
+    tmp_data += '\t\t<initialize>\n'
+    tmp_data += '\t\t\t<paraStyle name="all" alignment="justify"/>\n'
+    tmp_data += '\t\t</initialize>\n'
+    tmp_data += '\t\t<paraStyle name="P1" fontName="Helvetica-Bold" fontSize="10.0" leading="10" alignment="CENTER"/>\n'
+    tmp_data += '\t\t<paraStyle name="P2" fontName="Helvetica" fontSize="10.0" leading="13" alignment="justify"/>\n'
+    tmp_data += '\t</stylesheet>\n'
 
     return tmp_data
 
+
 def protocolos(lst_protocolos):
     """Gera o codigo rml do conteudo da pesquisa de protocolos"""
 
-    tmp_data=''
+    tmp_data = ''
 
-    #inicio do bloco que contem os flowables
-    tmp_data+='\t<story>\n'
+    # inicio do bloco que contem os flowables
+    tmp_data += '\t<story>\n'
 
     for dic in lst_protocolos:
-        #espaco inicial
-        tmp_data+='\t\t<para style="P2">\n'
-        tmp_data+='\t\t\t<font color="white"> </font>\n'
-        tmp_data+='\t\t</para>\n'
-        tmp_data+='\t\t<para style="P2">\n'
-        tmp_data+='\t\t\t<font color="white"> </font>\n'
-        tmp_data+='\t\t</para>\n'
-
-        #condicao para a quebra de pagina
-        tmp_data+='\t\t<condPageBreak height="4cm"/>\n'
-
-        #protocolos 
-        if dic['titulo']!=None:
-            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'
-        if dic['txt_assunto']!=None:
-            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'
-        elif dic['nom_autor']!=None:
-           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'
-        if dic['processo']!=None:
-            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'
-        if dic['anulado']!="":
-            tmp_data+='\t\t<para style="P2"><b>** PROTOCOLO ANULADO **</b> ' '</para>\n'
-
-    tmp_data+='\t</story>\n'
+        # espaco inicial
+        tmp_data += '\t\t<para style="P2">\n'
+        tmp_data += '\t\t\t<font color="white"> </font>\n'
+        tmp_data += '\t\t</para>\n'
+        tmp_data += '\t\t<para style="P2">\n'
+        tmp_data += '\t\t\t<font color="white"> </font>\n'
+        tmp_data += '\t\t</para>\n'
+
+        # condicao para a quebra de pagina
+        tmp_data += '\t\t<condPageBreak height="4cm"/>\n'
+
+        # protocolos
+        if dic['titulo'] != None:
+            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'
+        if dic['txt_assunto'] != None:
+            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'
+        elif dic['nom_autor'] != None:
+            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'
+        if dic['processo'] != None:
+            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'
+        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"""
 
-    arquivoPdf=str(int(time.time()*100))+".pdf"
-
-    tmp_data=''
-    tmp_data+='<?xml version="1.0" encoding="utf-8" standalone="no" ?>\n'
-    tmp_data+='<!DOCTYPE document SYSTEM "rml_1_0.dtd">\n'
-    tmp_data+='<document filename="relatorio.pdf">\n'
-    tmp_data+='\t<template pageSize="(21cm, 29.7cm)" title="Relatório de Protocolos" author="Luciano De Fazio" allowSplitting="20">\n'
-    tmp_data+='\t\t<pageTemplate id="first">\n'
-    tmp_data+='\t\t\t<pageGraphics>\n'
-    tmp_data+=cabecalho(dic_cabecalho,imagem)
-    tmp_data+=rodape(lst_rodape)
-    tmp_data+='\t\t\t</pageGraphics>\n'
-    tmp_data+='\t\t\t<frame id="first" x1="2cm" y1="3cm" width="17cm" height="21cm"/>\n'
-    tmp_data+='\t\t</pageTemplate>\n'
-    tmp_data+='\t</template>\n'
-    tmp_data+=paraStyle()
-    tmp_data+=protocolos(lst_protocolos)
-    tmp_data+='</document>\n'
-    tmp_pdf=parseString(tmp_data)
+    arquivoPdf = str(int(time.time() * 100)) + ".pdf"
+
+    tmp_data = ''
+    tmp_data += '<?xml version="1.0" encoding="utf-8" standalone="no" ?>\n'
+    tmp_data += '<!DOCTYPE document SYSTEM "rml_1_0.dtd">\n'
+    tmp_data += '<document filename="relatorio.pdf">\n'
+    tmp_data += '\t<template pageSize="(21cm, 29.7cm)" title="Relatório de Protocolos" author="Luciano De Fazio" allowSplitting="20">\n'
+    tmp_data += '\t\t<pageTemplate id="first">\n'
+    tmp_data += '\t\t\t<pageGraphics>\n'
+    tmp_data += cabecalho(dic_cabecalho, imagem)
+    tmp_data += rodape(lst_rodape)
+    tmp_data += '\t\t\t</pageGraphics>\n'
+    tmp_data += '\t\t\t<frame id="first" x1="2cm" y1="3cm" width="17cm" height="21cm"/>\n'
+    tmp_data += '\t\t</pageTemplate>\n'
+    tmp_data += '\t</template>\n'
+    tmp_data += paraStyle()
+    tmp_data += protocolos(lst_protocolos)
+    tmp_data += '</document>\n'
+    tmp_pdf = parseString(tmp_data)
 
     return tmp_pdf
 
@@ -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

@@ -1,117 +1,126 @@
 import os
 
-request=context.REQUEST
-response=request.RESPONSE
-session= request.SESSION
+request = context.REQUEST
+response = request.RESPONSE
+session = request.SESSION
 
-data=DateTime().strftime('%d/%m/%Y')
+data = DateTime().strftime('%d/%m/%Y')
 
-#Abaixo é gerada a string para o rodapé da página
-casa={}
-aux=context.sapl_documentos.props_sapl.propertyItems()
+# Abaixo é gerada a string para o rodapé da página
+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"])
-if len(casa["num_cep"])==8:
- cep=casa["num_cep"][:4]+"-"+casa["num_cep"][5:]
+    casa[item[0]] = item[1]
+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:
- cep=""
+    cep = ""
 
-linha1=casa["end_casa"]
-if cep!="":
-  if casa["end_casa"]!="" and casa["end_casa"]!=None:
+linha1 = casa["end_casa"]
+if cep != "":
+    if casa["end_casa"] != "" and casa["end_casa"] != None:
         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
-if casa["num_tel"]!="" and casa["num_tel"]!=None:
-  linha1 = linha1 + " Tel.: "+ casa["num_tel"]
-
-linha2=casa["end_web_casa"]
-if casa["end_email_casa"]!="" and casa["end_email_casa"]!=None:
-  if casa["end_web_casa"]!="" and casa["end_web_casa"]!=None:
+    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
+if casa["num_tel"] != "" and casa["num_tel"] != None:
+    linha1 = linha1 + " Tel.: " + casa["num_tel"]
+
+linha2 = casa["end_web_casa"]
+if casa["end_email_casa"] != "" and casa["end_email_casa"] != None:
+    if casa["end_web_casa"] != "" and casa["end_web_casa"] != None:
         linha2 = linha2 + " - "
-  linha2 =  linha2 + "E-mail: "+casa["end_email_casa"]
+    linha2 = linha2 + "E-mail: " + casa["end_email_casa"]
 
-data_emissao=DateTime().strftime("%d/%m/%Y")
-rodape=[linha1,linha2,data_emissao]
+data_emissao = DateTime().strftime("%d/%m/%Y")
+rodape = [linha1, linha2, data_emissao]
 
-#Por fim, gera-se as entradas para o cabeçalho
-estados=context.zsql.localidade_obter_zsql(tip_localidade="u")
+# Por fim, gera-se as entradas para o cabeçalho
+estados = context.zsql.localidade_obter_zsql(tip_localidade="u")
 for uf in estados:
- if localidade[0].sgl_uf==uf.sgl_uf:
-  nom_estado=uf.nom_localidade
+    if localidade[0].sgl_uf == uf.sgl_uf:
+        nom_estado = uf.nom_localidade
         break
-cabecalho={}
-cabecalho["nom_casa"]=casa["nom_casa"]
-cabecalho["nom_estado"]="Estado de "+nom_estado
+cabecalho = {}
+cabecalho["nom_casa"] = casa["nom_casa"]
+cabecalho["nom_estado"] = "Estado de " + nom_estado
 
 # tenta buscar o logotipo da casa LOGO_CASA
-if hasattr(context.sapl_documentos.props_sapl,'logo_casa.gif'):
+if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
     imagem = context.sapl_documentos.props_sapl['logo_casa.gif'].absolute_url()
 else:
     imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
-#Por fim, utiliza o PythonScript para pesquisar os protocolos e gerar os dados
+# Por fim, utiliza o PythonScript para pesquisar os protocolos e gerar os dados
 
-protocolos=[]
-REQUEST=context.REQUEST
+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 = {}
 
-        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
+    dic['txt_assunto'] = protocolo.txt_assunto_ementa
 
-        dic['txt_interessado']=protocolo.txt_interessado
+    dic['txt_interessado'] = protocolo.txt_interessado
 
     dic['nom_autor'] = " "
-        if protocolo.cod_autor!=None:
+    if protocolo.cod_autor != None:
         for autor in context.zsql.autor_obter_zsql(cod_autor=protocolo.cod_autor):
-                if autor.des_tipo_autor=='Parlamentar':
+            if autor.des_tipo_autor == 'Parlamentar':
                 for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=autor.cod_parlamentar):
-                        dic['nom_autor']=parlamentar.nom_completo
-                elif autor.des_tipo_autor=='Comissao':
+                    dic['nom_autor'] = parlamentar.nom_completo
+            elif autor.des_tipo_autor == 'Comissao':
                 for comissao in context.zsql.comissao_obter_zsql(cod_comissao=autor.cod_comissao):
-                        dic['nom_autor']=comissao.nom_comissao
+                    dic['nom_autor'] = comissao.nom_comissao
             else:
-                    dic['nom_autor']=autor.nom_autor
+                dic['nom_autor'] = autor.nom_autor
 
-        dic['natureza']=''
-        if protocolo.tip_processo==0:
-           dic['natureza']='Administrativo'
-        if protocolo.tip_processo==1:
-           dic['natureza']='Legislativo'
+    dic['natureza'] = ''
+    if protocolo.tip_processo == 0:
+        dic['natureza'] = 'Administrativo'
+    if protocolo.tip_processo == 1:
+        dic['natureza'] = 'Legislativo'
 
-        dic['processo']=protocolo.des_tipo_materia or protocolo.des_tipo_documento
+    dic['processo'] = protocolo.des_tipo_materia or protocolo.des_tipo_documento
 
-        dic['anulado']=''
-        if protocolo.ind_anulado==1:
-           dic['anulado']='Nulo'
+    dic['anulado'] = ''
+    if protocolo.ind_anulado == 1:
+        dic['anulado'] = 'Nulo'
 
     protocolos.append(dic)
 
-filtro={} # Dicionário que conterá os dados do filtro
+filtro = {}  # Dicionário que conterá os dados do filtro
 
 # Atribuições diretas do REQUEST
-filtro['numero']=REQUEST.txt_num_protocolo
-filtro['ano']=REQUEST.txt_ano_protocolo
-filtro['tipo_protocolo']=REQUEST.rad_tip_protocolo
-filtro['tipo_processo']=REQUEST.rad_tip_processo
-filtro['assunto']=REQUEST.txt_assunto
-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)
-if caminho=='aviso':
+filtro['numero'] = REQUEST.txt_num_protocolo
+filtro['ano'] = REQUEST.txt_ano_protocolo
+filtro['tipo_protocolo'] = REQUEST.rad_tip_protocolo
+filtro['tipo_processo'] = REQUEST.rad_tip_processo
+filtro['assunto'] = REQUEST.txt_assunto
+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)
+if caminho == 'aviso':
     return response.redirect('mensagem_emitir_proc')
 else:
     response.redirect(caminho)

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

@@ -1,20 +1,22 @@
 import os
 
-request=context.REQUEST
-response=request.RESPONSE
-session= request.SESSION
+request = context.REQUEST
+response = request.RESPONSE
+session = request.SESSION
 
-if context.REQUEST['data']!='':
+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
@@ -26,8 +28,8 @@ if context.REQUEST['data']!='':
 
         # Lista da composicao da mesa diretora
         lst_mesa = []
-        for composicao in context.zsql.composicao_mesa_sessao_obter_zsql(cod_sessao_plen=sessao.cod_sessao_plen,ind_excluido=0):
-            for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=composicao.cod_parlamentar,ind_excluido=0):
+        for composicao in context.zsql.composicao_mesa_sessao_obter_zsql(cod_sessao_plen=sessao.cod_sessao_plen, ind_excluido=0):
+            for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=composicao.cod_parlamentar, ind_excluido=0):
                 for cargo in context.zsql.cargo_mesa_obter_zsql(cod_cargo=composicao.cod_cargo, ind_excluido=0):
                     dic_mesa = {}
                     dic_mesa['nom_parlamentar'] = parlamentar.nom_parlamentar
@@ -38,7 +40,7 @@ if context.REQUEST['data']!='':
         # Lista de presença na sessão
         lst_presenca_sessao = []
         for presenca in context.zsql.presenca_sessao_obter_zsql(cod_sessao_plen=sessao.cod_sessao_plen, ind_excluido=0):
-            for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=presenca.cod_parlamentar,ind_excluido=0):
+            for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=presenca.cod_parlamentar, ind_excluido=0):
                 dic_presenca = {}
                 dic_presenca["nom_parlamentar"] = parlamentar.nom_parlamentar
                 dic_presenca['sgl_partido'] = parlamentar.sgl_partido
@@ -48,70 +50,88 @@ if context.REQUEST['data']!='':
         lst_expedientes = []
         dic_expedientes = None
         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):
+            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:
                 lst_expedientes.append(dic_expedientes)
 
         # Lista das matérias do Expediente, incluindo o resultado das votacoes
-        lst_expediente_materia=[]
-        for expediente_materia in context.zsql.votacao_expediente_materia_obter_zsql(dat_ordem = data, cod_sessao_plen=sessao.cod_sessao_plen, ind_excluido=0):
+        lst_expediente_materia = []
+        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["des_numeracao"]=""
+            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)
-            dic_expediente_materia["des_turno"]=""
+            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]
                 if tram_turno.sgl_turno != "":
-                  for turno in [("P","Primeiro"), ("S","Segundo"), ("U","Único"), ("L","Suplementar"), ("A","Votação Única em Regime de Urgência"), ("B","1ª Votação"), ("C","2ª e 3ª Votações"), ("F", "Final")]:
+                    for turno in [("P", "Primeiro"), ("S", "Segundo"), ("U", "Único"), ("L", "Suplementar"), ("A", "Votação Única em Regime de Urgência"), ("B", "1ª Votação"), ("C", "2ª e 3ª Votações"), ("F", "Final")]:
                         if tram_turno.sgl_turno == turno[0]:
                             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"]=""
+            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"
@@ -120,63 +140,80 @@ if context.REQUEST['data']!='':
         # Lista dos oradores do Expediente
         lst_oradores_expediente = []
         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):
+            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
         lst_presenca_ordem_dia = []
-        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):
+        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
-        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):
+        # 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["des_numeracao"]=""
-            numeracao = context.zsql.numeracao_obter_zsql(cod_materia=votacao.cod_materia)
+            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)
             if len(numeracao):
                 numeracao = numeracao[0]
-               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)
+                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)
             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 != "":
-                  for turno in [("P","Primeiro"), ("S","Segundo"), ("U","Único"), ("L","Suplementar"), ("F","Final"), ("A","Votação Única em Regime de Urgência"), ("B","1ª Votação"), ("C","2ª e 3ª Votações")]:
+                    for turno in [("P", "Primeiro"), ("S", "Segundo"), ("U", "Único"), ("L", "Suplementar"), ("F", "Final"), ("A", "Votação Única em Regime de Urgência"), ("B", "1ª Votação"), ("C", "2ª e 3ª Votações")]:
                         if tram_turno.sgl_turno == turno[0]:
                             dic_votacao["des_turno"] = turno[1]
             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
@@ -185,13 +222,15 @@ if context.REQUEST['data']!='':
                     except:
                         dic_votacao["nom_autor"] = "NC-od"
 
-            dic_votacao["votacao_observacao"]=""
+            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"
@@ -200,42 +239,46 @@ if context.REQUEST['data']!='':
         # Lista dos oradores nas Explicações Pessoais
         lst_oradores = []
         for orador in context.zsql.oradores_obter_zsql(cod_sessao_plen=sessao.cod_sessao_plen, ind_excluido=0):
-            for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=orador.cod_parlamentar,ind_excluido=0):
+            for parlamentar in context.zsql.parlamentar_obter_zsql(cod_parlamentar=orador.cod_parlamentar, ind_excluido=0):
                 dic_oradores = {}
                 dic_oradores["num_ordem"] = orador.num_ordem
                 dic_oradores["nom_parlamentar"] = parlamentar.nom_parlamentar
                 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
-    cabecalho={}
+    # 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()
+    if hasattr(context.sapl_documentos.props_sapl, 'logo_casa.gif'):
+        imagem = context.sapl_documentos.props_sapl[
+            'logo_casa.gif'].absolute_url()
     else:
         imagem = context.imagens.absolute_url() + "/brasao_transp.gif"
 
-    #Abaixo é gerado o dic do rodapé da página (linha 7)
-    casa={}
-    aux=context.sapl_documentos.props_sapl.propertyItems()
+    # Abaixo é gerado o dic do rodapé da página (linha 7)
+    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"])
-    data_emissao= DateTime().strftime("%d/%m/%Y")
-    rodape= casa
-    rodape['data_emissao']= data_emissao
-
-    inf_basicas_dic['nom_camara']= casa['nom_casa']
-    REQUEST=context.REQUEST
-    for local in context.zsql.localidade_obter_zsql(cod_localidade = casa['cod_localidade']):
-        rodape['nom_localidade']= "   "+local.nom_localidade
-        rodape['sgl_uf']= local.sgl_uf
+        casa[item[0]] = item[1]
+    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
+
+    inf_basicas_dic['nom_camara'] = casa['nom_casa']
+    REQUEST = context.REQUEST
+    for local in context.zsql.localidade_obter_zsql(cod_localidade=casa['cod_localidade']):
+        rodape['nom_localidade'] = "   " + local.nom_localidade
+        rodape['sgl_uf'] = local.sgl_uf
 
 #    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)
-    if caminho=='aviso':
+    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)
+    if caminho == 'aviso':
         return response.redirect('mensagem_emitir_proc')
     else:
         response.redirect(caminho)

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'))
         )