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

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

Implementacao inicial da api de tramite de recebimento.

File size: 7.1 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 TramiteInicial(self, protocolo_id):
141        """Tramite inicial.
142        """
143        session = Session()
144        tramite = db.Tramite(
145                  protocolo_id=protocolo_id,
146                  area_id=self.getAuthPessoa().area_id,
147                  data_disponibilizacao=None,
148                  data_recebimento=datetime.datetime.now(),
149                  acao=_(u'Protocolo Criado'),
150                  usuario=self.getAuthId(),
151                  )
152        session.add(tramite)
153        session.flush()
154        tramite_inbox = db.TramiteInbox(
155                        tramite_id=tramite.id,
156                        area_id=tramite.area_id,
157                        )
158        session.add(tramite_inbox)
159        session.flush()
160        return tramite.id
161       
162    def TramiteEnvio(self, protocolo_id, areas, acao):
163        """Tramite de envio.
164        """
165        session = Session()
166        area_id_auth = self.getAuthPessoa().area_id
167        copia = len(areas) > 1
168        result_ids = []
169        for area_id in areas:
170            # evita o envio para a própria área
171            if area_id == area_id_auth:
172                continue
173            tramite = db.Tramite(protocolo_id=protocolo_id,
174                                 area_id=area_id,
175                                 data_disponibilizacao=datetime.datetime.now(),
176                                 data_recebimento=None,
177                                 acao=acao,
178                                 copia=copia,
179                                 usuario=self.getAuthId(),
180                                 )
181            session.add(tramite)
182            session.flush()
183            tramite_outbox = db.TramiteOutbox(
184                             tramite_id=tramite.id,
185                             area_id=area_id_auth,
186                             )
187            session.add(tramite_inbox)
188            session.flush()
189            result_ids.append(tramite.id)
190        return tuple(result_ids)
191
192    def TramiteRecebimento(self, protocolos):
193        """Tramite de recebimento.
194        """
195        session = Session()
196        area_id_auth = self.getAuthPessoa().area_id
197        for protocolo_id in protocolos:
198            protocolo = self.getProtocolo(protocolo_id)
199            tramite = session.query(db.Tramite).\
200                      filter_by(protocolo_id=protocolo_id).\
201                      filter_by(area_id=area_id_actual).\
202                      filter(db.Tramite.data_recebimento is None).first()
203            tramite.data_recebimento=datetime.datetime.now()
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.