def update(self):
self.request.set("disable_border", True)
self.dados = []
session = Session()
items = session.query(db.UF).all()
for i in items:
self.dados.append({"id": i.id, "sigla": i.sigla, "nome": i.nome})
def update(self):
self.request.set("disable_border", True)
self.dados = []
session = Session()
items = session.query(db.Situacao).all()
for i in items:
self.dados.append({"id": i.id, "nome": i.nome, "inicial": i.inicial, "final": i.final})
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 _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 _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 _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 _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 _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_privilegio_criador_anexo(self, **kwargs):
"""O anexo deve ter sido criado pelo usuário que quer
apagá-lo. Não deve existir um tramite com data de
disponibilização posterior a data do anexo.
"""
anexo_id = kwargs.get('anexo_id', None)
protocolo_id = kwargs.get('protocolo_id', None)
if anexo_id is None or protocolo_id is None:
logger(
_(u'O método _valida_privilegio_criador_anexo não recebeu os parâmetros anexo_id ou protocolo_id.'
))
return False
session = Session()
api = getUtility(ISPDOAPI)
usuario = api.getAuthId()
anexo = session.query(db.Anexo).\
filter_by(id=anexo_id).\
filter_by(protocolo_id=protocolo_id).\
filter_by(usuario=usuario).first()
if anexo is None:
return False
tramite = session.query(db.Tramite).\
filter_by(protocolo_id=anexo.protocolo_id).\
filter(db.Tramite.data_disponibilizacao > anexo.data_anexo).first()
return not bool(tramite)
def _valida_privilegio_criador_observacao(self, **kwargs):
"""A observação deve ter sido criada pelo usuário que quer
modificá-la ou apagá-la. Não deve existir um tramite com data
de disponibilização posterior a data da observação.
"""
observacao_id = kwargs.get('observacao_id', None)
protocolo_id = kwargs.get('protocolo_id', None)
if observacao_id is None or protocolo_id is None:
logger(
_(u'O método _valida_privilegio_criador_observacao não recebeu os parâmetros observacao_id ou protocolo_id.'
))
return False
session = Session()
api = getUtility(ISPDOAPI)
usuario = api.getAuthId()
observacao = session.query(db.Observacao).\
filter_by(id=observacao_id).\
filter_by(protocolo_id=protocolo_id).\
filter_by(usuario=usuario).first()
if observacao is None:
return False
tramite = session.query(db.Tramite).\
filter_by(protocolo_id=observacao.protocolo_id).\
filter(db.Tramite.data_disponibilizacao > observacao.data_observacao).first()
return not bool(tramite)
def getFluxo(self, id=None):
"""Retorna o objeto Fluxo a partir do ID.
"""
session = Session()
if id is None:
id = self.getFluxoId()
return session.query(db.Fluxo).get(id)
def getFluxo(self, id=None):
"""Retorna o objeto Fluxo a partir do ID.
"""
session = Session()
if id is None:
id = self.getFluxoId()
return session.query(db.Fluxo).get(id)
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 addAnexos(self, protocolo_id, anexos):
"""Adiciona anexos.
"""
p = self.getProtocolo(protocolo_id)
if p is None or anexos is None:
return []
session = Session()
path_protocolo = os.path.join(PATH_ANEXOS, ScopeID(), str(p.ano), str(p.id))
if not os.path.exists(path_protocolo):
os.makedirs(path_protocolo, 0700)
ret = []
for arquivo in anexos:
anexo = db.Anexo(
protocolo_id=protocolo_id,
arquivo=arquivo.filename,
tamanho=arquivo.getSize(),
usuario=self.getAuthId(),
)
session.add(anexo)
session.flush()
ret.append(anexo.id)
path_anexo = os.path.join(path_protocolo, str(anexo.id))
with open(path_anexo, 'w') as file_anexo:
file_anexo.write(arquivo.data)
# propaga anexos nos apensos
for apenso in p.apenso:
ret.extend(self.addAnexos(apenso.id, anexos))
return ret
def _valida_dados(self, dados):
"""
Valida o parâmetro 'dados', que deve ser uma estrutura como a demonstrada a seguir:
import json
dados = {'origem': 'Nome da Pessoa de Origem',
'destino': 'Nome da Pessoa de Destino',
'assunto': 'Assunto...',
'situacao': 'Tramitando',
'tipodocumento': 'Carta',
'tipoprotocolo': 'E',
'inativo': '4',
'area': 'Comissão'}
print json.dumps(dados)
"""
# dados precisa ser um dicionário
if not isinstance(dados, dict):
return False
# os valores de “situacao”, “tipodocumento” e ”area” devem estar cadastrados
if dados.get('situacao', None):
session = Session()
if not session.query(db.Situacao).filter_by(nome=dados.get('situacao')).filter_by(inicial=True).first():
return False
if dados.get('tipodocumento', None):
if not self._tipodocumento(dados.get('tipodocumento')):
return False
if dados.get('area', None):
if not self._area(dados.get('area')):
return False
return True
def createAndAdd(self, data):
uf = UF()
uf.sigla = data['sigla']
uf.nome = data['nome']
session = Session()
session.add(uf)
session.flush()
def _tramite(self, dados, apenso=False):
protocolo_id = self._protocolo(dados['protocolo']).id
area_id = self._area(dados['area']).id
session = Session()
area_id_auth = self.api.getAuthPessoa().area_id
copia = len([area_id]) > 1
ret = []
ret.append(protocolo_id)
protocolo = self.api.getProtocolo(protocolo_id)
tramite = db.Tramite(
protocolo_id=protocolo_id,
area_id=area_id,
data_disponibilizacao=datetime.datetime.now(),
data_recebimento=None,
despacho=dados['despacho'],
usuario=self.api.getAuthId(),
copia=copia,
area_id_anterior=area_id_auth,
)
session.add(tramite)
self.api._add_box(db.TramiteOutbox, protocolo_id, area_id_auth)
self.api._del_box(db.TramiteInbox, protocolo_id, area_id_auth)
session.flush()
# propaga tramitação nos apensos
for apenso in protocolo.apenso:
ret.extend(self._tramite([apenso.id], area_id, dados['despacho'], apenso=True))
return ret
def getProtocolo(self, id=None):
"""Retorna o objeto Protocolo a partir do ID.
"""
session = Session()
if id is None:
id = self.getProtocoloId()
return session.query(db.Protocolo).get(id)
def getProtocolo(self, id=None):
"""Retorna o objeto Protocolo a partir do ID.
"""
session = Session()
if id is None:
id = self.getProtocoloId()
return session.query(db.Protocolo).get(id)
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 _valida_dados(self, dados):
"""
Valida o parâmetro 'dados', que deve ser uma estrutura como a demonstrada a seguir:
import json
dados = {'origem': 'Nome da Pessoa de Origem',
'destino': 'Nome da Pessoa de Destino',
'assunto': 'Assunto...',
'situacao': 'Tramitando',
'tipodocumento': 'Carta',
'tipoprotocolo': 'E',
'inativo': '4',
'area': 'Comissão'}
print json.dumps(dados)
"""
# dados precisa ser um dicionário
if not isinstance(dados, dict):
return False
# os valores de “situacao”, “tipodocumento” e ”area” devem estar cadastrados
if dados.get('situacao', None):
session = Session()
if not session.query(db.Situacao).filter_by(
nome=dados.get('situacao')).filter_by(
inicial=True).first():
return False
if dados.get('tipodocumento', None):
if not self._tipodocumento(dados.get('tipodocumento')):
return False
if dados.get('area', None):
if not self._area(dados.get('area')):
return False
return True
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 createAndAdd(self, data):
responsavel = Responsavel()
responsavel.area_id = data['area_id']
responsavel.pessoa_id = data['pessoa_id']
responsavel.data_responsavel = data['data_responsavel']
session = Session()
session.add(responsavel)
session.flush()
def doDeleteUser(self, userid):
"""Apaga o usuário removendo a pessoa do banco de dados. Se
alguma integridade referencial não for respeitada será lançada
uma exceção."""
api = getUtility(ISPDOAPI)
pessoa = api.getPessoaByEmail(userid)
session = Session()
session.delete(pessoa)
def _create_and_add(self, dados):
session = Session()
protocolo = session.query(
db.Protocolo).filter_by(numero=dados['protocolo']).first()
for numero in dados['apensos']:
apenso = session.query(
db.Protocolo).filter_by(numero=numero).first()
protocolo.apenso_id = apenso.id
def render(self):
self.dados = []
session = Session()
items = session.query(db.Pessoa).order_by(db.Pessoa.nome).all()
for i in items:
self.dados.append({'email': i.email, 'nome': i.nome})
return json.dumps(self.dados)
def createAndAdd(self, data):
situacao = Situacao()
situacao.nome = data["nome"]
situacao.inicial = data["inicial"]
situacao.final = data["final"]
session = Session()
session.add(situacao)
session.flush()
def doDeleteUser(self, userid):
"""Apaga o usuário removendo a pessoa do banco de dados. Se
alguma integridade referencial não for respeitada será lançada
uma exceção."""
api = getUtility(ISPDOAPI)
pessoa = api.getPessoaByEmail(userid)
session = Session()
session.delete(pessoa)
def createAndAdd(self, data):
area = Area()
area.sigla = data["sigla"]
area.nome = data["nome"]
area.chefia_id = data["chefia_id"]
session = Session()
session.add(area)
session.flush()
return area
def update(self):
sc = getUtility(ISecurityChecker)
sc.enforce("acessar_list_pessoa")
self.request.set("disable_border", True)
self.dados = []
session = Session()
items = session.query(db.Pessoa).all()
for i in items:
self.dados.append({"id": i.id, "nome": i.nome, "email": i.email})
def createAndAdd(self, data):
fluxo = Fluxo()
fluxo.nome = data['nome']
fluxo.tipoprotocolo = data['tipoprotocolo']
fluxo.tipodocumento_id = data['tipodocumento_id']
fluxo.flexivel = data['flexivel']
session = Session()
session.add(fluxo)
session.flush()
def update(self):
self.request.set('disable_border', True)
self.dados = []
session = Session()
items = session.query(db.TipoEntrega).all()
for i in items:
self.dados.append({
'id': i.id,
'nome': i.nome,
})
def render(self):
session = Session()
anexo = session.query(db.Anexo).get(self.request.id)
p = anexo.protocolo
path_anexo = os.path.join(PATH_ANEXOS, ScopeID(), str(p.ano), str(p.id), str(anexo.id))
file_anexo = NamedFile(open(path_anexo, "r"), filename=anexo.arquivo)
cd = 'inline; filename="%s"' % anexo.arquivo.encode("utf-8")
self.request.response.setHeader("Content-Disposition", cd)
set_headers(file_anexo, self.request.response)
return stream_data(file_anexo)
def update(self):
self.request.set('disable_border', True)
self.dados = []
session = Session()
items = session.query(db.TipoEntrega).all()
for i in items:
self.dados.append({
'id': i.id,
'nome': i.nome,
})
def render(self):
session = Session()
anexo = session.query(db.Anexo).get(self.request.id)
p = anexo.protocolo
path_anexo = os.path.join(PATH_ANEXOS, ScopeID(), str(p.ano), str(p.id), str(anexo.id))
file_anexo = NamedFile(open(path_anexo, 'r'), filename=anexo.arquivo)
cd = 'inline; filename="%s"' % anexo.arquivo.encode('utf-8')
self.request.response.setHeader('Content-Disposition', cd)
set_headers(file_anexo, self.request.response)
return stream_data(file_anexo)
def render(self):
self.dados = []
session = Session()
items = session.query(db.TipoDocumento).all()
for i in items:
self.dados.append({
'id': i.id,
'nome': i.nome,
})
return json.dumps(self.dados)
def _add_box(self, box, protocolo_id, area_id):
assert(box in (db.TramiteInbox, db.TramiteOutbox))
session = Session()
t = session.query(box).get((protocolo_id, area_id))
if t is None:
t = box()
t.protocolo_id=protocolo_id
t.area_id=area_id
tbl = box is db.TramiteInbox and 'tramite_inbox' or 'tramite_outbox'
t.version = db.nextVersion(tbl, protocolo_id=protocolo_id, area_id=area_id)
session.add(t)
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 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 render(self):
self.dados = []
session = Session()
items = session.query(db.TipoDocumento).all()
for i in items:
self.dados.append({
'id': i.id,
'nome': i.nome,
})
return json.dumps(self.dados)
def render(self):
self.dados = []
session = Session()
items = session.query(db.Pessoa).order_by(db.Pessoa.nome).all()
for i in items:
self.dados.append({
'email': i.email,
'nome': i.nome
})
return json.dumps(self.dados)
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 getProtocolosEnviados(self):
"""Consulta os protocolos enviados pela área.
"""
session = Session()
area_id_auth = self.getAuthPessoa().area_id
items = session.query(db.TramiteOutbox).\
filter_by(area_id=area_id_auth).\
join(db.Protocolo).\
filter(db.Protocolo.apenso_id == None).\
join(db.Situacao).\
filter(db.Situacao.final == False).all()
return self._getProtocolosData([i.protocolo for i in items])
def pesquisaProtocolos(self):
"""Pesquisa protocolos.
"""
session = Session()
items = session.query(db.Protocolo)
tipoprotocolo = getTipoProtocolo()
if tipoprotocolo is not None:
items = items.filter_by(tipoprotocolo=tipoprotocolo)
tipodocumento_id = getTipoDocumento()
if tipodocumento_id is not None:
items = items.filter_by(tipodocumento_id=tipodocumento_id)
assunto = getAssunto()
if assunto is not None:
clause = rdb.or_(db.Protocolo.assunto.contains(assunto),
db.Protocolo.assunto.ilike(assunto))
items = items.filter(clause)
situacao_id = getSituacao()
if situacao_id is not None:
items = items.filter_by(situacao_id=situacao_id)
origem = getOrigem()
if origem is not None:
pessoa1 = aliased(db.Pessoa)
items = items.join(db.PessoaOrigem).join(pessoa1)
clause = rdb.or_(pessoa1.nome.contains(origem),
pessoa1.nome.ilike(origem))
items = items.filter(clause)
destino = getDestino()
if destino is not None:
pessoa2 = aliased(db.Pessoa)
items = items.join(db.PessoaDestino).join(pessoa2)
clause = rdb.or_(pessoa2.nome.contains(destino),
pessoa2.nome.ilike(destino))
items = items.filter(clause)
area_id = getArea()
if area_id is not None:
inbox1 = aliased(db.TramiteInbox)
items = items.join(inbox1).filter_by(area_id=area_id)
tempo_inativo = getTempoInativo()
if tempo_inativo is not None:
d = datetime.datetime.now() - datetime.timedelta(
days=tempo_inativo)
inbox2 = aliased(db.TramiteInbox)
items = items.join(inbox2).filter(inbox2.version_date < d)
return self._getProtocolosData(items.limit(SEARCH_LIMIT).all())
def update(self):
self.request.set('disable_border', True)
self.dados = []
session = Session()
items = session.query(db.Situacao).all()
for i in items:
self.dados.append({
'id': i.id,
'nome': i.nome,
'inicial': i.inicial,
'final': i.final,
})
def update(self):
self.request.set('disable_border', True)
self.dados = []
session = Session()
items = session.query(db.Situacao).all()
for i in items:
self.dados.append({
'id': i.id,
'nome': i.nome,
'inicial': i.inicial,
'final': i.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 getProtocolosEnviados(self):
"""Consulta os protocolos enviados pela área.
"""
session = Session()
area_id_auth = self.getAuthPessoa().area_id
items = session.query(db.TramiteOutbox).\
filter_by(area_id=area_id_auth).\
join(db.Protocolo).\
filter(db.Protocolo.apenso_id == None).\
join(db.Situacao).\
filter(db.Situacao.final == False).all()
return self._getProtocolosData([i.protocolo for i in items])
def pesquisaProtocolos(self):
"""Pesquisa protocolos.
"""
session = Session()
items = session.query(db.Protocolo)
tipoprotocolo = getTipoProtocolo()
if tipoprotocolo is not None:
items = items.filter_by(tipoprotocolo=tipoprotocolo)
tipodocumento_id = getTipoDocumento()
if tipodocumento_id is not None:
items = items.filter_by(tipodocumento_id=tipodocumento_id)
assunto = getAssunto()
if assunto is not None:
clause = rdb.or_(db.Protocolo.assunto.contains(assunto),
db.Protocolo.assunto.ilike(assunto))
items = items.filter(clause)
situacao_id = getSituacao()
if situacao_id is not None:
items = items.filter_by(situacao_id=situacao_id)
origem = getOrigem()
if origem is not None:
pessoa1 = aliased(db.Pessoa)
items = items.join(db.PessoaOrigem).join(pessoa1)
clause = rdb.or_(pessoa1.nome.contains(origem),
pessoa1.nome.ilike(origem))
items = items.filter(clause)
destino = getDestino()
if destino is not None:
pessoa2 = aliased(db.Pessoa)
items = items.join(db.PessoaDestino).join(pessoa2)
clause = rdb.or_(pessoa2.nome.contains(destino),
pessoa2.nome.ilike(destino))
items = items.filter(clause)
area_id = getArea()
if area_id is not None:
inbox1 = aliased(db.TramiteInbox)
items = items.join(inbox1).filter_by(area_id=area_id)
tempo_inativo = getTempoInativo()
if tempo_inativo is not None:
d = datetime.datetime.now() - datetime.timedelta(days=tempo_inativo)
inbox2 = aliased(db.TramiteInbox)
items = items.join(inbox2).filter(inbox2.version_date < d)
return self._getProtocolosData(items.limit(SEARCH_LIMIT).all())
def render(self):
self.dados = []
session = Session()
items = session.query(db.Situacao).all()
for i in items:
self.dados.append({
'id': i.id,
'nome': i.nome,
'inicial': i.inicial,
'final': i.final,
})
return json.dumps(self.dados)
def _add_box(self, box, protocolo_id, area_id):
assert (box in (db.TramiteInbox, db.TramiteOutbox))
session = Session()
t = session.query(box).get((protocolo_id, area_id))
if t is None:
t = box()
t.protocolo_id = protocolo_id
t.area_id = area_id
tbl = box is db.TramiteInbox and 'tramite_inbox' or 'tramite_outbox'
t.version = db.nextVersion(tbl,
protocolo_id=protocolo_id,
area_id=area_id)
session.add(t)
def update(self):
sc = getUtility(ISecurityChecker)
sc.enforce('acessar_list_pessoa')
self.request.set('disable_border', True)
self.dados = []
session = Session()
items = session.query(db.Pessoa).all()
for i in items:
self.dados.append({
'id': i.id,
'nome': i.nome,
'email': i.email,
})
def update(self):
self.request.set('disable_border', True)
self.dados = []
session = Session()
items = session.query(db.Area).all()
for i in items:
self.dados.append({
'id': i.id,
'sigla': i.sigla,
'nome': i.nome,
'chefia_id': i.chefia_id,
'chefia_sigla': getattr(i.area,'sigla',''),
'chefia_nome': getattr(i.area,'nome',''),
})
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 update(self):
self.request.set('disable_border', True)
self.dados = []
session = Session()
items = session.query(db.Fluxo).all()
for i in items:
self.dados.append({
'id': i.id,
'nome': i.nome,
'tipoprotocolo': self._tipo_protocolo(i.tipoprotocolo),
'tipodocumento': i.tipodocumento.nome,
'flexivel': i.flexivel,
'url-transicao': url('list-transicao', fluxo_id=i.id),
})
def f(*args, **kwargs):
ret = fn(*args, **kwargs)
l = Log()
request = getRequest()
l.usuario = str(request.other.get('AUTHENTICATED_USER', 'Anonymous'))
l.url = request.other.get('ACTUAL_URL')
l.modulo = fn.__module__
l.classe = args[0].__class__.__name__
l.funcao = fn.__name__
l.args = repr(list(args)[1:])
l.kwargs = repr(kwargs)
session = Session()
session.add(l)
return ret
def _addProtocolo(self, dados, anexos=[]):
session = Session()
api = getUtility(ISPDOAPI)
# origens (e destinos)
pessoas_origens = []
pessoas_destinos = []
for f in ('origens', 'destinos'):
for origem in dados[f]:
pessoa = session.query(
db.Pessoa).filter_by(email=origem['email']).first()
if not pessoa:
pessoa = db.Pessoa(origem['nome'], origem['email'])
session.add(pessoa)
session.flush()
if f == 'origens':
pessoas_origens.append(pessoa.id)
else:
pessoas_destinos.append(pessoa.id)
# "situacao" e "tipodocumento"
situacao = session.query(db.Situacao).filter_by(
nome=dados.get('situacao')).filter_by(inicial=True).first()
tipodocumento = self._tipodocumento(dados.get('tipodocumento'))
# data de emissão
dt = dados.get('data_emissao')
if dt:
aaaa, mm, dd = dt.split('-')
aaaa = int(aaaa)
mm = int(mm)
dd = int(dd)
dt = datetime.date(aaaa, mm, dd)
else:
dt = None
# cria protocolo, observacao, anexos e tramite inicial, utilizando a API
# IMPORTANTE: Por definição, exceto na criação dos protocolos,
# os anexos e as observações são sempre adicionadas ANTES da
# tramitação ocorrer.
protocolo_id = api.addProtocolo(dados['tipoprotocolo'],
tipodocumento.id,
dados['numero_documento'], dt,
dados['assunto'], situacao.id,
pessoas_origens, pessoas_destinos)
api.TramiteInicial(protocolo_id)
if dados['observacao'].strip():
api.addObservacao(protocolo_id, dados['observacao'])
if anexos:
api.addAnexos(protocolo_id, anexos)
protocolo = api.getProtocolo(protocolo_id)
return protocolo.numero, protocolo.data_protocolo
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 render(self):
self.dados = []
session = Session()
items = session.query(db.Area).all()
for i in items:
self.dados.append({
'id': i.id,
'sigla': i.sigla,
'nome': i.nome,
'chefia_id': i.chefia_id,
'chefia_sigla': getattr(i.area, ' sigla', ''),
'chefia_nome': getattr(i.area, 'nome', ''),
})
return json.dumps(self.dados)
