source: publico/il.spdo/trunk/il/spdo/api.py @ 5574

Última Alteração nesse arquivo desde 5574 foi 5574, incluída por fabianosantos, 8 anos atrás

Nesse commit reside 90% da inteligencia desse sistema. Adicionado algoritmos de tramitacao inicial, de envio, de recebimento e recuperacao de protocolos enviados e nao recebidos. Adicionadas tabelas que representam o inbox e outbox das áreas. Adiciona coluna na tabela de tramitacao para armazenar a área anterior de um tramite, util para implementar a recuperacao e atualizacao de inbox e outbox no momento do recebimento. Todos os metodos recebem listas de identificadores de protocolos, para permitir a tramitacao em lote, desobrigando o usuario a tramitar protocolo por protocolo, dando agilidade ao sistema.

File size: 8.7 KB
Linha 
1# -*- coding: utf-8 -*-
2
3import os
4import datetime
5
6from five import grok
7from zope.interface import Interface
8from zope.component import getMultiAdapter
9from zope.globalrequest import getRequest
10from zope.app.component.hooks import getSite
11
12from il.spdo.config import MessageFactory as _
13from il.spdo import db
14from il.spdo.config import Session, PATH_ANEXOS
15
16class ISPDOAPI(Interface):
17    """Marker interface.
18    """
19
20class SPDOAPI(grok.GlobalUtility):
21    """API SPDO.
22    """
23    grok.provides(ISPDOAPI)
24
25    def getAuthId(self):
26        """Retorna o identificador do usuário autenticado (username).
27        """
28        context = getSite()
29        request = getRequest()
30        portal_state = getMultiAdapter((context, request), name=u'plone_portal_state')
31        return portal_state.member().getId()
32
33    def getAuthPessoa(self):
34        """Retorna o objeto Pessoa que representa o usuário autenticado.
35        """
36        session = Session()
37        return session.query(db.Pessoa).filter_by(email=self.getAuthId()).first()
38
39    def getProtocoloId(self):
40        """Retorna o valor do parâmetro protocolo_id.
41        """
42        r = getRequest()
43
44        # XIRU: as próximas 12 linhas são apenas para debug
45        ret = r.get('protocolo_id', None)
46        if ret is not None:
47            print 'utilizando protocolo_id do request'
48            return ret
49        ret = r.get('form.widgets.protocolo_id', None)
50        if ret is not None:
51            print 'utilizando form.widgets.protocolo_id do request'
52            return ret
53        ret = r.cookies.get('protocolo_id', None)
54        if ret is not None:
55            print 'utilizando protocolo_id do cookies'
56            return ret
57
58        return r.get('protocolo_id', r.get('form.widgets.protocolo_id', r.cookies.get('protocolo_id', None)))
59
60    def getProtocolo(self, id=None):
61        """Retorna o objeto Protocolo a partir do ID.
62        """
63        session = Session()
64        if id is None:
65            id = self.getProtocoloId()
66        return session.query(db.Protocolo).get(id)
67
68    def addProtocolo(self, tipoprotocolo, tipodocumento_id, numero_documento, data_emissao, assunto, situacao_id, origem, destino, **kwargs):
69        """Adiciona protocolo.
70        """
71        session = Session()
72        protocolo = db.Protocolo(
73                    tipoprotocolo=tipoprotocolo,
74                    tipodocumento_id=tipodocumento_id,
75                    numero_documento=numero_documento,
76                    data_emissao=data_emissao,
77                    assunto=assunto,
78                    situacao_id=situacao_id,
79                    usuario=self.getAuthId(),
80                    )
81        session.add(protocolo)
82        session.flush()
83        protocolo_id = protocolo.id
84        for pessoa_id in origem:
85            pessoa_origem = db.PessoaOrigem(
86                            protocolo_id=protocolo_id,
87                            pessoa_id=pessoa_id,
88                            )
89            session.add(pessoa_origem)
90        for pessoa_id in destino:
91            pessoa_destino = db.PessoaDestino(
92                             protocolo_id=protocolo_id,
93                             pessoa_id=pessoa_id,
94                             )
95            session.add(pessoa_destino)
96        session.flush()
97        return protocolo_id
98       
99    def addObservacao(self, protocolo_id, texto):
100        """Adiciona observação.
101        """
102        if not texto:
103            return
104        session = Session()
105        observacao = db.Observacao(
106                     protocolo_id=protocolo_id,
107                     texto=texto,
108                     usuario=self.getAuthId(),
109                     )
110        session.add(observacao)
111        session.flush()
112        return observacao.id
113
114    def addAnexos(self, protocolo_id, anexos):
115        """Adiciona anexos.
116        """
117        p = self.getProtocolo(protocolo_id)
118        if p is None or anexos is None:
119            return tuple()
120        session = Session()
121        path_protocolo = os.path.join(PATH_ANEXOS, str(p.ano), str(p.id))
122        if not os.path.exists(path_protocolo):
123            os.makedirs(path_protocolo, 0700)
124        result_ids = []
125        for arquivo in anexos:
126            anexo = db.Anexo(
127                    protocolo_id=protocolo_id,
128                    arquivo=arquivo.filename,
129                    tamanho=arquivo.getSize(),
130                    usuario=self.getAuthId(),
131                    )
132            session.add(anexo)
133            session.flush()
134            result_ids.append(anexo.id)
135            path_anexo = os.path.join(path_protocolo, str(anexo.id))
136            with open(path_anexo, 'w') as file_anexo:
137                file_anexo.write(arquivo.data)
138        return tuple(result_ids)
139
140    def _add_box(self, box, protocolo_id, area_id):
141        assert(box in (db.TramiteInbox, db.TramiteOutbox))
142        session = Session()
143        t = session.query(box).get((protocolo_id, area_id))
144        if t is None:
145            t = box()
146            t.protocolo_id=protocolo_id
147            t.area_id=area_id
148            tbl = box is db.TramiteInbox and 'tramite_inbox' or 'tramite_outbox'
149            t.version = db.nextVersion(tbl, protocolo_id=protocolo_id, area_id=area_id)
150            session.add(t)
151   
152    def _del_box(self, box, protocolo_id, area_id):
153        assert(box in (db.TramiteInbox, db.TramiteOutbox))
154        session = Session()
155        t = session.query(box).get((protocolo_id, area_id))
156        if t is not None:
157            session.delete(t)
158
159    def TramiteInicial(self, protocolo_id):
160        """Tramite inicial.
161        """
162        session = Session()
163        area_id_auth = self.getAuthPessoa().area_id
164        tramite = db.Tramite(
165                  protocolo_id=protocolo_id,
166                  area_id=area_id_auth,
167                  data_disponibilizacao=None,
168                  data_recebimento=datetime.datetime.now(),
169                  acao=_(u'Protocolo Criado'),
170                  usuario=self.getAuthId(),
171                  )
172        session.add(tramite)
173        self._add_box(db.TramiteInbox, protocolo_id, area_id_auth)
174        session.flush()
175
176    def TramiteEnvio(self, protocolos, areas, acao):
177        """Tramite de envio.
178        """
179        protocolos = list(set(protocolos))
180        areas = list(set(areas))
181        session = Session()
182        area_id_auth = self.getAuthPessoa().area_id
183        # evita o envio para a própria área
184        if areas.count(area_id_auth):
185            areas.pop(areas.index(area_id_auth))
186        copia = len(areas) > 1
187        for protocolo_id in protocolos:
188            for area_id in areas:
189                tramite = db.Tramite(
190                          protocolo_id=protocolo_id,
191                          area_id=area_id,
192                          data_disponibilizacao=datetime.datetime.now(),
193                          data_recebimento=None,
194                          acao=acao,
195                          usuario=self.getAuthId(),
196                          copia=copia,
197                          area_id_anterior=area_id_auth,
198                          )
199                session.add(tramite)
200                self._add_box(db.TramiteOutbox, protocolo_id, area_id_auth)
201                self._del_box(db.TramiteInbox, protocolo_id, area_id_auth)
202                session.flush()
203
204    def TramiteRecebimento(self, protocolos):
205        """Tramite de recebimento.
206        """
207        protocolos = list(set(protocolos))
208        session = Session()
209        area_id_auth = self.getAuthPessoa().area_id
210        for protocolo_id in protocolos:
211            protocolo = self.getProtocolo(protocolo_id)
212            tramite = session.query(db.Tramite).\
213                      filter_by(protocolo_id=protocolo_id).\
214                      filter_by(area_id=area_id_auth).\
215                      filter_by(data_recebimento=None).first()
216            tramite.data_recebimento=datetime.datetime.now()
217            self._add_box(db.TramiteInbox, protocolo_id, area_id_auth)
218            self._del_box(db.TramiteOutbox, protocolo_id, tramite.area_id_anterior)
219           
220    def TramiteRecuperacao(self, protocolos):
221        """Tramite de recuperação (recupera um protocolo enviado que não foi recebido).
222        """
223        protocolos = list(set(protocolos))
224        session = Session()
225        area_id_auth = self.getAuthPessoa().area_id
226        for protocolo_id in protocolos:
227            protocolo = self.getProtocolo(protocolo_id)
228            tramite = session.query(db.Tramite).\
229                      filter_by(protocolo_id=protocolo_id).\
230                      filter_by(area_id_anterior=area_id_auth).\
231                      filter_by(data_recebimento=None).first()
232            session.delete(tramite)
233            self._add_box(db.TramiteInbox, protocolo_id, area_id_auth)
234            self._del_box(db.TramiteOutbox, protocolo_id, area_id_auth)
Note: Veja TracBrowser para ajuda no uso do navegador do trac.
 

The contents and data of this website are published under license:
Creative Commons 4.0 Brasil - Atribuir Fonte - Compartilhar Igual.