ajustas heranças de seleção baseada em content_types

- muda BancadaCrud(Crud) para BancadaCrud(CrudAux) e BlocoCrud(Crud) para BlocoCrud(CrudAux) e adequa forma de buscar TipoAutor em metodos save de formulários que criam Autores automaticamente.
6 years ago · 4cdc78788f
5 changed files with 102 additions and 100 deletions
--- a/sapl/comissoes/forms.py
+++ b/sapl/comissoes/forms.py
@ -13,10 +13,13 @@ from sapl.comissoes.models import (Comissao, Composicao, DocumentoAcessorio,
                                   Participacao, Reuniao, Periodo)
 from sapl.parlamentares.models import Legislatura, Mandato, Parlamentar

+
 class ComposicaoForm(forms.ModelForm):

-    comissao = forms.CharField(required=False, label='Comissao', widget=forms.HiddenInput())
+    comissao = forms.CharField(
+        required=False, label='Comissao', widget=forms.HiddenInput())
    logger = logging.getLogger(__name__)
+
    class Meta:
        model = Composicao
        exclude = []
@ -43,8 +46,8 @@ class ComposicaoForm(forms.ModelForm):

        if intersecao_periodo:
            self.logger.error('O período informado ({} a {})'
-                        'choca com períodos já '
-                        'cadastrados para esta comissão'.format(periodo.data_inicio, periodo.data_fim))
+                              'choca com períodos já '
+                              'cadastrados para esta comissão'.format(periodo.data_inicio, periodo.data_fim))
            raise ValidationError('O período informado '
                                  'choca com períodos já '
                                  'cadastrados para esta comissão')
@ -55,6 +58,7 @@ class ComposicaoForm(forms.ModelForm):
 class PeriodoForm(forms.ModelForm):

    logger = logging.getLogger(__name__)
+
    class Meta:
        model = Periodo
        exclude = []
@ -70,31 +74,29 @@ class PeriodoForm(forms.ModelForm):

        if data_fim and data_fim < data_inicio:
            self.logger.error('A Data Final ({}) é menor que '
-                            'a Data Inicial({}).'.format(data_fim, data_inicio))
+                              'a Data Inicial({}).'.format(data_fim, data_inicio))
            raise ValidationError('A Data Final não pode ser menor que '
-                                    'a Data Inicial')
+                                  'a Data Inicial')

        # Evita NoneType exception se não preenchida a data_fim
        if not data_fim:
            data_fim = data_inicio

        legislatura = Legislatura.objects.filter(data_inicio__lte=data_inicio,
-                                                   data_fim__gte=data_fim,
-                                                   )
+                                                 data_fim__gte=data_fim,
+                                                 )

        if not legislatura:
            self.logger.error('O período informado ({} a {})'
-                            'não está contido em uma única '
-                            'legislatura existente'.format(data_inicio, data_fim))
+                              'não está contido em uma única '
+                              'legislatura existente'.format(data_inicio, data_fim))
            raise ValidationError('O período informado '
                                  'deve estar contido em uma única '
                                  'legislatura existente')

-
        return cleaned_data


-
 class ParticipacaoCreateForm(forms.ModelForm):

    logger = logging.getLogger(__name__)
@ -122,9 +124,9 @@ class ParticipacaoCreateForm(forms.ModelForm):
        parlamentares = Mandato.objects.filter(qs,
                                               parlamentar__ativo=True
                                               ).prefetch_related('parlamentar').\
-                                                values_list('parlamentar',
-                                                            flat=True
-                                                            ).distinct()
+            values_list('parlamentar',
+                        flat=True
+                        ).distinct()

        qs = Parlamentar.objects.filter(id__in=parlamentares).distinct().\
            exclude(id__in=id_part)
@ -137,7 +139,6 @@ class ParticipacaoCreateForm(forms.ModelForm):
            qs = Parlamentar.objects.filter(id__in=ids)
            self.fields['parlamentar'].queryset = qs

-
    def clean(self):
        cleaned_data = super(ParticipacaoCreateForm, self).clean()

@ -148,22 +149,23 @@ class ParticipacaoCreateForm(forms.ModelForm):
        data_desligamento = cleaned_data['data_desligamento']

        if data_desligamento and \
-            data_designacao > data_desligamento:
+                data_designacao > data_desligamento:
            self.logger.error('Data de designação ({}) superior '
-                            'à data de desligamento ({})'.format(data_designacao, data_desligamento))
+                              'à data de desligamento ({})'.format(data_designacao, data_desligamento))
            raise ValidationError(_('Data de designação não pode ser superior '
-                                  'à data de desligamento'))
+                                    'à data de desligamento'))

        composicao = Composicao.objects.get(id=self.initial['parent_pk'])
-        cargos_unicos = [c.cargo.nome for c in composicao.participacao_set.filter(cargo__unico=True)]
+        cargos_unicos = [
+            c.cargo.nome for c in composicao.participacao_set.filter(cargo__unico=True)]

        if cleaned_data['cargo'].nome in cargos_unicos:
            msg = _('Este cargo é único para esta Comissão.')
-            self.logger.error('Este cargo ({}) é único para esta Comissão.'.format(cleaned_data['cargo'].nome))
+            self.logger.error('Este cargo ({}) é único para esta Comissão.'.format(
+                cleaned_data['cargo'].nome))
            raise ValidationError(msg)
        return cleaned_data

-
    def create_participacao(self):
        composicao = Composicao.objects.get(id=self.initial['parent_pk'])
        data_inicio_comissao = composicao.periodo.data_inicio
@ -237,9 +239,9 @@ class ParticipacaoEditForm(forms.ModelForm):
        if data_desligamento and \
           data_designacao > data_desligamento:
            self.logger.error('Data de designação ({}) superior '
-                            'à data de desligamento ({})'.format(data_designacao, data_desligamento))
+                              'à data de desligamento ({})'.format(data_designacao, data_desligamento))
            raise ValidationError(_('Data de designação não pode ser superior '
-                                  'à data de desligamento'))
+                                    'à data de desligamento'))

        composicao_id = self.instance.composicao_id

@ -250,7 +252,7 @@ class ParticipacaoEditForm(forms.ModelForm):
        if cleaned_data['cargo'].nome in cargos_unicos:
            msg = _('Este cargo é único para esta Comissão.')
            self.logger.error('Este cargo ({}) é único para esta Comissão (id={}).'
-                            .format(cleaned_data['cargo'].nome, composicao_id))
+                              .format(cleaned_data['cargo'].nome, composicao_id))
            raise ValidationError(msg)

        return cleaned_data
@ -259,6 +261,7 @@ class ParticipacaoEditForm(forms.ModelForm):
 class ComissaoForm(forms.ModelForm):

    logger = logging.getLogger(__name__)
+
    class Meta:
        model = Comissao
        fields = '__all__'
@ -274,8 +277,6 @@ class ComissaoForm(forms.ModelForm):
                self.fields['data_prorrogada_temp'].widget.attrs['disabled'] = 'disabled'
                self.fields['data_fim_comissao'].widget.attrs['disabled'] = 'disabled'

-
-
    def clean(self):
        super(ComissaoForm, self).clean()

@ -283,51 +284,54 @@ class ComissaoForm(forms.ModelForm):
            return self.cleaned_data

        if len(self.cleaned_data['nome']) > 100:
-            msg = _('Nome da Comissão informado ({}) tem mais de 50 caracteres.'.format(self.cleaned_data['nome']))
-            self.logger.error('Nome da Comissão deve ter no máximo 50 caracteres.')
+            msg = _('Nome da Comissão informado ({}) tem mais de 50 caracteres.'.format(
+                self.cleaned_data['nome']))
+            self.logger.error(
+                'Nome da Comissão deve ter no máximo 50 caracteres.')
            raise ValidationError(msg)
        if (self.cleaned_data['data_extincao'] and
            self.cleaned_data['data_extincao'] <
                self.cleaned_data['data_criacao']):
-                msg = _('Data de extinção não pode ser menor que a de criação')
-                self.logger.error('Data de extinção ({}) não pode ser menor que a de criação ({}).'
-                        .format(self.cleaned_data['data_extincao'],self.cleaned_data['data_criacao']))
-                raise ValidationError(msg)
+            msg = _('Data de extinção não pode ser menor que a de criação')
+            self.logger.error('Data de extinção ({}) não pode ser menor que a de criação ({}).'
+                              .format(self.cleaned_data['data_extincao'], self.cleaned_data['data_criacao']))
+            raise ValidationError(msg)
        if (self.cleaned_data['data_final_prevista_temp'] and
            self.cleaned_data['data_final_prevista_temp'] <
                self.cleaned_data['data_criacao']):
-                msg = _('Data Prevista para Término não pode ser menor que a de criação')
-                self.logger.error('Data Prevista para Término ({}) não pode ser menor que a de criação ({}).'
-                                .format(self.cleaned_data['data_final_prevista_temp'], self.cleaned_data['data_criacao']))
-                raise ValidationError(msg)
+            msg = _('Data Prevista para Término não pode ser menor que a de criação')
+            self.logger.error('Data Prevista para Término ({}) não pode ser menor que a de criação ({}).'
+                              .format(self.cleaned_data['data_final_prevista_temp'], self.cleaned_data['data_criacao']))
+            raise ValidationError(msg)
        if (self.cleaned_data['data_prorrogada_temp'] and
            self.cleaned_data['data_prorrogada_temp'] <
                self.cleaned_data['data_criacao']):
-                msg = _('Data Novo Prazo não pode ser menor que a de criação')
-                self.logger.error('Data Novo Prazo ({}) não pode ser menor que a de criação ({}).'
-                                .format(self.cleaned_data['data_prorrogada_temp'], self.cleaned_data['data_criacao']))
-                raise ValidationError(msg)
+            msg = _('Data Novo Prazo não pode ser menor que a de criação')
+            self.logger.error('Data Novo Prazo ({}) não pode ser menor que a de criação ({}).'
+                              .format(self.cleaned_data['data_prorrogada_temp'], self.cleaned_data['data_criacao']))
+            raise ValidationError(msg)
        if (self.cleaned_data['data_instalacao_temp'] and
            self.cleaned_data['data_instalacao_temp'] <
                self.cleaned_data['data_criacao']):
-                msg = _('Data de Instalação não pode ser menor que a de criação')
-                self.logger.error('Data de Instalação ({}) não pode ser menor que a de criação ({}).'
-                                .format(self.cleaned_data['data_instalacao_temp'], self.cleaned_data['data_criacao']))
-                raise ValidationError(msg)
+            msg = _('Data de Instalação não pode ser menor que a de criação')
+            self.logger.error('Data de Instalação ({}) não pode ser menor que a de criação ({}).'
+                              .format(self.cleaned_data['data_instalacao_temp'], self.cleaned_data['data_criacao']))
+            raise ValidationError(msg)
        if (self.cleaned_data['data_final_prevista_temp'] and self.cleaned_data['data_instalacao_temp'] and
            self.cleaned_data['data_final_prevista_temp'] <
                self.cleaned_data['data_instalacao_temp']):
-                msg = _('Data Prevista para Término não pode ser menor que a de Instalação.')
-                self.logger.error('Data Prevista para Término ({}) não pode ser menor que a de Instalação ({}).'
-                        .format(self.cleaned_data['data_final_prevista_temp'], self.cleaned_data['data_instalacao_temp']))
-                raise ValidationError(msg)
+            msg = _(
+                'Data Prevista para Término não pode ser menor que a de Instalação.')
+            self.logger.error('Data Prevista para Término ({}) não pode ser menor que a de Instalação ({}).'
+                              .format(self.cleaned_data['data_final_prevista_temp'], self.cleaned_data['data_instalacao_temp']))
+            raise ValidationError(msg)
        if (self.cleaned_data['data_prorrogada_temp'] and self.cleaned_data['data_instalacao_temp'] and
            self.cleaned_data['data_prorrogada_temp'] <
                self.cleaned_data['data_instalacao_temp']):
-                msg = _('Data Novo Prazo não pode ser menor que a de Instalação.')
-                self.logger.error('Data Novo Prazo ({}) não pode ser menor que a de Instalação ({}).'
-                        .format(self.cleaned_data['data_prorrogada_temp'], self.cleaned_data['data_instalacao_temp']))
-                raise ValidationError(msg)
+            msg = _('Data Novo Prazo não pode ser menor que a de Instalação.')
+            self.logger.error('Data Novo Prazo ({}) não pode ser menor que a de Instalação ({}).'
+                              .format(self.cleaned_data['data_prorrogada_temp'], self.cleaned_data['data_instalacao_temp']))
+            raise ValidationError(msg)
        return self.cleaned_data

    @transaction.atomic
@ -337,7 +341,7 @@ class ComissaoForm(forms.ModelForm):
            comissao = super(ComissaoForm, self).save(commit)
            content_type = ContentType.objects.get_for_model(Comissao)
            object_id = comissao.pk
-            tipo = TipoAutor.objects.get(descricao__icontains='Comiss')
+            tipo = TipoAutor.objects.get(content_type=content_type)
            nome = comissao.sigla + ' - ' + comissao.nome
            Autor.objects.create(
                content_type=content_type,
@ -363,7 +367,6 @@ class ReuniaoForm(ModelForm):

    def clean(self):
        super(ReuniaoForm, self).clean()
-        

        if not self.is_valid():
            return self.cleaned_data
@ -371,12 +374,14 @@ class ReuniaoForm(ModelForm):
        if self.cleaned_data['hora_fim']:
            if (self.cleaned_data['hora_fim'] <
                    self.cleaned_data['hora_inicio']):
-                msg = _('A hora de término da reunião não pode ser menor que a de início')
+                msg = _(
+                    'A hora de término da reunião não pode ser menor que a de início')
                self.logger.error("A hora de término da reunião ({}) não pode ser menor que a de início ({})."
-                                .format(self.cleaned_data['hora_fim'], self.cleaned_data['hora_inicio']))
+                                  .format(self.cleaned_data['hora_fim'], self.cleaned_data['hora_inicio']))
                raise ValidationError(msg)
        return self.cleaned_data

+
 class DocumentoAcessorioCreateForm(forms.ModelForm):

    parent_pk = forms.CharField(required=False)  # widget=forms.HiddenInput())
@ -395,7 +400,6 @@ class DocumentoAcessorioCreateForm(forms.ModelForm):
            documentos = reuniao.documentoacessorio_set.all()
            return self.create_documentoacessorio()

-
    def create_documentoacessorio(self):
        reuniao = Reuniao.objects.get(id=self.initial['parent_pk'])

--- a/sapl/materia/forms.py
+++ b/sapl/materia/forms.py
@ -96,7 +96,7 @@ class OrgaoForm(ModelForm):
        orgao = super(OrgaoForm, self).save(commit)
        content_type = ContentType.objects.get_for_model(Orgao)
        object_id = orgao.pk
-        tipo = TipoAutor.objects.get(descricao='Órgão')
+        tipo = TipoAutor.objects.get(content_type=content_type)
        nome = orgao.nome + ' - ' + orgao.sigla
        Autor.objects.create(
            content_type=content_type,
--- a/sapl/parlamentares/forms.py
+++ b/sapl/parlamentares/forms.py
@ -1,6 +1,5 @@
-import logging
-
 from datetime import timedelta
+import logging

 from crispy_forms.helper import FormHelper
 from crispy_forms.layout import Fieldset, Layout
@ -46,8 +45,8 @@ def validar_datas_legislatura(eleicao, inicio, fim, pk=None):
    # Verifica se data de eleição < inicio < fim
    if inicio >= fim or eleicao >= inicio:
        logger.error('A data início ({}) deve ser menor que a ' +
-                    'data fim ({}) e a data eleição ({}) deve ser ' +
-                    'menor que a data início ({})'.format(inicio, fim, eleicao, inicio))
+                     'data fim ({}) e a data eleição ({}) deve ser ' +
+                     'menor que a data início ({})'.format(inicio, fim, eleicao, inicio))
        msg_error = _('A data início deve ser menor que a ' +
                      'data fim e a data eleição deve ser ' +
                      'menor que a data início')
@ -66,7 +65,8 @@ def validar_datas_legislatura(eleicao, inicio, fim, pk=None):
    # Verifica se há alguma outra data de eleição cadastrada
    if Legislatura.objects.filter(
            data_eleicao=eleicao).exclude(pk=pk).exists():
-        logger.error("Esta data de eleição ({}) já foi cadastrada.".format(eleicao))
+        logger.error(
+            "Esta data de eleição ({}) já foi cadastrada.".format(eleicao))
        msg_error = _('Esta data de eleição já foi cadastrada')
        return (False, msg_error)

@ -75,6 +75,7 @@ def validar_datas_legislatura(eleicao, inicio, fim, pk=None):

 class MandatoForm(ModelForm):
    logger = logging.getLogger(__name__)
+
    class Meta:
        model = Mandato
        fields = ['legislatura', 'coligacao', 'votos_recebidos',
@ -108,30 +109,30 @@ class MandatoForm(ModelForm):
            if (data_fim_mandato < legislatura.data_inicio or
                    data_fim_mandato > legislatura.data_fim):
                self.logger.error("Data fim mandato ({}) fora do intervalo"
-                                " de legislatura informada ({} a {})."
-                                .format(data_fim_mandato, legislatura.data_inicio, legislatura.data_fim))
+                                  " de legislatura informada ({} a {})."
+                                  .format(data_fim_mandato, legislatura.data_inicio, legislatura.data_fim))
                raise ValidationError(_("Data fim mandato fora do intervalo de"
                                        " legislatura informada"))

        data_expedicao_diploma = data['data_expedicao_diploma']
        if (data_expedicao_diploma and
                data_expedicao_diploma > data_inicio_mandato):
-                self.logger.error("A data da expedição do diploma ({}) deve ser anterior "
-                                  "a data de início do mandato ({}).".format(data_expedicao_diploma, data_inicio_mandato))
-                raise ValidationError(_("A data da expedição do diploma deve ser anterior "
-                                        "a data de início do mandato"))
+            self.logger.error("A data da expedição do diploma ({}) deve ser anterior "
+                              "a data de início do mandato ({}).".format(data_expedicao_diploma, data_inicio_mandato))
+            raise ValidationError(_("A data da expedição do diploma deve ser anterior "
+                                    "a data de início do mandato"))

        coligacao = data['coligacao']
        if coligacao and not coligacao.legislatura == legislatura:
-                self.logger.error("A coligação selecionada ({}) não está cadastrada "
-                                  "na mesma legislatura ({}) que o presente mandato ({}), "
-                                  "favor verificar a coligação ou fazer o cadastro "
-                                  "de uma nova coligação na legislatura correspondente"
-                                  .format(coligacao, coligacao.legislatura, legislatura))
-                raise ValidationError(_("A coligação selecionada não está cadastrada "
-                                        "na mesma legislatura que o presente mandato, "
-                                        "favor verificar a coligação ou fazer o cadastro "
-                                        "de uma nova coligação na legislatura correspondente"))
+            self.logger.error("A coligação selecionada ({}) não está cadastrada "
+                              "na mesma legislatura ({}) que o presente mandato ({}), "
+                              "favor verificar a coligação ou fazer o cadastro "
+                              "de uma nova coligação na legislatura correspondente"
+                              .format(coligacao, coligacao.legislatura, legislatura))
+            raise ValidationError(_("A coligação selecionada não está cadastrada "
+                                    "na mesma legislatura que o presente mandato, "
+                                    "favor verificar a coligação ou fazer o cadastro "
+                                    "de uma nova coligação na legislatura correspondente"))

        existe_mandato = Mandato.objects.filter(
            parlamentar=data['parlamentar'],
@ -158,7 +159,6 @@ class LegislaturaForm(ModelForm):
        if not self.is_valid():
            return self.cleaned_data

-
        numero = data['numero']
        data_inicio = data['data_inicio']
        data_fim = data['data_fim']
@ -166,7 +166,6 @@ class LegislaturaForm(ModelForm):

        pk = self.instance.pk

-
        ultima_legislatura = Legislatura.objects.filter(data_inicio__lt=data_inicio
                                                        ).order_by('-data_inicio').first()
        proxima_legislatura = Legislatura.objects.filter(data_fim__gt=data_fim
@ -175,13 +174,14 @@ class LegislaturaForm(ModelForm):
        if ultima_legislatura and ultima_legislatura.numero >= numero:
            self.logger.error("Número ({}) deve ser maior que o da legislatura anterior ({})."
                              .format(numero, ultima_legislatura.numero))
-            raise ValidationError(_("Número deve ser maior que o da legislatura anterior"))
+            raise ValidationError(
+                _("Número deve ser maior que o da legislatura anterior"))
        elif proxima_legislatura and proxima_legislatura.numero <= numero:
            self.logger.error("O Número ({}) deve ser menor que {}, pois existe uma "
                              "legislatura afrente cronologicamente desta que está sendo criada!"
                              .format(numero, proxima_legislatura.numero))
            msg_erro = "O Número deve ser menor que {}, pois existe uma " \
-            "legislatura afrente cronologicamente desta que está sendo criada!"
+                "legislatura afrente cronologicamente desta que está sendo criada!"
            msg_erro = msg_erro.format(proxima_legislatura.numero)
            raise ValidationError(_(msg_erro))

@ -241,7 +241,7 @@ class ParlamentarCreateForm(ParlamentarForm):
            data_expedicao_diploma=self.cleaned_data['data_expedicao_diploma'])
        content_type = ContentType.objects.get_for_model(Parlamentar)
        object_id = parlamentar.pk
-        tipo = TipoAutor.objects.get(descricao='Parlamentar')
+        tipo = TipoAutor.objects.get(content_type=content_type)
        Autor.objects.create(
            content_type=content_type,
            object_id=object_id,
@ -385,6 +385,7 @@ class ComposicaoColigacaoForm(ModelForm):

 class FrenteForm(ModelForm):
    logger = logging.getLogger(__name__)
+
    def __init__(self, *args, **kwargs):
        super(FrenteForm, self).__init__(*args, **kwargs)
        self.fields['parlamentares'].queryset = Parlamentar.objects.filter(
@ -404,15 +405,16 @@ class FrenteForm(ModelForm):

        if cd['data_extincao'] and cd['data_criacao'] >= cd['data_extincao']:
            self.logger.error("Data Dissolução ({}) não pode ser anterior a Data Criação ({})."
-                              .format(cd['data_extincao'],cd['data_criacao']))
-            raise ValidationError(_("Data Dissolução não pode ser anterior a Data Criação"))
+                              .format(cd['data_extincao'], cd['data_criacao']))
+            raise ValidationError(
+                _("Data Dissolução não pode ser anterior a Data Criação"))

        return cd

    @transaction.atomic
    def save(self, commit=True):
        frente = super(FrenteForm, self).save(commit)
-        
+
        if not self.instance.pk:
            frente = super(FrenteForm, self).save(commit)
            content_type = ContentType.objects.get_for_model(Frente)
@ -466,7 +468,8 @@ class VotanteForm(ModelForm):
        username = cd['username']
        user = get_user_model().objects.filter(username=username)
        if not user.exists():
-            self.logger.error("Não foi possível vincular usuário. Usuário {} não existe.".format(username))
+            self.logger.error(
+                "Não foi possível vincular usuário. Usuário {} não existe.".format(username))
            raise ValidationError(_(
                "{} [{}] {}".format(
                    'Não foi possível vincular usuário. Usuário',
--- a/sapl/sessao/forms.py
+++ b/sapl/sessao/forms.py
@ -317,7 +317,7 @@ class BancadaForm(ModelForm):
        bancada = super(BancadaForm, self).save(commit)
        content_type = ContentType.objects.get_for_model(Bancada)
        object_id = bancada.pk
-        tipo = TipoAutor.objects.get(descricao__icontains='Bancada')
+        tipo = TipoAutor.objects.get(content_type=content_type)
        Autor.objects.create(
            content_type=content_type,
            object_id=object_id,
@ -352,7 +352,7 @@ class BlocoForm(ModelForm):
        bloco = super(BlocoForm, self).save(commit)
        content_type = ContentType.objects.get_for_model(Bloco)
        object_id = bloco.pk
-        tipo = TipoAutor.objects.get(descricao__icontains='Bloco')
+        tipo = TipoAutor.objects.get(content_type=content_type)
        Autor.objects.create(
            content_type=content_type,
            object_id=object_id,
--- a/sapl/sessao/views.py
+++ b/sapl/sessao/views.py
@ -614,26 +614,20 @@ class OradorCrud(OradorCrud):
            return initial


-class BancadaCrud(Crud):
+class BancadaCrud(CrudAux):
    model = Bancada

-    class ListView(Crud.ListView):
-        template_name = 'crud/list_tabaux.html'
-
-    class CreateView(Crud.CreateView):
+    class CreateView(CrudAux.CreateView):
        form_class = BancadaForm

        def get_success_url(self):
            return reverse('sapl.sessao:bancada_list')


-class BlocoCrud(Crud):
+class BlocoCrud(CrudAux):
    model = Bloco

-    class ListView(Crud.ListView):
-        template_name = 'crud/list_tabaux.html'
-
-    class CreateView(Crud.CreateView):
+    class CreateView(CrudAux.CreateView):
        form_class = BlocoForm

        def get_success_url(self):
@ -1902,7 +1896,8 @@ class VotacaoView(SessaoPermissionMixin):
                qtde_presentes -= 1

            if (qtde_votos > qtde_presentes or qtde_votos < qtde_presentes):
-                msg = _('O total de votos não corresponde com a quantidade de presentes!')
+                msg = _(
+                    'O total de votos não corresponde com a quantidade de presentes!')
                messages.add_message(request, messages.ERROR, msg)
                return self.render_to_response(context)
            elif (qtde_presentes == qtde_votos):