Python Session.add方法代码示例

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

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

# 需要导入模块: from il.spdo.config import Session [as 别名]
# 或者: from il.spdo.config.Session import add [as 别名]
 def addObservacao(self, protocolo_id, texto):
     """Adiciona observação.
     """
     if not texto:
         return
     session = Session()
     observacao = db.Observacao(
                  protocolo_id=protocolo_id,
                  texto=texto,
                  usuario=self.getAuthId(),
                  )
     session.add(observacao)
     session.flush()
     return observacao.id

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

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