Sistema de Auditoria (RAAI - Relatorio Anual de Auditoria Interna)

forms.py

# -*- coding: utf8 -*-
import time, datetime 
from datetime import date

from django import forms
from django.contrib.auth.models import User
from django.conf import settings

from bootstrap_toolkit.widgets import BootstrapDateInput

from .models import TipoAssunto, RecomendacaoAuditoria, DespachoAuditoria


class TipoAssuntoForm(forms.ModelForm):

    def __init__(self, *args, **kwargs):
        super(TipoAssuntoForm, self).__init__(*args, **kwargs)
        # change a widget attribute:
        self.fields['codigo_assunto'].widget.attrs["class"] = "span1"        
        self.fields['descricao'].widget.attrs["class"] = "span8"
        
    class Meta:
        model = TipoAssunto


class TipoAssuntoAtualizacaoForm(forms.ModelForm):

    def __init__(self, *args, **kwargs):
        super(TipoAssuntoAtualizacaoForm, self).__init__(*args, **kwargs)
        # change a widget attribute:
        self.fields['codigo_assunto'].widget.attrs["class"] = "span1"        
        self.fields['descricao'].widget.attrs["class"] = "span8"
        

    codigo_assunto = forms.IntegerField(label='Código', widget=forms.TextInput(attrs={'readonly': 'readonly'}))    

    class Meta:
        model = TipoAssunto


class RecomendacaoAuditoriaForm(forms.ModelForm):

    class Meta:
        model = RecomendacaoAuditoria
        exclude = ('numero_recomendacao',)

    def clean(self):
        ano = self.cleaned_data.get('ano')
        prazo = self.cleaned_data.get('prazo')
        if ano < 2011:
            raise forms.ValidationError(u"Ano Inválido!")
        if prazo < datetime.date.today():
            raise forms.ValidationError(u"Prazo tem que ser maior que hoje!")
        return data
        

# TODO: Tenta deixar o nome do form mais enxuto possível, mas claro.
class RecomendacaoAuditoriaAtualizacaoForm(forms.ModelForm):

    def __init__(self, *args, **kwargs):
        super(RecomendacaoAuditoriaAtualizacaoForm, self).__init__(*args, **kwargs)
        instance = getattr(self, 'instance', None)
        if instance and instance.id:
            self.fields['codigo_assunto'].widget.attrs['readonly'] = True

    def clean_assunto(self):
        return self.instance.codigo_assunto
 	
    recomendacao = forms.IntegerField(label='Número', widget=forms.TextInput(attrs={'readonly': 'readonly'}))    	
    ano = forms.IntegerField(label='Ano', widget=forms.TextInput(attrs={'readonly': 'readonly'}))    
    
    class Meta:
        model = RecomendacaoAuditoria
    def clean_ano(self):
        ano = self.cleaned_data.get('ano')
        if ano < 2011:
	    raise forms.ValidationError(u"Ano Inválido!")
        return ano
        
         
class DespachoAuditoriaForm(forms.ModelForm):

    class Meta:
        model = DespachoAuditoria
        exclude = ('despacho',) 
          

class DespachoAuditoriaAtualizacaoForm(forms.ModelForm):
    def __init__(self, *args, **kwargs):
        super(DespachoAuditoriaAtualizacaoForm, self).__init__(*args, **kwargs)
        instance = getattr(self, 'instance', None)
        if instance and instance.id:
            self.fields['recomendacao'].widget.attrs['readonly'] = True
            self.fields['despacho'].widget.attrs['readonly'] = True            

    class Meta:
          model = DespachoAuditoria

    def clean_prazo(self):
        prazo    = self.cleaned_data.get('prazo')
        despacho    = self.cleaned_data.get('despacho')
        if prazo < despacho:
            raise forms.ValidationError(u"Data prevista para término tem que ser maior ou igual que a data do despacho!")
        recomendacao = self.cleaned_data['recomendacao']
        raise forms.ValidationError(recomendacao.pk)   # TODO: Precisa mesmo disso?
        return prazo

models.py

# -*- coding: utf-8 -*-
import datetime

from django.db import models
from django.contrib.auth.models import User
from django.utils.translation import ugettext as _


class TipoAssunto (models.Model):
    codigo_assunto = models.IntegerField(('Código'), primary_key=True)
    descricao = models.CharField(('Descrição'), max_length=100)

    class Meta:
        verbose_name = u'Assunto'
        verbose_name_plural = u'Assuntos'
        db_table = 'tipo_assunto'
        ordering = ('codigo_assunto', )
    
    def __unicode__(self):
         return u'%s' % (self.codigo_assunto)


class UnidadeOrganizacional (models.Model):
    codigo_local = models.IntegerField(('Código'), primary_key=True)
    descricao = models.CharField(('Descrição'), max_length=40)

    class Meta:
        verbose_name = u'Unidade Organizacional'
        verbose_name_plural = u'Uniddes Organizacionais'
        db_table = 'unidade_organizacional'
    
    def __unicode__(self):
        return self.descricao
     
   
class RecomendacaoAuditoria(models.Model):
    SITUACAO_CHOICES = (
        ('1',u'Em execução/estudo'),
        ('3', 'Concluída'),
    )

    RELEVANCIA_CHOICES = (
        ('3', u'Alto'),
        ('2', u'Médio'),
        ('1', u'Baixo'),
    )

    codigo_assunto = models.ForeignKey(tipo_assunto, verbose_name = 'Assunto')
    ano = models.IntegerField('Ano')    
    recomendacao= models.IntegerField('Número')
        
    situacao = models.CharField('Situação', max_length=1, choices=SITUACAO_CHOICES, db_index=True)        
    data_recomendacao = models.DateField('Data', auto_now_add=True)
    titulo = models.TextField('Titulo', null=True, blank=False)
    descricao = models.TextField('Descrição', null=True, blank=True)	
    local_responsavel = models.ForeignKey(unidade_organizacional,
                                               verbose_name = u'Diretoria/Gerência',
    )
    localidades = models.CharField('Outras localidades', max_length=40, null=True, blank=True)
    email_principal = models.EmailField(blank=False, verbose_name='E-mail Principal')
    ds_email_segundario = models.EmailField(blank=True, verbose_name='E-mail Secundário')    
    dt_prazo = models.DateField('Data prevista para conclusão')
    cd_grau_relevancia = models.CharField('Relevância', max_length=1, choices=RELEVANCIA_CHOICES) 
    cd_usuario_atualizacao = models.ForeignKey(User, editable=False) 
    dh_atualizacao = models.DateTimeField('Atualizado em', auto_now_add=True)

    class Meta:
        verbose_name = u'Recomendação'
        verbose_name_plural = u'Recomendações'
        db_table = 'recomendacao_auditoria'

    def __unicode__(self):
         return u'%s/%s' % (self.ano, self.recomendacao)
    
	
class DespachoAuditoria(models.Model):
    recomendacao = models.ForeignKey(RecomendacaoAuditoria, verbose_name = 'Recomendação')
    usuario_atualizacao = models.ForeignKey(User, editable=False) 
    titulo = models.CharField(u'Título', max_length=50, null=True, blank=True)
    despacho = models.TextField(u'Descrição', null=True, blank=True)
    despacho = models.DateField(u'Data do Despacho')
    prazo = models.DateField(u'Data prevista para término')
    atualizacao = models.DateTimeField(u'Atualizado em', auto_now_add=True)

     class Meta:
        verbose_name = u'Despacho'
        verbose_name_plural = u'Despachos'	
        db_table = 'despacho_auditoria'

    def __unicode__(self):
        return self.titulo

views.py

# -*- encoding: utf-8 -*-
import datetime

from django.shortcuts import render, get_object_or_404
from django.template.context import RequestContext
from django.http import HttpResponseRedirect
from django.contrib.auth.decorators import login_required
from django.db.models import Max, Count

from audit.raai.forms import TipoAssuntoForm, TipoAssuntoAtualizacaoForm, RecomendacaoAuditoriaForm
from audit.raai.forms import RecomendacaoAuditoriaAtualizacaoForm, DespachoAuditoriaForm, DespachoAuditoriaAtualizacaoForm
from audit.raai.models import TipoAssunto, RecomendacaoAuditoria, DespachoAuditoria


@login_required
def lista_assunto(request):
    lista_itens = TipoAssunto.objects.all()
    return render(request, 'listaAssunto.html', {'lista_itens': lista_itens})
    
@login_required
def adiciona_assunto(request):
    layout = 'horizontal'
    titulo = u'Tipo de Assunto'
    acao   = 'Adicionar'
    retorno = '/listaAssunto'
    if request.method == "POST":
       if request.POST.get('cancel', None):
           return HttpResponseRedirect(retorno)
       form = TipoAssuntoForm(request.POST, request.FILES)
       if form.is_valid():	      
          form.save()
          mensagem = 'Inclusão feita com sucesso.'
          return render_to_response("sucesso.html", RequestContext(request, {
            'retorno': retorno,
            'mensagem': mensagem,
          }))           
    else:
       form = TipoAssuntoForm()
    return render_to_response('adiciona.html', RequestContext(request, {
        'form': form,
        'layout': layout,
        'titulo': titulo,
        'acao' : acao,
    }))

@login_required
def atualiza_assunto(request, cd_assunto):
    layout = 'horizontal'
    titulo = u'Tipo de Assunto'
    acao   = 'Salvar'
    retorno = '/listaAssunto'
    assunto = get_object_or_404(tipo_assunto, pk=cd_assunto)
    if request.method == "POST":
       if request.POST.get('cancel', None):
           return HttpResponseRedirect(retorno)
       if request.POST.get('delete', None):
           if recomendacao_auditoria.objects.filter(cd_assunto=assunto.cd_assunto).aggregate(Count('cd_assunto')).itervalues().next() == 0 :
              assunto.delete()
              mensagem = 'Exclusão feita com sucesso.'
              return render_to_response("sucesso.html", RequestContext(request, {
                 'retorno': retorno,
                 'mensagem': mensagem,
                 }))  

           else:
              mensagem = 'Exclusão não permitida. Existem recomendações para este assunto.'
              return render_to_response("erro.html", RequestContext(request, {
                 'retorno': retorno,
                 'mensagem': mensagem,
                 }))  
             
       else:
           form = TipoAssuntoAtualizacaoForm(request.POST, request.FILES,instance=assunto)
           if not form.has_changed():
               return HttpResponseRedirect(retorno)		   
           if form.is_valid():
               form.save()
               mensagem = 'Atualização feita com sucesso.'
               return render_to_response("sucesso.html", RequestContext(request, {
                  'retorno': retorno,
                  'mensagem': mensagem,
                  }))  

    else:
       form = TipoAssuntoAtualizacaoForm(instance=assunto)	
       return render_to_response('adiciona.html', RequestContext(request, {
        'form': form,
        'layout': layout,
        'titulo': titulo,
        'acao' : acao,
    }))  
	
@login_required	
def lista_recomendacao_auditoria(request):
    lista_itens = recomendacao_auditoria.objects.all()
    lista_assuntos = tipo_assunto.objects.all().order_by("cd_assunto")
    filtro = '0'
    ds_assunto = ''
    if request.method == "POST":
       filtro = 'post'
       if request.POST.get('filtrar', ''):
          filtro = request.POST.get('assunto', '')
          if filtro != '0' :
             ds_assunto = tipo_assunto.objects.get(pk=filtro).ds_assunto
             lista_itens = recomendacao_auditoria.objects.filter(cd_assunto=filtro)
    
    return render_to_response("listaRecomendacaoAuditoria.html", {'lista_itens': lista_itens, 'lista_assuntos': lista_assuntos, }, context_instance=RequestContext(request, {
    'filtro': filtro,
    'ds_assunto': ds_assunto,
    })) 	
    
@login_required
def adiciona_recomendacao_auditoria(request):
    layout = 'horizontal'
    titulo = u'Recomendações'
    acao   = 'Adicionar'
    retorno = '/listaRecomendacaoAuditoria'
    if request.method == "POST":
       if request.POST.get('cancel', None):
           return HttpResponseRedirect(retorno)
       form = RecomendacaoAuditoriaForm(request.POST, request.FILES)
       if form.is_valid():	 
          recomendacao = form.save(commit=False)
          recomendacao.cd_usuario_atualizacao = request.user
          nr_recomendacao=recomendacao_auditoria.objects.filter(nr_ano=recomendacao.nr_ano, cd_assunto=recomendacao.cd_assunto).aggregate(Max('nr_recomendacao'))
          if nr_recomendacao['nr_recomendacao__max'] == None:
              recomendacao.nr_recomendacao = 1
          else:
              recomendacao.nr_recomendacao = nr_recomendacao.itervalues().next() + 1
          recomendacao.save()      
          mensagem = 'Atualização feita com sucesso.'
          return render_to_response("sucesso.html", RequestContext(request, {
            'retorno': retorno,
            'mensagem': mensagem,
          }))               
         
    else:
       form = RecomendacaoAuditoriaForm()
    return render_to_response('adiciona.html', RequestContext(request, {
        'form': form,
        'layout': layout,
        'titulo': titulo,
        'acao' : acao,
    }))

@login_required    
def atualiza_recomendacao_auditoria(request, id):
    layout = 'horizontal'
    titulo = u'Recomendações'
    acao   = 'Salvar'
    retorno = '/listaRecomendacaoAuditoria'
    recomendacao = get_object_or_404(recomendacao_auditoria, pk=id)
    if request.method == "POST":
       if request.POST.get('cancel', None):
           return HttpResponseRedirect(retorno)
       if request.POST.get('delete', None):
           if despacho_auditoria.objects.filter(cd_recomendacao=recomendacao.cd_recomendacao).aggregate(Count('cd_recomendacao')).itervalues().next() == 0 :
#              recomendacao.delete()
              mensagem = 'Exclusão feita com sucesso.'
              return render_to_response("sucesso.html", RequestContext(request, {
                 'retorno': retorno,
                 'mensagem': mensagem,
                 }))  

           else:
              mensagem = 'Exclusão não permitida. Existem recomendações para este assunto.'
              return render_to_response("erro.html", RequestContext(request, {
                 'retorno': retorno,
                 'mensagem': mensagem,
                 }))  
     
       else:
           form = RecomendacaoAuditoriaAtualizacaoForm(request.POST, request.FILES,instance=recomendacao)
           if not form.has_changed():
               return HttpResponseRedirect(retorno)		   
           if form.is_valid():
               form.save()
               mensagem = 'Atualização feita com sucesso.'
               return render_to_response("sucesso.html", RequestContext(request, {
                  'retorno': retorno,
                  'mensagem': mensagem,
                  }))               
    else:
       form = RecomendacaoAuditoriaAtualizacaoForm(instance=recomendacao)	       
    return render_to_response('adiciona.html', RequestContext(request, {
        'form': form,
        'layout': layout,
        'titulo': titulo,
        'acao' : acao,
    }))  

@login_required       
def lista_despacho_auditoria(request):
    lista_itens = despacho_auditoria.objects.all()
    return render_to_response("listaDespachoAuditoria.html", {'lista_itens': lista_itens}, context_instance=RequestContext(request)) 	

#@login_required       
def lista_despacho_auditoriaID(request, cd_recomendacao):
    lista_itens = despacho_auditoria.objects.filter(cd_recomendacao=cd_recomendacao)
#    lista_itens = despacho_auditoria.objects.all()
    return render_to_response("listaDespachoAuditoria.html", {'lista_itens': lista_itens}, context_instance=RequestContext(request))     

@login_required
def adiciona_despacho_auditoria(request):
    layout = 'horizontal'
    titulo = u'Despachos'
    acao   = 'Adicionar'
    retorno = '/listaDespachoAuditoria'
    if request.method == "POST":
       if request.POST.get('cancel', None):
           return HttpResponseRedirect(retorno)
       form = DespachoAuditoriaForm(request.POST, request.FILES)
       if form.is_valid():	 
          despacho = form.save(commit=False)
          despacho.cd_usuario_atualizacao = request.user
          despacho.dt_despacho = datetime.datetime.now()
          despacho.save()      
          mensagem = 'Despacho incluido com sucesso.'
          return render_to_response("sucesso.html", RequestContext(request, {
           'retorno': '/listaDespachoAuditoria',
           'mensagem': mensagem,
          }))                         
    else:
       form = DespachoAuditoriaForm()
    return render_to_response('adiciona.html', RequestContext(request, {
        'form': form,
        'layout': layout,
        'titulo': titulo,
        'acao' : acao,
    }))


    
@login_required
def atualiza_despacho_auditoria(request, id):
    layout = 'horizontal'
    titulo = u'Despachos'
    acao   = 'Salvar'
    retorno = '/listaDespachoAuditoria'
    despacho = get_object_or_404(despacho_auditoria, pk=id)
    if request.method == "POST":
       if request.POST.get('cancel', None):
           return HttpResponseRedirect(retorno)
       if request.POST.get('delete', None):
#           despacho.delete()
           mensagem = 'Exclusão feita com sucesso.'
           return render_to_response("sucesso.html", RequestContext(request, {
                'retorno': retorno,
                'mensagem': mensagem,
                 }))  
                    
       else:
           form = DespachoAuditoriaAtualizacaoForm(request.POST, request.FILES,instance=despacho)
           if not form.has_changed():
               return HttpResponseRedirect(retorno)		   
           if form.is_valid():
               form.save()
               mensagem = 'Atualização feita com sucesso.'
               return render_to_response("sucesso.html", RequestContext(request, {
                'retorno': retorno,
                'mensagem': mensagem,
               }))                         
               
    else:
       form = DespachoAuditoriaAtualizacaoForm(instance=despacho)	
    return render_to_response('adiciona.html', RequestContext(request, {
        'form': form,
        'layout': layout,
        'titulo': titulo,
        'acao' : acao,
    }))