# -*- coding: utf-8 -*- from datetime import datetime from django.db import models from django.utils.translation import ugettext as _ from eav.models import BaseChoice, BaseEntity, BaseSchema, BaseAttribute from sigi.apps.utils import SearchField from sigi.apps.utils.email import enviar_email class Diagnostico(BaseEntity): """ Modelo para representar unm diagnostico realizado em uma Casa Legislativa """ casa_legislativa = models.ForeignKey( 'casas.CasaLegislativa', verbose_name=_(u'Casa Legislativa')) # campo de busca em caixa baixa e sem acento search_text = SearchField(field_names=['casa_legislativa']) # casa_legislativa.casa_uf_filter = True # casa_legislativa.casa_tipo_filter = True data_visita_inicio = models.DateField( u'data inicial da visita', null=True, blank=True, ) data_visita_fim = models.DateField( u'data final da visita', null=True, blank=True, ) publicado = models.BooleanField(default=False) data_publicacao = models.DateField( u'data de publicação do diagnóstico', null=True, blank=True, ) responsavel = models.ForeignKey('servidores.Servidor', verbose_name=_(u'responsável')) class Meta: verbose_name, verbose_name_plural = _(u'diagnóstico'), _(u'diagnósticos') @property def membros(self): """ Retorna a lista de membros do diagnostico, isto é responsavel + equipe """ membros = set([self.responsavel]) for equipe in self.equipe_set.all(): membros.add(equipe.membro) return list(membros) @property def contatos_respondidos(self): """Retorna uma lista de contatos que foram respondidos """ return list(self.casa_legislativa.funcionario_set.all()) @property def categorias_respondidas(self): """ Retorna uma listas das categorias dinamicas que tem ao menos uma resposta """ # unifica as categorias das perguntas dessas respostas categoria_com_respostas = set([r.schema.categoria for r in self._get_respostas()]) return list(categoria_com_respostas) def _get_respostas(self): # obtem todas as respostas dinamicas desse diagnostico respostas = Resposta.objects.filter(entity_id=self.id).all() # remove as respostas nulas ou em branco return [r for r in respostas if r._get_value()] def email_diagnostico_publicado(self, from_email, host): """Enviando email quando o diagnóstico for publicado. Os argumentos acima são: * from_email - Email de remetente * host - O Host do sistema, para ser usado na construção do endereço do diagnóstico """ enviar_email(from_email, _(u"Diagnóstico publicado"), 'diagnosticos/email_diagnostico_publicado.txt', { 'responsavel': self.responsavel.nome_completo, 'casa_legislativa': self.casa_legislativa, 'data_diagnostico': self.data_visita_inicio, 'host': host, 'url_diagnostico': self.get_absolute_url(), 'status': _(u"Publicado"), }) def email_diagnostico_alterado(self, from_email, host): """Enviando email quando o status do diagnóstico for alterado. Os argumentos acima são: * from_email - Email do destinatário * host - O Host do sistema, para ser usado na construção do endereço do diagnóstico """ enviar_email(from_email, _(u"Diagnóstico alterado"), 'diagnosticos/email_diagnostico_alterado.txt', { 'servidor': self.responsavel.nome_completo, 'casa_legislativa': self.casa_legislativa, 'data_diagnostico': self.data_visita_inicio, 'host': host, 'url_diagnostico': self.get_absolute_url(), 'status': _(u"Alterado"), }) def get_schemata(self, category=None, *args, **kwargs): """ Se existir uma categoria retorna apenas as questões dessa. """ schemas = super(Diagnostico, self).get_schemata(*args, **kwargs) if category: schemas = [s for s in schemas if s.categoria_id == category] schemas = sorted(schemas, lambda x, y: cmp(x.title, y.title)) return schemas @classmethod def get_schemata_for_model(self): return Pergunta.objects.all() def __unicode__(self): return str(self.casa_legislativa).decode('utf8') def get_absolute_url(self): return "/diagnosticos/diagnostico/%i.pdf" % (self.id, ) class Categoria(models.Model): """ Modelo para representar a categoria de uma pergunta e sua ordem na hora de exibir no formulário """ nome = models.CharField(max_length=255) class Meta: ordering = ('nome',) def __unicode__(self): return self.nome class Pergunta(BaseSchema): """ Modelo que representa uma pergunta no questionário e sua ordem dentro da categoria Uma pergunta tem o nome e o tipo da resposta """ categoria = models.ForeignKey(Categoria, related_name='perguntas') def group_choices(self): from django.db import connection, transaction cursor = connection.cursor() cursor.execute(""" SELECT choice_id, sum(1) FROM diagnosticos_resposta WHERE schema_id=%s and choice_id is not null GROUP BY choice_id; """, [self.id]) return [ (Escolha.objects.get(id=int(row[0])), row[1]) for row in cursor.fetchall() ] def total_anwsers(self): from django.db import connection, transaction cursor = connection.cursor() cursor.execute(""" SELECT sum(1) FROM diagnosticos_resposta WHERE schema_id=%s """, [self.id]) return cursor.fetchone() class Meta: ordering = ('title',) verbose_name, verbose_name_plural = _(u'pergunta'), _(u'perguntas') class Escolha(BaseChoice): """ Perguntas de multiplas escolhas tem as opções cadastradas neste modelo """ schema = models.ForeignKey(Pergunta, related_name='choices', verbose_name=_(u'pergunta')) schema_to_open = models.ForeignKey(Pergunta, related_name='abre_por', verbose_name=_(u'pergunta para abrir'), blank=True, null=True) ordem = models.PositiveIntegerField(blank=True, null=True) class Meta: ordering = ('schema', 'ordem') verbose_name, verbose_name_plural = _(u'escolha'), _(u'escolhas') class Resposta(BaseAttribute): """ Modelo para guardar as respostas das perguntas de um diagnosico """ schema = models.ForeignKey(Pergunta, related_name='attrs', verbose_name=_(u'pergunta')) choice = models.ForeignKey(Escolha, verbose_name=_(u'escolha'), blank=True, null=True) class Meta: verbose_name, verbose_name_plural = _(u'resposta'), _(u'respostas') class Equipe(models.Model): """ Modelo que representa a equipe de um diagnóstico """ diagnostico = models.ForeignKey(Diagnostico) membro = models.ForeignKey('servidores.Servidor') class Meta: verbose_name, verbose_name_plural = _(u'equipe'), _(u'equipe') def __unicode__(self): return self.membro.__unicode__() class Anexo(models.Model): """ Modelo para representar os documentos levantados no processo de diagnóstico. Podem ser fotos, contratos, etc. """ diagnostico = models.ForeignKey(Diagnostico, verbose_name=u'diagnóstico') arquivo = models.FileField(upload_to='apps/diagnostico/anexo/arquivo', max_length=500) descricao = models.CharField(_(u'descrição'), max_length='70') data_pub = models.DateTimeField(_(u'data da publicação do anexo'), default=datetime.now) class Meta: ordering = ('-data_pub',) def __unicode__(self): return unicode(self.arquivo.name)