Python Session.flush方法代码示例

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

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import flush [as 别名]
 def createAndAdd(self, data):
     uf = UF()
     uf.sigla = data['sigla']
     uf.nome = data['nome']
     session = Session()
     session.add(uf)
     session.flush()

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import flush [as 别名]
 def addProtocolo(self, tipoprotocolo, tipodocumento_id, numero_documento, data_emissao, assunto, situacao_id, origem, destino, **kwargs):
     """Adiciona protocolo.
     """
     session = Session()
     protocolo = db.Protocolo(
                 tipoprotocolo=tipoprotocolo,
                 tipodocumento_id=tipodocumento_id,
                 numero_documento=numero_documento,
                 data_emissao=data_emissao,
                 assunto=assunto,
                 situacao_id=situacao_id,
                 usuario=self.getAuthId(),
                 )
     session.add(protocolo)
     session.flush()
     protocolo_id = protocolo.id
     for pessoa_id in origem:
         pessoa_origem = db.PessoaOrigem(
                         protocolo_id=protocolo_id,
                         pessoa_id=pessoa_id,
                         )
         session.add(pessoa_origem)
     for pessoa_id in destino:
         pessoa_destino = db.PessoaDestino(
                          protocolo_id=protocolo_id,
                          pessoa_id=pessoa_id,
                          )
         session.add(pessoa_destino)
     session.flush()
     return protocolo_id

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

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

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

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

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

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

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

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

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import flush [as 别名]
 def createAndAdd(self, data):
     api = getUtility(ISPDOAPI)
     protocolo_id = api.getProtocoloId()
     session = Session()
     for i in data['referencia_id']:
         # garante que o protocolo não faz referência para ele mesmo
         if protocolo_id == i:
             continue
         referencia = Referencia()
         referencia.protocolo_id = protocolo_id
         referencia.referencia_id = i
         referencia.version = nextVersion('referencia', protocolo_id=protocolo_id, referencia_id=i)
         session.add(referencia)
     session.flush()