Python Session.query方法代码示例

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
 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

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
 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())

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
    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

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
    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

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
 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

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
 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)

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
 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

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
 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})

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
 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)

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
 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.'))

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
 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)

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
 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)

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
 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,
            })

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
    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)

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import query [as 别名]
 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)