Python config.Session类代码示例

 def _TramiteRecebimento(self, protocolos, apenso=False):
     """Tramite de recebimento.
     """
     protocolos = list(set(protocolos))
     session = Session()
     area_id_auth = self.getAuthPessoa().area_id
     ret = []
     for protocolo_id in protocolos:
         ret.append(protocolo_id)
         protocolo = self.getProtocolo(protocolo_id)
         if not apenso:
             sc = getUtility(ISecurityChecker)
             msg = _(u'Protocolo não disponível para recebimento. Protocolo: ') + protocolo.numero
             sc.enforce('tramitar_recebimento', protocolo_id=protocolo_id, msg=msg)
         tramite = session.query(db.Tramite).\
                   filter_by(protocolo_id=protocolo_id).\
                   filter_by(area_id=area_id_auth).\
                   filter_by(data_recebimento=None).first()
         tramite.data_recebimento=datetime.datetime.now()
         self._add_box(db.TramiteInbox, protocolo_id, area_id_auth)
         self._del_box(db.TramiteOutbox, protocolo_id, tramite.area_id_anterior)
         # propaga tramitação nos apensos
         for apenso in protocolo.apenso:
             ret.extend(self._TramiteRecebimento([apenso.id], apenso=True))
     return ret

 def _valida_protocolo_fluxo_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 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 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 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 _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 _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 createAndAdd(self, data):
     uf = UF()
     uf.sigla = data['sigla']
     uf.nome = data['nome']
     session = Session()
     session.add(uf)
     session.flush()

 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 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 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 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