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

forms.py

# -*- coding: utf8 -*-
from django import forms
from django.contrib.auth.models import User
from bootstrap_toolkit.widgets import BootstrapDateInput
from django.conf import settings
from models import tipo_assunto, recomendacao_auditoria, despacho_auditoria

#from django.forms.widgets import DateTimeInput

import time, datetime 
from datetime import date

#DATE_FORMAT = '%d/%m/%Y'

#class FormattedDateInput(forms.DateTimeInput):
#    format = DATE_FORMAT
#MY_DATE_FORMATS = ['%d/%m/%Y',]

 
class TipoAssuntoForm(forms.ModelForm):

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

class TipoAssuntoAtualizacaoForm(forms.ModelForm):

    def __init__(self, *args, **kwargs):
        super(TipoAssuntoAtualizacaoForm, self).__init__(*args, **kwargs)
        # change a widget attribute:
        self.fields['cd_assunto'].widget.attrs["class"] = "span1"        
        self.fields['ds_assunto'].widget.attrs["class"] = "span8"
        
#    cd_assunto = forms.IntegerField(widget=forms.TextInput(attrs={'disabled': 'disabled'}))
    cd_assunto = forms.IntegerField(label='Código', widget=forms.TextInput(attrs={'readonly': 'readonly'}))    
#    ds_assunto = forms.CharField(widget=forms.TextInput(attrs={'class':span4}))
    class Meta:
        model = tipo_assunto
        
class RecomendacaoAuditoriaForm(forms.ModelForm):

    class Meta:
        model = recomendacao_auditoria        
        exclude = ('nr_recomendacao',)

    def clean(self):
        data = self.cleaned_data
        if data.get('nr_ano') < 2011:
		    raise forms.ValidationError("Ano Inválido!")
        if data.get('dt_prazo') <datetime.date.today():
		    raise forms.ValidationError("Prazo tem que ser maior que hoje!")
        return data
        
#    def clean_nr_ano(self):
#        ano = self.cleaned_data['nr_ano']
#        if ano < 2011:
#		    raise forms.ValidationError("Ano Inválido!")
#        return ano
            
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['cd_assunto'].widget.attrs['readonly'] = True

    def clean_cd_assunto(self):
        return self.instance.cd_assunto
 	
    nr_recomendacao = forms.IntegerField(label='Número', widget=forms.TextInput(attrs={'readonly': 'readonly'}))    	
    nr_ano = forms.IntegerField(label='Ano', widget=forms.TextInput(attrs={'readonly': 'readonly'}))    
    
#    dt_prazo = forms.DateField(label="Prazo", input_formats=[DATE_FORMAT], widget=FormattedDateInput())
#    dt_prazo = forms.DateField(label="Prazo", input_formats=MY_DATE_FORMATS)
#    dt_prazo = forms.DateField(label='Prazo', widget=BootstrapDateInput)
    class Meta:
        model = recomendacao_auditoria
    def clean_nr_ano(self):
        ano = self.cleaned_data['nr_ano']
        if ano < 2011:
		    raise forms.ValidationError("Ano Inválido!")
        return ano
        
#    def __init__(self, *args, **kwargs):
#        super(RecomendacaoAuditoriaAtualizacaoForm(, self).__init__(*args, **kwargs)
#        self.fields['dt_prazo'].widget = widgets.AdminDateWidget()
         
class DespachoAuditoriaForm(forms.ModelForm):

    class Meta:
          model = despacho_auditoria    
          exclude = ('dt_despacho',) 
          

class DespachoAuditoriaAtualizacaoForm(forms.ModelForm):

    class Meta:
          model = despacho_auditoria    
#          exclude = ('dt_despacho',)    
    def __init__(self, *args, **kwargs):
        super(DespachoAuditoriaAtualizacaoForm, self).__init__(*args, **kwargs)
        instance = getattr(self, 'instance', None)
        if instance and instance.id:
            self.fields['cd_recomendacao'].widget.attrs['readonly'] = True
            self.fields['dt_despacho'].widget.attrs['readonly'] = True            

#    def clean_cd_recomendacao(self):
#        return self.instance.cd_recomendacao
    def clean_dt_prazo(self):
        dt_prazo    = self.cleaned_data['dt_prazo']
        if dt_prazo < self.cleaned_data['dt_despacho']:
		    raise forms.ValidationError(u"Data prevista para término tem que ser maior ou igual que a data do despacho!")
        pk_recomendacao = self.cleaned_data['cd_recomendacao']
#        nr_recomendacao = int(cd_recomendacao)
#        dt_recomendacao = recomendacao_auditoria.objects.get(pk=pk_recomendacao).dt_recomendacao
#        if dt_prazo > dt_recomendacao:
#           raise forms.ValidationError(u"Data prevista para término tem que ser menor que a data da recomendação!")
        raise forms.ValidationError(pk_recomendacao)
        return dt_prazo           
#    def clean_dt_prazao(self):
#        data = self.cleaned_data
#        if data.get('dt_despacho') > data.get('dt_prazo'):
#		    raise forms.ValidationError(u"Data prevista para término tem que ser maior ou igual que a data do despacho!")
#        return data
          

models.py

# -*- coding: utf-8 -*-
from django.db import models
from django.contrib.auth.models import User
from django.utils.translation import ugettext as _
import datetime

class tipo_assunto (models.Model):
    class Meta:
        verbose_name = 'Assunto'
        verbose_name_plural = 'Assuntos'
        db_table = 'tipo_assunto'
        ordering = ('cd_assunto', )

    cd_assunto = models.IntegerField(('Código'), primary_key=True)
    ds_assunto = models.CharField(('Descrição'), max_length=100)
    
    def __unicode__(self):
#        return self.ds_assunto       
         return u'%s' % (self.cd_assunto)

class unidade_organizacional (models.Model):
    class Meta:
        verbose_name = 'Unidade Organizacional'
        verbose_name_plural = 'Uniddes Organizacionais'
        db_table = 'unidade_organizacional'
    cd_local = models.IntegerField(('Código'), primary_key=True)
    ds_local = models.CharField(('Descrição'), max_length=40)
    
    def __unicode__(self):
        return self.ds_local
     
        
SITUACAO = (('1',('Em execução/estudo')),
           ('3', ('Concluída')))

RELEVANCIA = (('3', ('Alto')),
             ('2', ('Médio')),
             ('1', ('Baixo')))
             
   
class recomendacao_auditoria(models.Model):
    class Meta:
        verbose_name = 'Recomendação'
        verbose_name_plural = 'Recomendações'
        db_table = 'recomendacao_auditoria'

    def __unicode__(self):
         return u'%s/%s' % (self.nr_ano, self.nr_recomendacao)
#        return self.ds_titulo
        
    cd_assunto = models.ForeignKey(tipo_assunto,
                                   verbose_name = 'Assunto',
    )
    nr_ano = models.IntegerField('Ano')    
    nr_recomendacao= models.IntegerField('Número')
        
    st_situacao = models.CharField(('Situação'), max_length=1,
        choices=SITUACAO, 
        db_index=True)        
    dt_recomendacao = models.DateField('Data', auto_now_add=True)
    ds_titulo = models.TextField(('Titulo'), null=True, blank=False)
    ds_recomendacao = models.TextField(('Descrição'), null=True, blank=True)	
    cd_local_responsavel = models.ForeignKey(unidade_organizacional,
                                               verbose_name = u'Diretoria/Gerência',
    )
    ds_outro_responsavel = models.CharField(('Outras localidades'), max_length=40, null=True, blank=True)
    ds_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) 
    cd_usuario_atualizacao = models.ForeignKey(User, editable=False) 
    dh_atualizacao = models.DateTimeField(('Atualizado em'), auto_now_add=True)
    
	
class despacho_auditoria(models.Model):
    class Meta:
        verbose_name = 'Despacho'
        verbose_name_plural = 'Despachos'	
        db_table = 'despacho_auditoria'
    def __unicode__(self):
        return self.ds_titulo       
        
    cd_recomendacao = models.ForeignKey(recomendacao_auditoria,
                                               verbose_name = 'Recomendação',
    )
    ds_titulo = models.CharField(('Título'), max_length=50, null=True, blank=True)
    ds_despacho = models.TextField(('Descrição'), null=True, blank=True)
    dt_despacho = models.DateField('Data do Despacho' )
    dt_prazo = models.DateField('Data prevista para término')
    cd_usuario_atualizacao = models.ForeignKey(User, editable=False) 
    dh_atualizacao = models.DateTimeField(('Atualizado em'), auto_now_add=True)
 

views.py

# -*- encoding: utf-8 -*-
from django.shortcuts import render_to_response, get_object_or_404
from django.template.context import RequestContext
from django.http import HttpResponseRedirect
from audit.raai.forms import TipoAssuntoForm, TipoAssuntoAtualizacaoForm, RecomendacaoAuditoriaForm
from audit.raai.forms import RecomendacaoAuditoriaAtualizacaoForm, DespachoAuditoriaForm, DespachoAuditoriaAtualizacaoForm

from django.contrib.auth.decorators import login_required
from django.db.models import Max, Count

from models import tipo_assunto, recomendacao_auditoria, despacho_auditoria
import datetime

@login_required
def lista_assunto(request):
    lista_itens = tipo_assunto.objects.all()
    return render_to_response("listaAssunto.html", {'lista_itens': lista_itens}, context_instance=RequestContext(request)) 	
    
@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,
    }))