Esempio n. 1
0
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)
Esempio n. 2
0
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.'))
Esempio n. 3
0
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)
Esempio n. 4
0
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)
Esempio n. 5
0
 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])
Esempio n. 6
0
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)
Esempio n. 7
0
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)
Esempio n. 8
0
    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.'))
Esempio n. 9
0
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')
Esempio n. 10
0
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)
Esempio n. 11
0
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')
Esempio n. 12
0
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)
Esempio n. 13
0
 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])
Esempio n. 14
0
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'))
Esempio n. 15
0
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())
Esempio n. 16
0
 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.'))
Esempio n. 17
0
 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.'))
Esempio n. 18
0
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")
Esempio n. 19
0
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")
Esempio n. 20
0
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.'))
Esempio n. 21
0
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.')
Esempio n. 22
0
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.')
Esempio n. 23
0
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.')
Esempio n. 24
0
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.')
Esempio n. 25
0
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.')
Esempio n. 26
0
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.')
Esempio n. 27
0
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.')
Esempio n. 28
0
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.')
Esempio n. 29
0
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.')
Esempio n. 30
0
 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.'))
Esempio n. 31
0
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.')
Esempio n. 32
0
 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')
Esempio n. 33
0
 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
Esempio n. 34
0
 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
Esempio n. 35
0
 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())
Esempio n. 36
0
 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
Esempio n. 37
0
    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))))
Esempio n. 38
0
 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.'))
Esempio n. 39
0
 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)
Esempio n. 40
0
 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)
Esempio n. 41
0
 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)
Esempio n. 42
0
 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)
Esempio n. 43
0
 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")
Esempio n. 44
0
 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)
Esempio n. 45
0
 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)
Esempio n. 46
0
 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
Esempio n. 47
0
 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)
Esempio n. 48
0
 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
Esempio n. 49
0
 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
Esempio n. 50
0
    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
Esempio n. 51
0
 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)
Esempio n. 52
0
    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
Esempio n. 53
0
 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
Esempio n. 54
0
 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())
Esempio n. 55
0
 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())
Esempio n. 56
0
 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()
Esempio n. 57
0
 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)