source: publico/il.spdo/trunk/il/spdo/browser/views.py @ 7806

Última Alteração nesse arquivo desde 7806 foi 7806, incluída por gustavolepri, 5 anos atrás

ws para as areas adicionado

File size: 32.7 KB
Linha 
1# -*- coding: utf-8 -*-
2
3import os
4import json
5import datetime
6
7from five import grok
8from zope.component import getUtility
9from zope.schema.interfaces import IVocabularyFactory
10from zope.interface import implements
11from plone.app.layout.navigation.interfaces import INavigationRoot
12from plone.namedfile.utils import set_headers, stream_data
13from plone.namedfile.file import NamedFile
14from Products.statusmessages.interfaces import IStatusMessage
15from Products.Five import BrowserView
16
17from il.spdo.config import Session, PATH_ANEXOS
18from il.spdo.saconfig import ScopeID
19from il.spdo import db
20from il.spdo.config import MessageFactory as _
21from il.spdo.log import log
22from il.spdo.nav import go, url
23from il.spdo.interfaces import ISPDOAPI, ISecurityChecker
24
25class BaseListView(object):
26   
27    def show_url(self, id, vs=None):
28        vs = self.view_sufix if vs is None else vs
29        return url('show-'+vs, id=id)
30
31    def add_url(self, vs=None):
32        vs = self.view_sufix if vs is None else vs
33        return url('add-'+vs)
34
35class AreaListView(grok.View, BaseListView):
36
37    grok.name('list-area')
38    grok.context(INavigationRoot)
39    grok.require('cmf.ManagePortal')
40
41    dados = []
42    view_sufix = 'area'
43
44    @log
45    def update(self):
46        self.request.set('disable_border', True)
47        self.dados = []
48        session = Session()
49        items = session.query(db.Area).all()
50        for i in items:
51            self.dados.append({
52               'id': i.id,
53               'sigla': i.sigla,
54               'nome': i.nome,
55               'chefia_id': i.chefia_id,
56               'chefia_sigla': getattr(i.area,'sigla',''),
57               'chefia_nome': getattr(i.area,'nome',''),
58               })
59
60class UFListView(grok.View, BaseListView):
61
62    grok.name('list-uf')
63    grok.context(INavigationRoot)
64    grok.require('cmf.ManagePortal')
65
66    dados = []
67    view_sufix = 'uf'
68
69    @log
70    def update(self):
71        self.request.set('disable_border', True)
72        self.dados = []
73        session = Session()
74        items = session.query(db.UF).all()
75        for i in items:
76            self.dados.append({
77               'id': i.id,
78               'sigla': i.sigla,
79               'nome': i.nome,
80               })
81
82class PessoaListView(grok.View, BaseListView):
83   
84    grok.name('list-pessoa')
85    grok.context(INavigationRoot)
86    grok.require('zope2.View')
87
88    dados = []
89    view_sufix = 'pessoa'
90
91    @log
92    def update(self):
93        sc = getUtility(ISecurityChecker)
94        sc.enforce('acessar_list_pessoa')
95        self.request.set('disable_border', True)
96        self.dados = []
97        session = Session()
98        items = session.query(db.Pessoa).all()
99        for i in items:
100            self.dados.append({
101               'id': i.id,
102               'nome': i.nome,
103               'email': i.email,
104               })
105
106class ResponsavelListView(grok.View, BaseListView):
107
108    grok.name('list-responsavel')
109    grok.context(INavigationRoot)
110    grok.require('cmf.ManagePortal')
111
112    dados = []
113    view_sufix = 'responsavel'
114
115    @log
116    def update(self):
117        self.request.set('disable_border', True)
118        self.dados = []
119        session = Session()
120        items = session.query(db.Responsavel).all()
121        for i in items:
122            self.dados.append({
123                'id': i.id,
124                'area_id': i.area_id,
125                'area_sigla': i.area.sigla,
126                'area_nome': i.area.nome,
127                'pessoa_id': i.pessoa_id,
128                'pessoa_nome': i.pessoa.nome,
129                'pessoa_email': i.pessoa.email,
130                'data_responsavel': i.data_responsavel,
131                'url-area': url('show-area', id=i.area_id),
132                'url-pessoa': url('show-pessoa', id=i.pessoa_id),
133               })
134
135class TipoDocumentoListView(grok.View, BaseListView):
136
137    grok.name('list-tipodocumento')
138    grok.context(INavigationRoot)
139    grok.require('cmf.ManagePortal')
140
141    dados = []
142    view_sufix = 'tipodocumento'
143
144    @log
145    def update(self):
146        self.request.set('disable_border', True)
147        self.dados = []
148        session = Session()
149        items = session.query(db.TipoDocumento).all()
150        for i in items:
151            self.dados.append({
152               'id': i.id,
153               'nome': i.nome,
154               })
155
156class SituacaoListView(grok.View, BaseListView):
157
158    grok.name('list-situacao')
159    grok.context(INavigationRoot)
160    grok.require('cmf.ManagePortal')
161
162    dados = []
163    view_sufix = 'situacao'
164
165    @log
166    def update(self):
167        self.request.set('disable_border', True)
168        self.dados = []
169        session = Session()
170        items = session.query(db.Situacao).all()
171        for i in items:
172            self.dados.append({
173               'id': i.id,
174               'nome': i.nome,
175               'inicial': i.inicial,
176               'final': i.final,
177               })
178
179class TipoEntregaListView(grok.View, BaseListView):
180
181    grok.name('list-tipoentrega')
182    grok.context(INavigationRoot)
183    grok.require('cmf.ManagePortal')
184
185    dados = []
186    view_sufix = 'tipoentrega'
187
188    @log
189    def update(self):
190        self.request.set('disable_border', True)
191        self.dados = []
192        session = Session()
193        items = session.query(db.TipoEntrega).all()
194        for i in items:
195            self.dados.append({
196               'id': i.id,
197               'nome': i.nome,
198               })
199
200class FluxoListView(grok.View, BaseListView):
201
202    grok.name('list-fluxo')
203    grok.context(INavigationRoot)
204    grok.require('cmf.ManagePortal')
205
206    dados = []
207    view_sufix = 'fluxo'
208
209    def _tipo_protocolo(self, tipoprotocolo):
210        tpvf = getUtility(IVocabularyFactory, 'il.spdo.tipoprotocolo-vocab')
211        tpv = tpvf(self.context)
212        return tpv.getTerm(tipoprotocolo).title
213
214    @log
215    def update(self):
216        self.request.set('disable_border', True)
217        self.dados = []
218        session = Session()
219        items = session.query(db.Fluxo).all()
220        for i in items:
221            self.dados.append({
222               'id': i.id,
223               'nome': i.nome,
224               'tipoprotocolo': self._tipo_protocolo(i.tipoprotocolo),
225               'tipodocumento': i.tipodocumento.nome,
226               'flexivel': i.flexivel,
227               'url-transicao': url('list-transicao', fluxo_id=i.id),
228               })
229
230class TransicaoRemoveView(grok.View):
231
232    grok.name('remove-transicao')
233    grok.context(INavigationRoot)
234    grok.require('cmf.ManagePortal')
235
236    @log
237    def render(self):
238        session = Session()
239        content = session.query(db.Transicao).get(self.request.id)
240        fluxo_id = content.fluxo_id
241        session.delete(content)
242        session.flush()
243        status = IStatusMessage(self.request)
244        status.add(_(u'Registro removido.'), 'info')
245        go('list-transicao', fluxo_id=fluxo_id)
246
247class TransicaoListView(grok.View, BaseListView):
248
249    grok.name('list-transicao')
250    grok.context(INavigationRoot)
251    grok.require('cmf.ManagePortal')
252   
253    dados = []
254    dados_fluxo = {}
255    view_sufix = 'transicao'
256
257    @log
258    def update(self):
259        self.request.set('disable_border', True)
260        self.dados = []
261        api = getUtility(ISPDOAPI)
262        fluxo = api.getFluxo()
263        self.request.response.setCookie('fluxo_id', fluxo.id)
264        self.dados_fluxo = {
265            'nome':fluxo.nome,
266            'url': url('show-fluxo', id=fluxo.id),
267            }
268        for i in fluxo.transicao:
269            self.dados.append({
270                'fluxo_id': i.fluxo_id,
271                'inicial': i.inicial,
272                'area_origem': i.area_origem.nome,
273                'url-area-origem': url('show-area', id=i.area_origem_id),
274                'area_destino': i.area_destino.nome,
275                'url-area-destino': url('show-area', id=i.area_destino_id),
276                'url-remove': url('remove-transicao', id=i.id),
277                })
278
279class PessoaOrigemRemoveView(grok.View):
280
281    grok.name('remove-pessoaorigem')
282    grok.context(INavigationRoot)
283    grok.require('zope2.View')
284
285    def update(self):
286        sc = getUtility(ISecurityChecker)
287        sc.enforce('acessar_remove_pessoaorigem')
288        super(PessoaOrigemRemoveView, self).update()
289
290    @log
291    def render(self):
292        session = Session()
293        r = self.request
294        content = session.query(db.PessoaOrigem).get((r.protocolo_id, r.pessoa_id))
295        session.delete(content)
296        session.flush()
297        status = IStatusMessage(self.request)
298        status.add(_(u'Registro removido.'), 'info')
299        go('show-protocolo', id=r.protocolo_id)
300
301class PessoaDestinoRemoveView(grok.View):
302
303    grok.name('remove-pessoadestino')
304    grok.context(INavigationRoot)
305    grok.require('zope2.View')
306
307    def update(self):
308        sc = getUtility(ISecurityChecker)
309        sc.enforce('acessar_remove_pessoadestino')
310        super(PessoaDestinoRemoveView, self).update()
311
312    @log
313    def render(self):
314        session = Session()
315        r = self.request
316        content = session.query(db.PessoaDestino).get((r.protocolo_id, r.pessoa_id))
317        session.delete(content)
318        session.flush()
319        status = IStatusMessage(self.request)
320        status.add(_(u'Registro removido.'), 'info')
321        go('show-protocolo', id=r.protocolo_id)
322
323class NotificacaoRemoveView(grok.View):
324
325    grok.name('remove-notificacao')
326    grok.context(INavigationRoot)
327    grok.require('zope2.View')
328
329    def update(self):
330        sc = getUtility(ISecurityChecker)
331        sc.enforce('acessar_remove_notificacao')
332        super(NotificacaoRemoveView, self).update()
333
334    @log
335    def render(self):
336        session = Session()
337        api = getUtility(ISPDOAPI)
338        pessoa_id = api.getAuthPessoa().id
339        content = session.query(db.Notificacao).get((pessoa_id, self.request.protocolo_id))
340        session.delete(content)
341        session.flush()
342        status = IStatusMessage(self.request)
343        status.add(_(u'Registro removido.'), 'info')
344        go('list-notificacao')
345
346class NotificacaoListView(grok.View, BaseListView):
347
348    grok.name('list-notificacao')
349    grok.context(INavigationRoot)
350    grok.require('zope2.View')
351   
352    dados = []
353    dados_pessoa = {}
354    view_sufix = 'notificacao'
355
356    @log
357    def update(self):
358        sc = getUtility(ISecurityChecker)
359        sc.enforce('acessar_list_notificacao')
360        self.request.set('disable_border', True)
361        self.dados = []
362        self.dados_pessoa = {}
363        api = getUtility(ISPDOAPI)
364        pessoa = api.getAuthPessoa()
365        self.dados_pessoa = {
366            'pessoa_id': pessoa.id,
367            'nome': pessoa.nome,
368            'email': pessoa.email,
369            'url': url('show-pessoa', id=pessoa.id)
370            }
371        for i in pessoa.notificacao:
372            self.dados.append({
373                'protocolo_id': i.protocolo.id,
374                'numero': i.protocolo.numero,
375                'data_protocolo': i.protocolo.data_protocolo,
376                'assunto': i.protocolo.assunto,
377                'tipodocumento': i.protocolo.tipodocumento.nome,
378                'situacao': i.protocolo.situacao.nome,
379                'url-remove': url('remove-notificacao', protocolo_id=i.protocolo.id),
380                })
381
382class ProtocoloShowView(grok.View):
383
384    grok.name('show-protocolo')
385    grok.context(INavigationRoot)
386    grok.require('zope2.View')
387   
388    dados = {}
389
390    @log
391    def update(self):
392        sc = getUtility(ISecurityChecker)
393        sc.enforce('acessar_show_protocolo')
394        self.request.set('disable_border', True)
395        api = getUtility(ISPDOAPI)
396        self._protocolo = api.getProtocolo(self.request.id)
397        self.request.response.setCookie('protocolo_id', self._protocolo.id)
398        self.dados = {
399            'protocolo_id': self._protocolo.id,
400            'tipoprotocolo': self._tipo_protocolo(),
401            'tipodocumento': self._protocolo.tipodocumento.nome,
402            'numero': self._protocolo.numero,
403            'data_protocolo': self._protocolo.data_protocolo,
404            'numero_documento': self._protocolo.numero_documento,
405            'data_emissao': self._protocolo.data_emissao,
406            'assunto': self._protocolo.assunto,
407            'situacao': self._protocolo.situacao.nome,
408            'referencias': self._referencias(),
409            'referenciado_por': self._referenciado_por(),
410            'apensado': self._apensado(),
411            'apensos': self._apensos(),
412            'origens': self._origens(),
413            'destinos': self._destinos(),
414            'observacoes': self._observacoes(),
415            'anexos': self._anexos(),
416            'tramites': self._tramites(),
417            'menu': self._menu(),
418        }
419
420    def _tipo_protocolo(self):
421        tpvf = getUtility(IVocabularyFactory, 'il.spdo.tipoprotocolo-vocab')
422        tpv = tpvf(self.context)
423        return tpv.getTerm(self._protocolo.tipoprotocolo).title
424
425    def _referencias(self):
426        ret = []
427        sc = getUtility(ISecurityChecker)
428        if not sc.check('acessar_list_referencia'):
429            return ret
430        for i in self._protocolo.protocolo:
431            ret.append({
432                'numero': i.referencia.numero,
433                'url': url('show-protocolo', id=i.referencia_id),
434                })
435        return ret
436   
437    def _referenciado_por(self):
438        ret = []
439        sc = getUtility(ISecurityChecker)
440        if not sc.check('acessar_list_referencia'):
441            return ret
442        for i in self._protocolo.referencia:
443            ret.append({
444                'numero': i.protocolo.numero,
445                'url': url('show-protocolo', id=i.protocolo_id),
446                })
447        return ret
448
449    def _apensado(self):
450        i = self._protocolo.apensado
451        if i is not None:
452            return {
453                'numero': i.numero,
454                'url': url('show-protocolo', id=i.id)
455                }
456
457    def _apensos(self):
458        ret = []
459        for i in self._protocolo.apenso:
460            ret.append({
461                'numero': i.numero,
462                'url': url('show-protocolo', id=i.id),
463                })
464        return ret
465   
466    def _origens(self):
467        sc = getUtility(ISecurityChecker)
468        show_pessoa = sc.check('acessar_show_pessoa')
469        remove_pessoaorigem = sc.check('acessar_remove_pessoaorigem', protocolo_id=self._protocolo.id)
470        ret = []
471        for p in self._protocolo.pessoa_origem:
472            i = p.pessoa
473            url_pessoa = show_pessoa and url('show-pessoa', id=i.id) or None
474            url_remove = remove_pessoaorigem and url('remove-pessoaorigem', protocolo_id=self._protocolo.id, pessoa_id=i.id) or None
475            ret.append({
476                'nome': i.nome,
477                'email': i.email,
478                'url': url_pessoa,
479                'url-remove': url_remove,
480                })
481        return ret
482   
483    def _destinos(self):
484        sc = getUtility(ISecurityChecker)
485        show_pessoa = sc.check('acessar_show_pessoa')
486        edit_pessoadestino = sc.check('acessar_edit_pessoadestino', protocolo_id=self._protocolo.id)
487        remove_pessoadestino = sc.check('acessar_remove_pessoadestino', protocolo_id=self._protocolo.id)
488        ret = []
489        for p in self._protocolo.pessoa_destino:
490            i = p.pessoa
491            url_pessoa = show_pessoa and url('show-pessoa', id=i.id) or None
492            url_edit = edit_pessoadestino and url('edit-pessoadestino', protocolo_id=self._protocolo.id, pessoa_id=i.id) or None
493            url_remove = remove_pessoadestino and url('remove-pessoadestino', protocolo_id=self._protocolo.id, pessoa_id=i.id) or None
494            ret.append({
495                'nome': i.nome,
496                'email': i.email,
497                'tipoentrega': p.tipoentrega.nome if p.tipoentrega is not None else '',
498                'data_entrega': p.data_entrega,
499                'objeto_correios': p.objeto_correios,
500                'url': url_pessoa,
501                'url-edit': url_edit,
502                'url-remove': url_remove,
503                })
504        return ret
505   
506    def _observacoes(self):
507        ret = []
508        sc = getUtility(ISecurityChecker)
509        if not sc.check('visualizar_observacoes', protocolo_id=self._protocolo.id):
510            return ret
511        for i in self._protocolo.observacao:
512            edit_observacao = sc.check('acessar_edit_observacao', protocolo_id=self._protocolo.id, observacao_id=i.id)
513            url_edit = edit_observacao and url('edit-observacao', id=i.id) or None
514            remove_observacao = sc.check('acessar_remove_observacao', protocolo_id=self._protocolo.id, observacao_id=i.id)
515            url_remove = remove_observacao and url('remove-observacao', id=i.id) or None
516            ret.append({
517                'texto': i.texto,
518                'data_observacao': i.data_observacao,
519                'url-edit': url_edit,
520                'url-remove': url_remove,
521                })
522        return ret
523   
524    def _anexos(self):
525        ret = []
526        sc = getUtility(ISecurityChecker)
527        if not sc.check('visualizar_anexos', protocolo_id=self._protocolo.id):
528            return ret
529        for i in self._protocolo.anexo:
530            remove_anexo = sc.check('acessar_remove_anexo', protocolo_id=self._protocolo.id, anexo_id=i.id)
531            url_remove = remove_anexo and url('remove-anexo', id=i.id) or None
532            ret.append({
533                'arquivo': i.arquivo,
534                'tamanho': i.tamanho,
535                'data_anexo': i.data_anexo,
536                'download_url': url('download-anexo', id=i.id),
537                'url-remove': url_remove,
538                })
539        return ret
540   
541    def _tramites(self):
542        sc = getUtility(ISecurityChecker)
543        show_pessoa = sc.check('acessar_show_pessoa')
544        visualizar_despachos = sc.check('visualizar_despachos', protocolo_id=self._protocolo.id)
545        ret = []
546        for i in self._protocolo.tramite:
547            url_responsavel = show_pessoa and url('show-pessoa', id=i.responsavel.pessoa.id) or None
548            despacho = visualizar_despachos and i.despacho or None
549            ret.append({
550                'data_disponibilizacao': i.data_disponibilizacao,
551                'data_recebimento': i.data_recebimento,
552                'area': i.area.sigla,
553                'nome_responsavel': i.responsavel.pessoa.nome,
554                'url-responsavel': url_responsavel,
555                'despacho': despacho,
556                })
557        return ret
558
559    def _menu(self):
560        sc = getUtility(ISecurityChecker)
561        protocolo_id = self._protocolo.id
562        apenso_id = self._protocolo.apenso_id
563        ret = []
564       
565        if sc.check('acessar_edit_protocolo', protocolo_id=protocolo_id):
566            ret.append({'url': url('edit-protocolo', id=protocolo_id),
567                        'titulo': _(u'Atualizar Protocolo'),
568                        'id': 'overlay-edit-protocolo'})
569
570        if sc.check('acessar_add_observacao', protocolo_id=protocolo_id):
571            ret.append({'url': url('add-observacao', protocolo_id=protocolo_id),
572                        'titulo': _(u'Adicionar Observação'),
573                        'class': 'overlay-add-edit-observacao'})
574
575        if sc.check('acessar_add_anexo', protocolo_id=protocolo_id):
576            ret.append({'url': url('add-anexo', protocolo_id=protocolo_id),
577                        'titulo': _(u'Adicionar Anexo')})
578
579        if sc.check('acessar_list_referencia', protocolo_id=protocolo_id):
580            ret.append({'url': url('list-referencia', protocolo_id=protocolo_id),
581                        'titulo': _(u'Referências')})
582
583        if sc.check('acessar_add_apenso', protocolo_id=protocolo_id, apenso_id=apenso_id):
584            ret.append({'url': url('add-apenso', protocolo_id=protocolo_id),
585                        'titulo': _(u'Apenso')})
586
587        if sc.check('acessar_add_tramite', protocolo_id=protocolo_id):
588            ret.append({'url': url('add-tramite', protocolo_id=protocolo_id),
589                        'titulo': _(u'Tramitar')})
590
591        return ret
592
593class ProtocoloListView(grok.View, BaseListView):
594
595    grok.name('list-protocolo')
596    grok.context(INavigationRoot)
597    grok.require('zope2.View')
598
599    dados = []
600    view_sufix = 'protocolo'
601
602    @log
603    def update(self):
604        sc = getUtility(ISecurityChecker)
605        sc.enforce('acessar_list_protocolo')
606        self.request.set('disable_border', True)
607        api = getUtility(ISPDOAPI)
608        self.dados = api.getProtocolosCriadosRecebidos()
609
610class AnexoRemoveView(grok.View):
611
612    grok.name('remove-anexo')
613    grok.context(INavigationRoot)
614    grok.require('zope2.View')
615
616    @log
617    def render(self):
618        session = Session()
619        content = session.query(db.Anexo).get(self.request.id)
620        protocolo_id = content.protocolo_id
621        sc = getUtility(ISecurityChecker)
622        sc.enforce('acessar_remove_anexo', protocolo_id=protocolo_id, anexo_id=self.request.id)
623        session.delete(content)
624        session.flush()
625        status = IStatusMessage(self.request)
626        status.add(_(u'Registro removido.'), 'info')
627        go('show-protocolo', id=protocolo_id)
628   
629class AnexoDownloadView(grok.View):
630
631    grok.name('download-anexo')
632    grok.context(INavigationRoot)
633    grok.require('zope2.View')
634
635    def update(self):
636        sc = getUtility(ISecurityChecker)
637        sc.enforce('visualizar_anexos')
638        super(AnexoDownloadView, self).update()
639
640    @log
641    def render(self):
642        session = Session()
643        anexo = session.query(db.Anexo).get(self.request.id)
644        p = anexo.protocolo
645        path_anexo = os.path.join(PATH_ANEXOS, ScopeID(), str(p.ano), str(p.id), str(anexo.id))
646        file_anexo = NamedFile(open(path_anexo, 'r'), filename=anexo.arquivo)
647        cd = 'inline; filename="%s"' % anexo.arquivo.encode('utf-8')
648        self.request.response.setHeader('Content-Disposition', cd)
649        set_headers(file_anexo, self.request.response)
650        return stream_data(file_anexo)
651
652class ObservacaoRemoveView(grok.View):
653
654    grok.name('remove-observacao')
655    grok.context(INavigationRoot)
656    grok.require('zope2.View')
657
658    @log
659    def render(self):
660        session = Session()
661        content = session.query(db.Observacao).get(self.request.id)
662        protocolo_id = content.protocolo_id
663        sc = getUtility(ISecurityChecker)
664        sc.enforce('acessar_remove_observacao', protocolo_id=protocolo_id, observacao_id=self.request.id)
665        session.delete(content)
666        session.flush()
667        status = IStatusMessage(self.request)
668        status.add(_(u'Registro removido.'), 'info')
669        go('show-protocolo', id=protocolo_id)
670
671class ReferenciaRemoveView(grok.View):
672
673    grok.name('remove-referencia')
674    grok.context(INavigationRoot)
675    grok.require('zope2.View')
676
677    def update(self):
678        sc = getUtility(ISecurityChecker)
679        sc.enforce('acessar_remove_referencia')
680        super(ReferenciaRemoveView, self).update()
681
682    @log
683    def render(self):
684        session = Session()
685        r = self.request
686        content = session.query(db.Referencia).get((r.protocolo_id, r.referencia_id))
687        session.delete(content)
688        session.flush()
689        status = IStatusMessage(self.request)
690        status.add(_(u'Registro removido.'), 'info')
691        go('list-referencia', protocolo_id=r.protocolo_id)
692
693class ReferenciaListView(grok.View, BaseListView):
694
695    grok.name('list-referencia')
696    grok.context(INavigationRoot)
697    grok.require('zope2.View')
698   
699    dados = []
700    dados_protocolo = {}
701    view_sufix = 'referencia'
702
703    @log
704    def update(self):
705        sc = getUtility(ISecurityChecker)
706        sc.enforce('acessar_list_referencia')
707        self.request.set('disable_border', True)
708        self.dados = []
709        self.dados_protocolo = {}
710        api = getUtility(ISPDOAPI)
711        protocolo = api.getProtocolo()
712        self.dados_protocolo = {
713            'protocolo_id': protocolo.id,
714            'numero': protocolo.numero,
715            'data_protocolo': protocolo.data_protocolo,
716            'assunto': protocolo.assunto,
717            'tipodocumento': protocolo.tipodocumento.nome,
718            'situacao': protocolo.situacao.nome,
719            'url': url('show-protocolo', id=protocolo.id)
720            }
721        for i in protocolo.protocolo:
722            self.dados.append({
723                'protocolo_id': i.protocolo_id,
724                'referencia_id': i.referencia_id,
725                'numero': i.referencia.numero,
726                'data_protocolo': i.referencia.data_protocolo,
727                'assunto': i.referencia.assunto,
728                'tipodocumento': i.referencia.tipodocumento.nome,
729                'situacao': i.referencia.situacao.nome,
730                'url-remove': url('remove-referencia', protocolo_id=i.protocolo_id, referencia_id=i.referencia_id),
731                })
732
733class EtiquetasDownloadView(grok.View):
734
735    grok.name('download-etiquetas')
736    grok.context(INavigationRoot)
737    grok.require('zope2.View')
738
739    def update(self):
740        sc = getUtility(ISecurityChecker)
741        sc.enforce('acessar_print_etiquetas')
742        super(EtiquetasDownloadView, self).update()
743
744    @log
745    def render(self):
746        file_etiquetas = NamedFile(open('/tmp/%s.pdf' % self.request.SESSION.id, 'r'), filename=u'etiquetas.pdf')
747        cd = 'inline; filename="etiquetas.pdf"'
748        self.request.response.setHeader('Content-Disposition', cd)
749        set_headers(file_etiquetas, self.request.response)
750        return stream_data(file_etiquetas)
751
752class ProtocoloAddWSView(grok.View):
753
754    grok.name('ws-add-protocolo')
755    grok.context(INavigationRoot)
756    grok.require('zope2.View')
757
758    def update(self):
759        sc = getUtility(ISecurityChecker)
760        sc.enforce('acessar_ws_add_protocolo')
761        super(ProtocoloAddWSView, self).update()
762
763    def _json_error(self, error_code):
764        ERROS = {
765            1: _(u'Parâmetro dados não informado.'),
766            2: _(u'Estrutura de dados inválida.'),
767            3: _(u'Esse tipo de protocolo e/ou tipo de documento não pode ser protocolado pela sua área.'),
768        }
769        return json.dumps(ERROS[error_code])
770
771    def _tipodocumento(self, nome):
772        session = Session()
773        return session.query(db.TipoDocumento).filter_by(nome=nome).first()
774   
775    def _valida_dados(self, dados):
776        """
777        Valida o parâmetro 'dados', que deve ser uma estrutura como a demonstrada a seguir:
778
779        import json
780        dados = {'origens': [{'email': 'email@origem.net', 'nome': 'Nome da Pessoa de Origem'}],
781                 'destinos': [{'email': 'email@destino.net', 'nome': 'Nome da Pessoa de Destino'}],
782                 'assunto': 'Assunto...',
783                 'observacao': '',
784                 'numero_documento': '12345',
785                 'data_emissao': '2011-11-23',
786                 'situacao': 'Tramitando',
787                 'tipodocumento': 'Carta',
788                 'tipoprotocolo': 'E'}
789        print json.dumps(dados)
790        """
791       
792        # dados precisa ser um dicionário
793        if type(dados) != type({}):
794            return False
795
796        # dados deve conter todas as chaves
797        for k in ('origens', 'destinos', 'assunto', 'observacao', 'numero_documento',
798                  'data_emissao', 'situacao', 'tipodocumento', 'tipoprotocolo'):
799            if dados.get(k, None) is None:
800                return False
801       
802        # origens (e destinos) devem ser listas de dicionários não vazias
803        for f in ('origens', 'destinos'):
804            origens = dados.get(f)
805            if type(origens) != type([]) or len(origens) < 1:
806                return False
807            for p in origens:
808                if type(p) != type({}):
809                    return False
810                for k in ('email', 'nome'):
811                    if p.get(k, None) is None:
812                        return False
813                   
814        # demais campos devem ser strings unicode
815        for k in ('assunto', 'observacao', 'numero_documento', 'data_emissao',
816                  'situacao', 'tipodocumento', 'tipoprotocolo'):
817            if type(dados.get(k)) != type(u''):
818                return False
819
820        # assunto é obrigatório
821        if not dados.get('assunto', None):
822            return False
823
824        # tipo de protocolo deve ser 'R', 'E' ou 'I'
825        if dados.get('tipoprotocolo') not in ('R', 'E', 'I'):
826            return False
827
828        # a data de emissão, quando não for uma string vazia, deve ser
829        # uma data válida, representada como AAAA-MM-DD e que não seja
830        # maior do que a data atual
831        dt = dados.get('data_emissao')
832        if dt:
833            if len(dt) != 10:
834                return False
835            try:
836                aaaa, mm, dd = dt.split('-')
837                aaaa = int(aaaa)
838                mm = int(mm)
839                dd = int(dd)
840                d1 = datetime.date(aaaa, mm, dd)
841                d2 = datetime.date.today()
842                if d1 > d2:
843                    return False
844            except ValueError, IndexError:
845                return False
846
847        # os valores de “situacao” e “tipodocumento” devem estar cadastrados
848        session = Session()
849        if not session.query(db.Situacao).filter_by(nome=dados.get('situacao')).filter_by(inicial=True).first():
850            return False
851        if not self._tipodocumento(dados.get('tipodocumento')):
852            return False
853
854        return True
855   
856    def _addProtocolo(self, dados, anexos=[]):
857
858        session = Session()
859        api = getUtility(ISPDOAPI)
860
861        # origens (e destinos)
862        pessoas_origens = []
863        pessoas_destinos = []
864        for f in ('origens', 'destinos'):
865            for origem in dados[f]:
866                pessoa = session.query(db.Pessoa).filter_by(email=origem['email']).first()
867                if not pessoa:
868                    pessoa = db.Pessoa(origem['nome'], origem['email'])
869                    session.add(pessoa)
870                    session.flush()
871                if f == 'origens':
872                    pessoas_origens.append(pessoa.id)
873                else:
874                    pessoas_destinos.append(pessoa.id)
875
876        # "situacao" e "tipodocumento"
877        situacao = session.query(db.Situacao).filter_by(nome=dados.get('situacao')).filter_by(inicial=True).first()
878        tipodocumento = self._tipodocumento(dados.get('tipodocumento'))
879
880        # data de emissão
881        dt = dados.get('data_emissao')
882        if dt:
883            aaaa, mm, dd = dt.split('-')
884            aaaa = int(aaaa)
885            mm = int(mm)
886            dd = int(dd)
887            dt = datetime.date(aaaa, mm, dd)
888        else:
889            dt = None
890
891        # cria protocolo, observacao, anexos e tramite inicial, utilizando a API
892
893        # IMPORTANTE: Por definição, exceto na criação dos protocolos,
894        # os anexos e as observações são sempre adicionadas ANTES da
895        # tramitação ocorrer.
896
897        protocolo_id = api.addProtocolo(dados['tipoprotocolo'], tipodocumento.id, dados['numero_documento'], dt,
898                                        dados['assunto'], situacao.id, pessoas_origens, pessoas_destinos)
899
900        api.TramiteInicial(protocolo_id)
901
902        if dados['observacao'].strip():
903            api.addObservacao(protocolo_id, dados['observacao'])
904           
905        if anexos:
906            api.addAnexos(protocolo_id, anexos)
907
908        protocolo = api.getProtocolo(protocolo_id)       
909        return protocolo.numero, protocolo.data_protocolo
910
911    @log
912    def render(self):
913        r = self.request
914
915        dados = r.get('dados', '')
916        if not dados:
917            return self._json_error(1)
918
919        dados = json.loads(dados)
920        if not self._valida_dados(dados):
921            return self._json_error(2)
922
923        sc = getUtility(ISecurityChecker)
924        if not sc.check('fluxo_rigoroso_area_inicial', tipoprotocolo=dados['tipoprotocolo'],
925                        tipodocumento_id=self._tipodocumento(dados['tipodocumento']).id):
926            return self._json_error(3)
927
928        anexos = [NamedFile(r.form[a], filename=unicode(r.form[a].filename, 'utf-8')) \
929                  for a in r.form.keys() if a.startswith('anexo')]
930        numero, data_protocolo = self._addProtocolo(dados, anexos)
931        return json.dumps(_('Protocolo: %s de %s' % (numero, str(data_protocolo))))
932
933
934class AreaListWSView(grok.View):
935
936    grok.name('ws-list-area')
937    grok.context(INavigationRoot)
938    grok.require('zope2.View')
939
940    @log
941    def render(self):
942
943        self.dados = []
944        session = Session()
945        items = session.query(db.Area).all()
946        for i in items:
947            self.dados.append({
948                'id': i.id,
949                'sigla': i.sigla,
950                'nome': i.nome,
951                'chefia_id': i.chefia_id,
952                'chefia_sigla': getattr(i.area,'sigla',''),
953                'chefia_nome': getattr(i.area,'nome',''),
954                })
955
956        return json.dumps(self.dados[0])
957
958class SecurityCheckerView(BrowserView):
959    """View de verificação de segurança, destinada a omitir nas
960    portlets as opções que os usuários não podem acessar.
961    """
962
963    implements(ISecurityChecker)
964
965    def check(self, acao, **kwargs):
966        sc = getUtility(ISecurityChecker)
967        return sc.check(acao, **kwargs)
968
969    def enforcee(self, acao, **kwargs):
970        sc = getUtility(ISecurityChecker)
971        return sc.enforce(acao, **kwargs)
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.