class IFluxo(IBaseFormSchema):
form.mode(id='hidden')
id = schema.Int(
title=_(u'ID'),
description=_(u'Identificador do Fluxo.'),
required=False)
nome = schema.TextLine(
title=_(u'Nome'),
description=_(u'Informe o nome do fluxo.'))
tipoprotocolo = schema.Choice(
title=_(u'Tipo de Protocolo'),
description=_(u'Selecione o tipo do protocolo.'),
vocabulary='il.spdo.tipoprotocolo-vocab')
tipodocumento_id = schema.Choice(
title=_(u'Tipo de Documento'),
description=_(u'Selecione o tipo do documento.'),
vocabulary='il.spdo.tipodocumento-vocab')
flexivel = schema.Bool(
title=_(u'Flexível'),
description=_(u'O fluxo possui tramitação flexível?'),
required=False)
class IApenso(IBaseFormSchema):
form.mode(protocolo_id='hidden')
protocolo_id = schema.Int(
title=_(u'ID do Protocolo'),
description=_(u'Identificador do Protocolo.'),
defaultFactory=getProtocoloId,
required=False)
form.widget(apenso_id=AutocompleteFieldWidget)
apenso_id = schema.Choice(
title=_(u'Apenso'),
description=_(u'Número de Protocolo de Apenso'),
vocabulary='il.spdo.protocolo-vocab',
required=False)
@interface.invariant
def verifyApenso(apenso):
if not apenso.apenso_id:
return
if not apenso.protocolo_id:
raise interface.Invalid(_(u'O parâmetro protocolo_id não foi informado.'))
if apenso.protocolo_id == apenso.apenso_id:
raise interface.Invalid(_(u'O protocolo não pode ser apensado a ele mesmo.'))
sc = getUtility(ISecurityChecker)
if not sc.check('ciclo_apenso', protocolo_id=apenso.protocolo_id, apenso_id=apenso.apenso_id):
raise interface.Invalid(_(u'Ciclo de apensos detectado!'))
if not sc.check('momento_tramitacao', protocolo_id=apenso.protocolo_id, apenso_id=apenso.apenso_id):
raise interface.Invalid(_(u'Para que um protocolo seja apensado em outro é necessário que ambos compartilhem o mesmo momento na tramitação, ou seja, estejam tramitando nas mesmas áreas e tenham o mesmo tipo de documento e protocolo.'))
class ObservacaoAddForm(base.AddForm):
"""Formulário de cadastro de observações.
"""
grok.context(INavigationRoot)
grok.name('add-observacao')
grok.require('zope2.View')
schema = IObservacao
klass = Observacao
label = _(u'Adicionar Observação')
description = _(u'Formulário de cadastro de observações.')
def update(self):
sc = getUtility(ISecurityChecker)
sc.enforce('acessar_add_observacao')
super(ObservacaoAddForm, self).update()
@log
def createAndAdd(self, data):
api = getUtility(ISPDOAPI)
protocolo_id = api.getProtocoloId()
api.addObservacao(protocolo_id, data['texto'])
def nextURL(self):
api = getUtility(ISPDOAPI)
protocolo_id = api.getProtocoloId()
go('show-protocolo', id=protocolo_id)
class PessoaOrigemAddForm(base.AddForm):
"""Formulário de cadastro de origens.
"""
grok.context(INavigationRoot)
grok.name('add-pessoaorigem')
grok.require('zope2.View')
schema = IPessoaOrigem
klass = PessoaOrigem
label = _(u'Adicionar Origem')
description = _(u'Formulário de cadastro de origens.')
def update(self):
sc = getUtility(ISecurityChecker)
sc.enforce('acessar_add_pessoaorigem', ajax=True)
super(PessoaOrigemAddForm, self).update()
@log
def createAndAdd(self, data):
api = getUtility(ISPDOAPI)
protocolo_id = api.getProtocoloId()
session = Session()
for i in data['pessoa_id']:
pessoaorigem = PessoaOrigem()
pessoaorigem.protocolo_id = protocolo_id
pessoaorigem.pessoa_id = i
pessoaorigem.version = nextVersion('pessoa_origem', protocolo_id=protocolo_id, pessoa_id=i)
session.add(pessoaorigem)
session.flush()
def nextURL(self):
api = getUtility(ISPDOAPI)
protocolo_id = api.getProtocoloId()
go('show-protocolo', id=protocolo_id)
def _json_error(self, error_code):
ERROS = {
1: _(u'Parâmetro dados não informado.'),
2: _(u'Estrutura de dados inválida.'),
3: _(u'Esse tipo de protocolo e/ou tipo de documento não pode ser protocolado pela sua área.'),
}
return json.dumps(ERROS[error_code])
class IEntrega(IBaseFormSchema):
form.mode(protocolo_id='hidden')
protocolo_id = schema.Int(
title=_(u'ID do Protocolo'),
description=_(u'Identificador do Protocolo.'),
defaultFactory=getProtocoloId)
form.mode(pessoa_id='hidden')
pessoa_id = schema.Int(
title=_(u'ID da Pessoa'),
description=_(u'Identificador da Pessoa.'))
tipoentrega_id = schema.Choice(
title=_(u'Tipo de Entrega'),
description=_(u'Selecione o tipo de entrega.'),
vocabulary='il.spdo.tipoentrega-vocab')
form.widget(data_entrega=DateFieldWidget)
data_entrega = schema.Date(
title=_(u'Data de Entrega'),
description=_(u'Informe a data de entrega do protocolo expedido.'),
defaultFactory=datetime.date.today,
required=False)
objeto_correios = schema.TextLine(
title=_(u'Objeto dos Correios'),
description=_(u'Informe o identificador do objeto dos correios, quando for o caso.'),
max_length=20,
required=False)
class TransicaoAddForm(base.AddForm):
"""Formulário de cadastro de transições.
"""
grok.context(INavigationRoot)
grok.name('add-transicao')
grok.require('cmf.ManagePortal')
schema = IAddTransicao
klass = Transicao
label = _(u'Adicionar Transições')
description = _(u'Formulário de cadastro de transições.')
@log
def createAndAdd(self, data):
api = getUtility(ISPDOAPI)
fluxo_id = api.getFluxoId()
session = Session()
for i in data['area_origem_id']:
for j in data['area_destino_id']:
# garante que a transição não tenha origem e destino iguais
if i == j:
continue
transicao = Transicao()
transicao.fluxo_id = fluxo_id
transicao.inicial = data['inicial']
transicao.area_origem_id = i
transicao.area_destino_id = j
session.add(transicao)
session.flush()
def nextURL(self):
api = getUtility(ISPDOAPI)
fluxo_id = api.getFluxoId()
go('list-transicao', fluxo_id=fluxo_id)
def _notificaResponsaveis(self, protocolos):
"""Envia email notificando tramitação para a pessoa destino
"""
pu = getToolByName(getSite(), 'portal_url')
portal = pu.getPortalObject()
mh = portal.MailHost
session = Session()
protocolos = list(set(protocolos))
for protocolo_id in protocolos:
protocolo = session.query(db.Protocolo).get(protocolo_id)
# TODO: refatorar. Essa lista de tramites pode vir
# pronta do método TramiteEnvio, evitando notificações
# desnecessárias nas tramitações por cópia.
tramites = session.query(db.Tramite).\
filter_by(protocolo_id=protocolo_id).\
filter_by(data_recebimento=None).all()
for tramite in tramites:
d = {
'numero':
protocolo.numero,
'data_tramitacao':
tramite.data_disponibilizacao,
'assunto':
protocolo.assunto,
'area_origem':
tramite.area_anterior.nome,
'responsavel_origem':
tramite.area_anterior.responsavel[-1].pessoa.nome,
'area_destino':
tramite.area.nome,
'responsavel_destino':
tramite.responsavel.pessoa.nome,
'situacao':
protocolo.situacao.nome,
'despacho':
tramite.despacho,
'url_protocolo':
url('show-protocolo', id=protocolo.id)
}
mfrom = unicode(portal.getProperty('email_from_address'),
'utf-8')
mto = tramite.responsavel.pessoa.email
subject = NOTIFICACAO_OBRIG_ASSUNTO % d
body = NOTIFICACAO_OBRIG_MSG % d
text = u"From: %s\nTo: %s\nSubject: %s\n\n%s" % (mfrom, mto,
subject, body)
try:
mh.send(text, immediate=True, charset='utf8')
logger(_(u'Enviou...'))
logger(_(text))
except:
logger(_(u'Erro ao enviar a mensagem de notificação.'))
class TramiteRecebimentoForm(base.AddForm):
"""Formulário de tramitação de recebimento de protocolos.
"""
grok.context(INavigationRoot)
grok.name('recebimento-tramite')
grok.require('zope2.View')
schema = IBaseFormSchema
label = _(u'Tramitação de Protocolos - Recebimento')
description = _(u'Formulário de tramitação de recebimento de protocolos.')
dados = []
@log
def update(self):
self.request.set('disable_border', True)
sc = getUtility(ISecurityChecker)
sc.enforce('acessar_recebimento_tramite')
api = getUtility(ISPDOAPI)
self.dados = api.getProtocolosNaoRecebidos()
super(TramiteRecebimentoForm, self).update()
@log
def createAndAdd(self, data):
api = getUtility(ISPDOAPI)
protocolos = self.request.protocolos
api.TramiteRecebimento(protocolos)
def nextURL(self):
go('recebimento-tramite')
def cancelURL(self):
go('list-protocolo')
class TramiteAddForm(base.AddForm):
"""Formulário de tramitação de protocolo.
"""
grok.context(INavigationRoot)
grok.name('add-tramite')
grok.require('zope2.View')
schema = IAddTramite
label = _(u'Tramitação de Protocolo')
description = _(u'Formulário de tramitação de um protocolo.')
def update(self):
sc = getUtility(ISecurityChecker)
sc.enforce('acessar_add_tramite')
super(TramiteAddForm, self).update()
@log
def createAndAdd(self, data):
api = getUtility(ISPDOAPI)
protocolo_id = api.getProtocoloId()
api.addAnexos(protocolo_id, data['anexos'])
api.TramiteEnvio([protocolo_id], data['areas'], data['despacho'])
def nextURL(self):
api = getUtility(ISPDOAPI)
protocolo_id = api.getProtocoloId()
go('show-protocolo', id=protocolo_id)
class NotificacaoAddForm(base.AddForm):
"""Formulário de cadastro de notificações.
"""
grok.context(INavigationRoot)
grok.name('add-notificacao')
grok.require('zope2.View')
schema = IAddNotificacao
klass = Notificacao
label = _(u'Adicionar Notificações')
description = _(u'Formulário de cadastro de notificações.')
def update(self):
sc = getUtility(ISecurityChecker)
sc.enforce('acessar_add_notificacao', ajax=True)
super(NotificacaoAddForm, self).update()
@log
def createAndAdd(self, data):
api = getUtility(ISPDOAPI)
pessoa_id = api.getAuthPessoa().id
session = Session()
for i in data['protocolo_id']:
notificacao = Notificacao()
notificacao.pessoa_id = pessoa_id
notificacao.protocolo_id = i
notificacao.version = nextVersion('notificacao',
pessoa_id=pessoa_id,
protocolo_id=i)
session.add(notificacao)
session.flush()
def nextURL(self):
go('list-notificacao')
class ApensoAddForm(base.AddForm):
"""Formulário de cadastro de apenso.
"""
grok.context(INavigationRoot)
grok.name('add-apenso')
grok.require('zope2.View')
schema = IApenso
klass = db.Protocolo
label = _(u'Adicionar apenso')
descrition = _(u'Formulário de cadastro de apenso.')
def update(self):
sc = getUtility(ISecurityChecker)
sc.enforce('acessar_add_apenso', ajax=True)
super(ApensoAddForm, self).update()
@log
def createAndAdd(self, data):
api = getUtility(ISPDOAPI)
protocolo = api.getProtocolo()
# garante que o protocolo não seja apensado em si mesmo
if protocolo.id == data['apenso_id']:
return
protocolo.apenso_id = data['apenso_id']
def nextURL(self):
api = getUtility(ISPDOAPI)
protocolo_id = api.getProtocoloId()
go('show-protocolo', id=protocolo_id)
def _json_error(self, error_code):
ERROS = {
1: _(u"Parâmetro dados não informado."),
2: _(u"Estrutura de dados inválida."),
3: _(u"Esse tipo de protocolo e/ou tipo de documento não pode ser protocolado pela sua área."),
}
return json.dumps(ERROS[error_code])
class IAddNotificacao(IBaseFormSchema):
form.widget(protocolo_id=AutocompleteMultiFieldWidget)
protocolo_id = schema.List(
title=_(u'Protocolos'),
description=_(u'Protocolos que serão acompanhados, enviando notificações por email ao serem atualizados.'),
value_type=schema.Choice(vocabulary='il.spdo.protocolo-vocab'))
class IAddProtocolo(IBaseProtocolo):
situacao_id = schema.Choice(
title=_(u'Situação'),
description=_(u'Selecione a situação inicial do protocolo.'),
vocabulary='il.spdo.situacao-inicial-vocab')
form.widget(origem=AutocompleteMultiFieldWidget)
origem = schema.List(
title=_(u'Origem'),
description=_(u'Selecione uma ou mais pessoas de origem do protocolo.'),
value_type=schema.Choice(vocabulary='il.spdo.pessoa-vocab'))
form.widget(destino=AutocompleteMultiFieldWidget)
destino = schema.List(
title=_(u'Destino'),
description=_(u'Selecione uma ou mais pessoas de destino do protocolo.'),
value_type=schema.Choice(vocabulary='il.spdo.pessoa-vocab'))
observacao = schema.Text(
title=_(u'Observação'),
description=_(u'Informe qualquer observação que seja necessária.'),
required=False)
if ENABLE_FLASH_MULTIFILE:
form.widget(anexos=MultiFileFieldWidget)
anexos = schema.List(
title=_(u'Anexos'),
description=_(u'Adicione anexos ao protocolo (opcional).'),
required=False,
value_type=NamedFile())
def verifyFluxo(tramite):
if not tramite.protocolo_id:
raise interface.Invalid(_(u'O parâmetro protocolo_id não foi informado.'))
if not tramite.areas:
raise interface.Invalid(_(u'O parâmetro areas não foi informado.'))
sc = getUtility(ISecurityChecker)
if not sc.check('fluxo_rigoroso', protocolo_id=tramite.protocolo_id, areas=tramite.areas):
raise interface.Invalid(_(u'Não é possível tramitar esse protocolo para as áreas escolhidas. O fluxo de tramitação definido para o tipo de protocolo e documento não é flexível.'))
def verifyFluxo(protocolo):
if not protocolo.tipoprotocolo:
raise interface.Invalid(_(u'O parâmetro tipoprotocolo não foi informado.'))
if not protocolo.tipodocumento_id:
raise interface.Invalid(_(u'O parâmetro tipodocumento_id não foi informado.'))
sc = getUtility(ISecurityChecker)
if not sc.check('fluxo_rigoroso_area_inicial', tipoprotocolo=protocolo.tipoprotocolo, tipodocumento_id=protocolo.tipodocumento_id):
raise interface.Invalid(_(u'Esse tipo de protocolo e/ou tipo de documento não pode ser protocolado pela sua área.'))
class ProtocoloSearchForm(form.SchemaForm):
"""Formulário de pesquisa de protocolos.
"""
grok.context(INavigationRoot)
grok.name('search-protocolo')
grok.require('zope2.View')
ignoreContext = True
schema = ISearchProtocolo
label = _(u'Pesquisa Protocolos')
description = _(
u'Utilize o formulário a seguir para pesquisar por tipo de protocolo, '
+
u'tipo de documento, assunto, situação, origem, destino, área ou ainda '
+ u'pelo tempo que o protocolo está sem tramitar.')
dados = []
@log
def update(self):
self.request.set('disable_border', True)
sc = getUtility(ISecurityChecker)
sc.enforce('acessar_search_protocolo')
api = getUtility(ISPDOAPI)
self.dados = api.pesquisaProtocolos()
super(ProtocoloSearchForm, self).update()
def consultarProtocolos(self, data):
r = self.request.response
for campo in [
'tipoprotocolo', 'tipodocumento_id', 'assunto', 'situacao_id',
'origem', 'destino', 'area_id', 'tempo_inativo'
]:
cookie_name = 'search-protocolo-' + campo
if data[campo] is None:
r.expireCookie(cookie_name)
else:
v = data[campo]
# API de cookies do Zope não suporta unicode
if type(v) == type(u''):
v = v.encode('utf-8')
r.setCookie(cookie_name, v)
go('search-protocolo')
@button.buttonAndHandler(_(u'Consultar'), name='consultar')
def handleConsultar(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
self.consultarProtocolos(data)
def updateActions(self):
self.request.set('disable_border', True)
super(ProtocoloSearchForm, self).updateActions()
self.actions["consultar"].addClass("context")
class TramiteRecebimentoProtocoloForm(form.SchemaForm):
"""Formulário de tramitação de recebimento de um protocolo (código de barras).
"""
grok.context(INavigationRoot)
grok.name('recebimento-tramite-barra')
grok.require('zope2.View')
ignoreContext = True
schema = INumeroProtocolo
label = _(u'Tramitação de Protocolos - Recebimento (Código de Barras)')
description = _(
u'Utilize um scanner para efetuar a leitura do código de barras e receber o protocolo.'
)
def update(self):
sc = getUtility(ISecurityChecker)
sc.enforce('acessar_recebimento_tramite_barra')
super(TramiteRecebimentoProtocoloForm, self).update()
def receberProtocolo(self, data):
status = IStatusMessage(self.request)
session = Session()
protocolo = session.query(Protocolo).filter_by(
numero=data['numero']).first()
if protocolo is None:
status.add(
_(u'Verifique o número informado. Protocolo: ' +
data['numero']), 'error')
else:
sc = getUtility(ISecurityChecker)
if not sc.check('tramitar_recebimento', protocolo_id=protocolo.id):
status.add(
_(u'Protocolo não disponível para recebimento. Protocolo: '
) + protocolo.numero, 'error')
else:
api = getUtility(ISPDOAPI)
api.TramiteRecebimento([protocolo.id])
status.add(
_(u'Protocolo recebido com sucesso! Protocolo: ') +
protocolo.numero, 'info')
go('recebimento-tramite-barra')
@button.buttonAndHandler(_(u'Receber'), name='receber')
def handleReceber(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
self.receberProtocolo(data)
def updateActions(self):
self.request.set('disable_border', True)
super(TramiteRecebimentoProtocoloForm, self).updateActions()
self.actions["receber"].addClass("context")
class ITipoEntrega(IBaseFormSchema):
form.mode(id='hidden')
id = schema.Int(
title=_(u'ID'),
description=_(u'Identificador do Tipo de Entrega.'),
required=False)
nome = schema.TextLine(
title=_(u'Nome'),
description=_(u'Informe o nome do tipo do entrega.'))
class TipoDocumentoEditForm(base.EditForm):
"""Formulário de edição de um tipo de documento.
"""
grok.context(INavigationRoot)
grok.name('edit-tipodocumento')
grok.require('cmf.ManagePortal')
schema = ITipoDocumento
klass = TipoDocumento
label = _(u'Editar Tipo de Documento')
descrition = _(u'Formulário de edição de um tipo de documento.')
class FluxoShowForm(base.ShowForm):
"""Formulário de visualização de um fluxo de tramitação.
"""
grok.context(INavigationRoot)
grok.name('show-fluxo')
grok.require('cmf.ManagePortal')
schema = IFluxo
klass = Fluxo
label = _(u'Detalhes do Fluxo')
description = _(u'Formulário de visualização de um fluxo de tramitação.')
class FluxoEditForm(base.EditForm):
"""Formulário de edição de um fluxo de tramitação.
"""
grok.context(INavigationRoot)
grok.name('edit-fluxo')
grok.require('cmf.ManagePortal')
schema = IFluxo
klass = Fluxo
label = _(u'Editar Fluxo')
descrition = _(u'Formulário de edição de um fluxo de tramitação.')
class TipoEntregaShowForm(base.ShowForm):
"""Formulário de visualização de um tipo de entrega.
"""
grok.context(INavigationRoot)
grok.name('show-tipoentrega')
grok.require('cmf.ManagePortal')
schema = ITipoEntrega
klass = TipoEntrega
label = _(u'Detalhes da Tipo de Entrega')
description = _(u'Formulário de visualização de um tipo de entrega.')
class UFShowForm(base.ShowForm):
"""Formulário de visualização de uma UF.
"""
grok.context(INavigationRoot)
grok.name('show-uf')
grok.require('cmf.ManagePortal')
schema = IUF
klass = UF
label = _(u'Detalhes da UF')
description = _(u'Formulário de visualização de uma UF.')
class UFEditForm(base.EditForm):
"""Formulário de edição de uma UF.
"""
grok.context(INavigationRoot)
grok.name('edit-uf')
grok.require('cmf.ManagePortal')
schema = IUF
klass = UF
label = _(u'Editar UF')
descrition = _(u'Formulário de edição de uma UF.')
class TipoEntregaEditForm(base.EditForm):
"""Formulário de edição de um tipo de entrega.
"""
grok.context(INavigationRoot)
grok.name('edit-tipoentrega')
grok.require('cmf.ManagePortal')
schema = ITipoEntrega
klass = TipoEntrega
label = _(u'Editar Tipo de Entrega')
descrition = _(u'Formulário de edição de um tipo de entrega.')
class SituacaoShowForm(base.ShowForm):
"""Formulário de visualização de uma situação.
"""
grok.context(INavigationRoot)
grok.name('show-situacao')
grok.require('cmf.ManagePortal')
schema = ISituacao
klass = Situacao
label = _(u'Detalhes da Situação')
description = _(u'Formulário de visualização de uma situação.')
class SituacaoEditForm(base.EditForm):
"""Formulário de edição de uma situação.
"""
grok.context(INavigationRoot)
grok.name('edit-situacao')
grok.require('cmf.ManagePortal')
schema = ISituacao
klass = Situacao
label = _(u'Editar Situação')
descrition = _(u'Formulário de edição de uma situação.')
def verifyApenso(apenso):
if not apenso.apenso_id:
return
if not apenso.protocolo_id:
raise interface.Invalid(_(u'O parâmetro protocolo_id não foi informado.'))
if apenso.protocolo_id == apenso.apenso_id:
raise interface.Invalid(_(u'O protocolo não pode ser apensado a ele mesmo.'))
sc = getUtility(ISecurityChecker)
if not sc.check('ciclo_apenso', protocolo_id=apenso.protocolo_id, apenso_id=apenso.apenso_id):
raise interface.Invalid(_(u'Ciclo de apensos detectado!'))
if not sc.check('momento_tramitacao', protocolo_id=apenso.protocolo_id, apenso_id=apenso.apenso_id):
raise interface.Invalid(_(u'Para que um protocolo seja apensado em outro é necessário que ambos compartilhem o mesmo momento na tramitação, ou seja, estejam tramitando nas mesmas áreas e tenham o mesmo tipo de documento e protocolo.'))
class TipoDocumentoShowForm(base.ShowForm):
"""Formulário de visualização de um tipo de documento.
"""
grok.context(INavigationRoot)
grok.name('show-tipodocumento')
grok.require('cmf.ManagePortal')
schema = ITipoDocumento
klass = TipoDocumento
label = _(u'Detalhes da Tipo de Documento')
description = _(u'Formulário de visualização de um tipo de documento.')
def receberProtocolo(self, data):
status = IStatusMessage(self.request)
session = Session()
protocolo = session.query(Protocolo).filter_by(numero=data['numero']).first()
if protocolo is None:
status.add(_(u'Verifique o número informado. Protocolo: ' + data['numero']), 'error')
else:
sc = getUtility(ISecurityChecker)
if not sc.check('tramitar_recebimento', protocolo_id=protocolo.id):
status.add(_(u'Protocolo não disponível para recebimento. Protocolo: ') + protocolo.numero, 'error')
else:
api = getUtility(ISPDOAPI)
api.TramiteRecebimento([protocolo.id])
status.add(_(u'Protocolo recebido com sucesso! Protocolo: ') + protocolo.numero, 'info')
go('recebimento-tramite-barra')
def _TramiteRecebimento(self, protocolos, apenso=False):
"""Tramite de recebimento.
"""
protocolos = list(set(protocolos))
session = Session()
area_id_auth = self.getAuthPessoa().area_id
ret = []
for protocolo_id in protocolos:
ret.append(protocolo_id)
protocolo = self.getProtocolo(protocolo_id)
if not apenso:
sc = getUtility(ISecurityChecker)
msg = _(u'Protocolo não disponível para recebimento. Protocolo: ') + protocolo.numero
sc.enforce('tramitar_recebimento', protocolo_id=protocolo_id, msg=msg)
tramite = session.query(db.Tramite).\
filter_by(protocolo_id=protocolo_id).\
filter_by(area_id=area_id_auth).\
filter_by(data_recebimento=None).first()
tramite.data_recebimento=datetime.datetime.now()
self._add_box(db.TramiteInbox, protocolo_id, area_id_auth)
self._del_box(db.TramiteOutbox, protocolo_id, tramite.area_id_anterior)
# propaga tramitação nos apensos
for apenso in protocolo.apenso:
ret.extend(self._TramiteRecebimento([apenso.id], apenso=True))
return ret
def _valida_protocolo_fluxo(self, **kwargs):
"""O tipo de protocolo e o tipo de documento possuem uma
definição de fluxo rigoroso. A tramitação de envio deve seguir
uma transição desse fluxo.
"""
protocolo_id = kwargs.get('protocolo_id', None)
areas = kwargs.get('areas', [])
if protocolo_id is None or not areas:
logger(_(u'O método _valida_protocolo_fluxo não recebeu os parâmetros protocolo_id e areas.'))
return False
api = getUtility(ISPDOAPI)
protocolo = api.getProtocolo(protocolo_id)
if protocolo is None:
return False
tipoprotocolo = protocolo.tipoprotocolo
tipodocumento_id = protocolo.tipodocumento_id
session = Session()
fluxo = session.query(db.Fluxo).\
filter_by(tipoprotocolo=tipoprotocolo).\
filter_by(tipodocumento_id=tipodocumento_id).\
filter_by(flexivel=False).first()
if fluxo is None:
return True
area_id_auth = self._get_area_usuario()
if area_id_auth is None:
return False
for area in areas:
if not bool(session.query(db.Transicao).\
filter_by(fluxo_id=fluxo.id).\
filter_by(area_origem_id=area_id_auth).\
filter_by(area_destino_id=area).first()):
return False
return True
def _valida_protocolo_fluxo_area_inicial(self, **kwargs):
"""O tipo de protocolo e o tipo de documento possuem uma
definição de fluxo rigoroso. A área onde o usuário está lotado
deve corresponder a uma área inicial de uma das transições
desse fluxo.
"""
tipoprotocolo = kwargs.get('tipoprotocolo', None)
tipodocumento_id = kwargs.get('tipodocumento_id', None)
if tipoprotocolo is None or tipodocumento_id is None:
logger(_(u'O método _valida_protocolo_fluxo_area_inicial não recebeu os parâmetros tipoprotocolo e tipodocumento_id.'))
return False
area_id_auth = self._get_area_usuario()
if area_id_auth is None:
return False
session = Session()
fluxo = session.query(db.Fluxo).\
filter_by(tipoprotocolo=tipoprotocolo).\
filter_by(tipodocumento_id=tipodocumento_id).\
filter_by(flexivel=False).first()
if fluxo is None:
return True
return bool(session.query(db.Transicao).\
filter_by(fluxo_id=fluxo.id).\
filter_by(area_origem_id=area_id_auth).\
filter_by(inicial=True).first())
def _TramiteRecuperacao(self, protocolos, apenso=False):
"""Tramite de recuperação (recupera um protocolo enviado que não foi recebido).
"""
protocolos = list(set(protocolos))
session = Session()
area_id_auth = self.getAuthPessoa().area_id
ret = []
for protocolo_id in protocolos:
ret.append(protocolo_id)
protocolo = self.getProtocolo(protocolo_id)
if not apenso:
sc = getUtility(ISecurityChecker)
msg = _(u'Protocolo não disponível para recuperação. Protocolo: ') + protocolo.numero
sc.enforce('tramitar_recuperacao', protocolo_id=protocolo_id, msg=msg)
tramites = session.query(db.Tramite).\
filter_by(protocolo_id=protocolo_id).\
filter_by(area_id_anterior=area_id_auth).\
filter_by(data_recebimento=None).all()
for tramite in tramites:
session.delete(tramite)
self._add_box(db.TramiteInbox, protocolo_id, area_id_auth)
self._del_box(db.TramiteOutbox, protocolo_id, area_id_auth)
# propaga tramitação nos apensos
for apenso in protocolo.apenso:
ret.extend(self._TramiteRecuperacao([apenso.id], apenso=True))
return ret
def render(self):
r = self.request
dados = r.get("dados", "")
if not dados:
return self._json_error(1)
dados = json.loads(dados)
if not self._valida_dados(dados):
return self._json_error(2)
sc = getUtility(ISecurityChecker)
if not sc.check(
"fluxo_rigoroso_area_inicial",
tipoprotocolo=dados["tipoprotocolo"],
tipodocumento_id=self._tipodocumento(dados["tipodocumento"]).id,
):
return self._json_error(3)
anexos = [
NamedFile(r.form[a], filename=unicode(r.form[a].filename, "utf-8"))
for a in r.form.keys()
if a.startswith("anexo")
]
numero, data_protocolo = self._addProtocolo(dados, anexos)
return json.dumps(_("Protocolo: %s de %s" % (numero, str(data_protocolo))))
def _notificaResponsaveis(self, protocolos):
"""Envia email notificando tramitação para a pessoa destino
"""
pu = getToolByName(getSite(), 'portal_url')
portal = pu.getPortalObject()
mh = portal.MailHost
session = Session()
protocolos = list(set(protocolos))
for protocolo_id in protocolos:
protocolo = session.query(db.Protocolo).get(protocolo_id)
# TODO: refatorar. Essa lista de tramites pode vir
# pronta do método TramiteEnvio, evitando notificações
# desnecessárias nas tramitações por cópia.
tramites = session.query(db.Tramite).\
filter_by(protocolo_id=protocolo_id).\
filter_by(data_recebimento=None).all()
for tramite in tramites:
d = {'numero': protocolo.numero,
'data_tramitacao': tramite.data_disponibilizacao,
'assunto': protocolo.assunto,
'area_origem': tramite.area_anterior.nome,
'responsavel_origem': tramite.area_anterior.responsavel[-1].pessoa.nome,
'area_destino': tramite.area.nome,
'responsavel_destino': tramite.responsavel.pessoa.nome,
'situacao': protocolo.situacao.nome,
'despacho': tramite.despacho,
'url_protocolo': url('show-protocolo', id=protocolo.id)}
mfrom = unicode(portal.getProperty('email_from_address'), 'utf-8')
mto = tramite.responsavel.pessoa.email
subject=NOTIFICACAO_OBRIG_ASSUNTO % d
body=NOTIFICACAO_OBRIG_MSG % d
text = u"From: %s\nTo: %s\nSubject: %s\n\n%s" % (mfrom, mto, subject, body)
try:
mh.send(text, immediate=True, charset='utf8')
logger(_(u'Enviou...'))
logger(_(text))
except:
logger(_(u'Erro ao enviar a mensagem de notificação.'))
def render(self):
session = Session()
content = session.query(db.Transicao).get(self.request.id)
fluxo_id = content.fluxo_id
session.delete(content)
session.flush()
status = IStatusMessage(self.request)
status.add(_(u"Registro removido."), "info")
go("list-transicao", fluxo_id=fluxo_id)
def render(self):
session = Session()
r = self.request
content = session.query(db.PessoaDestino).get((r.protocolo_id, r.pessoa_id))
session.delete(content)
session.flush()
status = IStatusMessage(self.request)
status.add(_(u"Registro removido."), "info")
go("show-protocolo", id=r.protocolo_id)
def render(self):
session = Session()
r = self.request
content = session.query(db.PessoaOrigem).get((r.protocolo_id, r.pessoa_id))
session.delete(content)
session.flush()
status = IStatusMessage(self.request)
status.add(_(u'Registro removido.'), 'info')
go('show-protocolo', id=r.protocolo_id)
def render(self):
session = Session()
r = self.request
content = session.query(db.Referencia).get((r.protocolo_id, r.referencia_id))
session.delete(content)
session.flush()
status = IStatusMessage(self.request)
status.add(_(u"Registro removido."), "info")
go("list-referencia", protocolo_id=r.protocolo_id)
def render(self):
session = Session()
api = getUtility(ISPDOAPI)
pessoa_id = api.getAuthPessoa().id
content = session.query(db.Notificacao).get((pessoa_id, self.request.protocolo_id))
session.delete(content)
session.flush()
status = IStatusMessage(self.request)
status.add(_(u"Registro removido."), "info")
go("list-notificacao")
def render(self):
session = Session()
content = session.query(db.Observacao).get(self.request.id)
protocolo_id = content.protocolo_id
sc = getUtility(ISecurityChecker)
sc.enforce("acessar_remove_observacao", protocolo_id=protocolo_id, observacao_id=self.request.id)
session.delete(content)
session.flush()
status = IStatusMessage(self.request)
status.add(_(u"Registro removido."), "info")
go("show-protocolo", id=protocolo_id)
def render(self):
session = Session()
content = session.query(db.Anexo).get(self.request.id)
protocolo_id = content.protocolo_id
sc = getUtility(ISecurityChecker)
sc.enforce('acessar_remove_anexo', protocolo_id=protocolo_id, anexo_id=self.request.id)
session.delete(content)
session.flush()
status = IStatusMessage(self.request)
status.add(_(u'Registro removido.'), 'info')
go('show-protocolo', id=protocolo_id)
def _valida_protocolo_apensado(self, **kwargs):
"""Protocolo não estar apensado em outro protocolo.
"""
api = getUtility(ISPDOAPI)
protocolo_id = kwargs.get('protocolo_id', api.getProtocoloId())
if protocolo_id is None:
logger(_(u'O método _valida_protocolo_apensado não recebeu o parâmetro protocolo_id.'))
return False
protocolo = api.getProtocolo(protocolo_id)
if protocolo is None:
return False
return protocolo.apenso_id is None
def consultarProtocolo(self, data):
status = IStatusMessage(self.request)
session = Session()
query = session.query(db.Protocolo)
clause = or_(db.Protocolo.numero.contains(data['numero']),
db.Protocolo.numero.ilike(data['numero']))
protocolo = query.filter(clause).first()
if protocolo is None:
status.add(_(u'Verifique o número informado. Protocolo: ' + data['numero']), 'error')
go('search-protocolo-barra')
else:
go('show-protocolo', id=protocolo.id)
def _valida_protocolo_situacao_final(self, **kwargs):
"""Protocolo não pode estar em situação final.
"""
api = getUtility(ISPDOAPI)
protocolo_id = kwargs.get('protocolo_id', api.getProtocoloId())
if protocolo_id is None:
logger(_(u'O método _valida_protocolo_situacao_final não recebeu o parâmetro protocolo_id.'))
return False
protocolo = api.getProtocolo(protocolo_id)
if protocolo is None:
return False
return not protocolo.situacao.final
def removeItem(self):
content = self.getContent()
status = IStatusMessage(self.request)
try:
session = Session()
session.delete(content)
session.flush()
except AssertionError, e:
msg = _(u'Falha de integridade relacional: ' + str(e))
status.add(msg, 'error')
logger(msg)
raise
def _menu(self):
sc = getUtility(ISecurityChecker)
protocolo_id = self._protocolo.id
apenso_id = self._protocolo.apenso_id
ret = []
if sc.check('acessar_edit_protocolo', protocolo_id=protocolo_id):
ret.append({'url': url('edit-protocolo', id=protocolo_id),
'titulo': _(u'Atualizar Protocolo'),
'id': 'overlay-edit-protocolo'})
if sc.check('acessar_add_observacao', protocolo_id=protocolo_id):
ret.append({'url': url('add-observacao', protocolo_id=protocolo_id),
'titulo': _(u'Adicionar Observação'),
'class': 'overlay-add-edit-observacao'})
if sc.check('acessar_add_anexo', protocolo_id=protocolo_id):
ret.append({'url': url('add-anexo', protocolo_id=protocolo_id),
'titulo': _(u'Adicionar Anexo')})
if sc.check('acessar_list_referencia', protocolo_id=protocolo_id):
ret.append({'url': url('list-referencia', protocolo_id=protocolo_id),
'titulo': _(u'Referências')})
if sc.check('acessar_add_apenso', protocolo_id=protocolo_id, apenso_id=apenso_id):
ret.append({'url': url('add-apenso', protocolo_id=protocolo_id),
'titulo': _(u'Apenso')})
if sc.check('acessar_add_tramite', protocolo_id=protocolo_id):
ret.append({'url': url('add-tramite', protocolo_id=protocolo_id),
'titulo': _(u'Tramitar')})
return ret
def _valida_protocolo_apenso_ciclo(self, **kwargs):
"""Não podem existir ciclos nas definições de apensos.
"""
protocolo_id = kwargs.get('protocolo_id', None)
apenso_id = kwargs.get('apenso_id', None)
if protocolo_id is None or apenso_id is None:
logger(_(u'O método _valida_protocolo_apenso_ciclo não recebeu os parâmetros protocolo_id ou apenso_id.'))
return False
api = getUtility(ISPDOAPI)
protocolo = api.getProtocolo(protocolo_id)
if protocolo is None:
return False
ids_visitados = []
return not self._procura_ciclo(protocolo, apenso_id, ids_visitados)
def _menu(self):
sc = getUtility(ISecurityChecker)
protocolo_id = self._protocolo.id
apenso_id = self._protocolo.apenso_id
ret = []
if sc.check("acessar_edit_protocolo", protocolo_id=protocolo_id):
ret.append(
{
"url": url("edit-protocolo", id=protocolo_id),
"titulo": _(u"Atualizar Protocolo"),
"id": "overlay-edit-protocolo",
}
)
if sc.check("acessar_add_observacao", protocolo_id=protocolo_id):
ret.append(
{
"url": url("add-observacao", protocolo_id=protocolo_id),
"titulo": _(u"Adicionar Observação"),
"class": "overlay-add-edit-observacao",
}
)
if sc.check("acessar_add_anexo", protocolo_id=protocolo_id):
ret.append({"url": url("add-anexo", protocolo_id=protocolo_id), "titulo": _(u"Adicionar Anexo")})
if sc.check("acessar_list_referencia", protocolo_id=protocolo_id):
ret.append({"url": url("list-referencia", protocolo_id=protocolo_id), "titulo": _(u"Referências")})
if sc.check("acessar_add_apenso", protocolo_id=protocolo_id, apenso_id=apenso_id):
ret.append({"url": url("add-apenso", protocolo_id=protocolo_id), "titulo": _(u"Apenso")})
if sc.check("acessar_add_tramite", protocolo_id=protocolo_id):
ret.append({"url": url("add-tramite", protocolo_id=protocolo_id), "titulo": _(u"Tramitar")})
return ret
def handleCadastrar(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
status = IStatusMessage(self.request)
try:
obj = self.createAndAdd(data)
session = Session()
session.flush()
except IntegrityError, e:
msg = _(u'Falha de integridade relacional: ' + str(e))
status.add(msg, 'error')
logger(msg)
raise
def _valida_protocolo_tramita_area(self, **kwargs):
"""Protocolo tramita na área onde o usuário autenticado está
lotado.
"""
api = getUtility(ISPDOAPI)
protocolo_id = kwargs.get('protocolo_id', api.getProtocoloId())
if protocolo_id is None:
logger(_(u'O método _valida_protocolo_tramita_area não recebeu o parâmetro protocolo_id.'))
return False
area_id_auth = self._get_area_usuario()
if area_id_auth is None:
return False
session = Session()
return bool(session.query(db.TramiteInbox).\
filter_by(protocolo_id=protocolo_id).\
filter_by(area_id=area_id_auth).first())
def _valida_protocolo_nao_recebido(self, **kwargs):
"""Protocolo enviado pela área de lotação do usuário mas ainda
não recebido pela área destino.
"""
api = getUtility(ISPDOAPI)
protocolo_id = kwargs.get('protocolo_id', api.getProtocoloId())
if protocolo_id is None:
logger(_(u'O método _valida_protocolo_nao_recebido não recebeu o parâmetro protocolo_id.'))
return False
area_id_auth = self._get_area_usuario()
if area_id_auth is None:
return False
session = Session()
return bool(session.query(db.TramiteOutbox).\
filter_by(area_id=area_id_auth).\
filter_by(protocolo_id=protocolo_id).first())
def TramiteInicial(self, protocolo_id):
"""Tramite inicial.
"""
session = Session()
area_id_auth = self.getAuthPessoa().area_id
tramite = db.Tramite(
protocolo_id=protocolo_id,
area_id=area_id_auth,
data_disponibilizacao=None,
data_recebimento=datetime.datetime.now(),
despacho=_(u'Protocolo Criado'),
usuario=self.getAuthId(),
)
session.add(tramite)
self._add_box(db.TramiteInbox, protocolo_id, area_id_auth)
session.flush()
def _valida_protocolo_apenso_momento(self, **kwargs):
"""Para que um protocolo seja apensado em outro é necessário
que ambos compartilhem o mesmo momento na tramitação, ou seja,
estejam tramitando nas mesmas áreas e tenham o mesmo tipo de
documento e protocolo.
"""
protocolo_id = kwargs.get('protocolo_id', None)
apenso_id = kwargs.get('apenso_id', None)
if protocolo_id is None or apenso_id is None:
logger(_(u'O método _valida_protocolo_apenso_momento não recebeu os parâmetros protocolo_id ou apenso_id.'))
return False
api = getUtility(ISPDOAPI)
protocolo = api.getProtocolo(protocolo_id)
if protocolo is None:
return False
apenso = api.getProtocolo(apenso_id)
if apenso is None:
return False
return self._compara_protocolos(protocolo, apenso)