Python base_models.DBSession类代码示例

def save():
    print('{line} -> {ip} {forwarder} {is_send} {mti} {bits}'.format(
        line=r_log.line, ip=ip, forwarder=forwarder, is_send=is_send, mti=mti,
        bits=bits))
    r_iso = Iso()
    r_iso.id = conf.nilai_int = r_log.id
    r_iso.tgl = r_log.tgl
    r_iso.jenis_id = r_log.jenis_id
    r_iso.kategori_id = r_log.kategori_id
    r_iso.ip = ip
    r_iso.forwarder = forwarder
    r_iso.is_send = is_send
    r_iso.mti = mti
    for key in bits:
        value = bits[key]
        n = str(key).zfill(3)
        fieldname = 'bit_{n}'.format(n=n)
        setattr(r_iso, fieldname, value)
    DBSession.add(r_iso)
    conf.updated = create_now()
    DBSession.add(conf)
    try:
        DBSession.flush()
    except IntegrityError as err:
        s_err = str(err)
        if s_err.find('duplicate key') > -1:
            print('  sudah ada')
            DBSession.rollback()
        else:
            raise(err)
    DBSession.commit()

 def create_payment(self, inq):
     pay, urutan = self.sismiop_create_payment(inq)
     d = pay.to_dict()
     prefix_ntp = '' 
     for fieldname in PREFIX_NTP_FIELDS: 
         prefix_ntp += d[fieldname] or '00'
     ntp = query.create_ntp(prefix_ntp)
     iso_pay = models.Payment(id=ntp)
     iso_pay.inquiry_id = inq.id
     iso_pay.propinsi = inq.propinsi
     iso_pay.kabupaten = inq.kabupaten
     iso_pay.kecamatan = inq.kecamatan
     iso_pay.kelurahan = inq.kelurahan
     iso_pay.blok = inq.blok
     iso_pay.urut = inq.urut
     iso_pay.jenis = inq.jenis
     iso_pay.tahun = inq.tahun
     iso_pay.ke = urutan
     iso_pay.kd_kanwil_bank = pay.kd_kanwil
     iso_pay.kd_kppbb_bank = pay.kd_kantor
     iso_pay.kd_bank_tunggal = '00'
     iso_pay.kd_bank_persepsi = '00'
     iso_pay.kd_tp = pay.kd_tp
     #iso_pay.channel = self.parent.from_iso.get_channel()
     iso_pay.ntb = self.parent.from_iso.get_ntb()
     iso_pay.iso_request = self.parent.from_iso.raw
     DBSession.add(iso_pay)
     DBSession.flush()
     self.set_ntp(ntp)

 def inquiry_request_handler(self):
     try:
         self.save_request_log()
         self._inquiry_request_handler()
         self.save_response_log()
         DBSession.commit()
     except:
         self.ack_unknown()

 def set_unpaid(self):
     pay = Reversal.set_unpaid(self)
     if not pay:
         q = DBSession.query(self.models.Payment).filter_by(
             propinsi=self.invoice.kd_propinsi,
             kabupaten=self.invoice.kd_dati2,
             kecamatan=self.invoice.kd_kecamatan,
             kelurahan=self.invoice.kd_kelurahan,
             blok=self.invoice.kd_blok,
             urut=self.invoice.no_urut,
             jenis=self.invoice.kd_jns_op,
             tahun=self.invoice.thn_pajak_sppt)
         q.delete()
     DBSession.commit()

 def show(self, option):
     sample_count = int(option.sample_count)
     q = DBSession.query(self.models.Invoice).filter_by(
             status_pembayaran_sppt='0')
     if option.min:
         n = int(option.min)
         q = q.filter(self.models.Invoice.pbb_yg_harus_dibayar_sppt >= n)
     if option.max:
         n = int(option.max)
         q = q.filter(self.models.Invoice.pbb_yg_harus_dibayar_sppt <= n)
     if option.tahun:
         q = q.filter(self.models.Invoice.thn_pajak_sppt == option.tahun)
     offset = -1
     count = 0
     while True:
         if count >= sample_count:
             break
         offset += 1
         row = q.offset(offset).first()
         if not row:
             break
         calc = CalculateInvoice(
                 self.models, DBSession, self.persen_denda, row.kd_propinsi,
                 row.kd_dati2, row.kd_kecamatan, row.kd_kelurahan,
                 row.kd_blok, row.no_urut, row.kd_jns_op,
                 row.thn_pajak_sppt)
         if calc.total < 1:
             continue
         count += 1
         invoice_id_raw = sppt2nop(calc.invoice) + \
             calc.invoice.thn_pajak_sppt
         msg = '#{no}/{count} {id} Rp {total}'.format(
                 no=count, id=invoice_id_raw, total=calc.total,
                 count=sample_count)
         print(msg)

 def _payment_request_handler(self):
     inv = self.get_invoice()
     if not inv:
         return
     if self.calc.total != self.get_amount():
         return self.ack_insufficient_fund()
     s_channel_id = self.from_iso.get_channel_id()
     channel_id = int(s_channel_id)
     q = DBSession.query(models.Channel).filter_by(id=channel_id)
     channel = q.first()
     if channel:
         channel_name = channel.nama
     else:
         channel_name = s_channel_id
     pay = self.calc.query_payment(inv).first()
     pay.date_bayar = pay.time_bayar = self.from_iso.get_transaction_datetime()
     pay.cara_bayar = 'Transfer'
     pay.ref_bayar = self.from_iso.get_ntb()
     pay.nominal = self.calc.total - self.calc.denda
     pay.denda = self.calc.denda
     pay.jum_bayar = self.calc.total
     pay.denda_masaberlaku = self.calc.bulan
     pay.is_bayar = 1
     pay.status_pembayaran = 'Lunas'
     pay.pembayaran_melalui = channel_name
     OtherDBSession.add(pay)
     OtherDBSession.flush()
     self.save_iso_payment(pay)
     self.commit()

 def show(self, option):
     sample_count = int(option.sample_count)
     q = DBSession.query(models.Invoice).filter(models.Invoice.kode_bayar != None).\
               filter(models.Invoice.kode_bayar != '')
     if option.min:
         n = int(option.min)
         q = q.filter(models.Invoice.nominal >= n)
     if option.max:
         n = int(option.max)
         q = q.filter(models.Invoice.nominal <= n)
     q = q.order_by(models.Invoice.nominal)
     offset = -1
     count = 0
     print('START *************')
     while True:
         if count >= sample_count:
             break
         offset += 1
         row = q.offset(offset).first()
         if not row:
             break
         calc = CalculateInvoice(models, DBSession, row.kode_bayar)
         if calc.invoice and calc.paid:
             continue
         count += 1
         msg = '#{no}/{count} {id} Rp {total}'.format(no=count,
                 id=row.kode_bayar, total=calc.tagihan, count=sample_count)
         print(msg)
     print('SELESAI *************')

 def show(self, option):
     sample_count = int(option.sample_count)
     q = DBSession.query(models.Invoice).filter_by(status_bayar=0)
     if option.min:
         n = int(option.min)
         q = q.filter(models.Invoice.jml_tagihan >= n)
     if option.max:
         n = int(option.max)
         q = q.filter(models.Invoice.jml_tagihan <= n)
     q = q.order_by(models.Invoice.jml_tagihan)
     offset = -1
     count = 0
     while True:
         if count >= sample_count:
             break
         offset += 1
         row = q.offset(offset).first()
         if not row:
             break
         calc = CalculateInvoice(models, DBSession, row.no_tagihan)
         if calc.tagihan < 1:
             continue
         count += 1
         msg = '#{no}/{count} {id} Rp {total}'.format(no=count,
                 id=row.no_tagihan, total=calc.tagihan, count=sample_count)
         print(msg)

 def show(self, option):
     sample_count = int(option.sample_count)
     q = DBSession.query(models.Invoice).filter_by(
             status_pembayaran=0).filter(
             models.Invoice.bphtb_harus_dibayarkan > 0)
     offset = -1
     count = 0
     while True:
         if count >= sample_count:
             break
         offset += 1
         row = q.offset(offset).first()
         if not row:
             break
         invoice_id = FixLength(self.get_invoice_id_structure())
         invoice_id['Tahun'] = row.tahun
         invoice_id['Kode'] = row.kode
         invoice_id['SSPD No'] = row.no_sspd
         calc = CalculateInvoice(
                 models, DBSession, invoice_id, persen_denda)
         if calc.total < 1:
             continue
         count += 1
         invoice_id_raw = invoice_id.get_raw()
         self.on_print(option, count, invoice_id_raw, calc)

 def __init__(self, invoice_id_raw):
     Query.__init__(self, models, DBSession)
     self.invoice_id = FixLength(INVOICE_ID)
     self.invoice_id.set_raw(invoice_id_raw)
     q = self.query_invoice(self.invoice_id['Propinsi'],
             self.invoice_id['Kabupaten'], self.invoice_id['Kecamatan'],
             self.invoice_id['Kelurahan'], self.invoice_id['Blok'],
             self.invoice_id['Urut'], self.invoice_id['Jenis'],
             self.invoice_id['Tahun Pajak'])
     self.invoice = q.first()
     self.ket = None
     if not self.invoice:
         return
     self.nama_wp = self.invoice.nm_wp_sppt
     self.payment = self.invoice2payment(self.invoice)
     if self.payment:
         self.total = self.payment.jml_sppt_yg_dibayar
         self.tgl_bayar = self.payment.tgl_rekam_byr_sppt
         self.ket = 'pembayaran ke {n}'.format(n=self.payment.pembayaran_sppt_ke)
         q = DBSession.query(models.TempatPembayaran).filter_by(
             kd_kanwil=self.payment.kd_kanwil_bank,
             kd_kppbb=self.payment.kd_kppbb_bank,
             kd_bank_tunggal=self.payment.kd_bank_tunggal,
             kd_bank_persepsi=self.payment.kd_bank_persepsi,
             kd_tp=self.payment.kd_tp)
         tp = q.first()
         self.tempat_pembayaran = dict()
         if tp:
             self.tempat_pembayaran['nama'] = tp.nm_tp
             alamat = tp.alamat_tp and tp.alamat_tp.strip()
             if alamat:
                 self.tempat_pembayaran['alamat'] = alamat
     self.h2h = self.invoice2iso_pay()

 def response(self):
     if not self.rev.invoice:
         return self.parent.ack_payment_not_found()
     if not self.rev.is_paid():
         return self.parent.ack_invoice_open()
     if not self.rev.payment:
         return self.parent.ack_payment_not_found()
     if not self.is_transaction_owner():
         return self.parent.ack_payment_owner()
     iso_pay = self.rev.get_iso_payment(self.invoice_id)
     if not iso_pay:
         return self.parent.ack_payment_not_found_2()
     iso_rev = models.Reversal(payment_id=iso_pay.id)
     iso_rev.iso_request = self.parent.from_iso.raw
     DBSession.add(iso_rev)
     self.rev.set_unpaid() # flush
     self.commit()

 def invoice2iso_pay(self):
     q = DBSession.query(models.Payment).filter_by(
             propinsi=self.invoice.kd_propinsi,
             kabupaten=self.invoice.kd_dati2,
             kecamatan=self.invoice.kd_kecamatan,
             kelurahan=self.invoice.kd_kelurahan,
             blok=self.invoice.kd_blok,
             urut=self.invoice.no_urut,
             jenis=self.invoice.kd_jns_op,
             tahun=self.invoice.thn_pajak_sppt).order_by(
             models.Payment.ke)
     r = []
     for iso_pay in q:
         q_inq = DBSession.query(models.Inquiry).filter_by(
                 id=iso_pay.inquiry_id)
         iso_inq = q_inq.first()
         total = iso_inq.tagihan + iso_inq.denda
         ket = 'Pembayaran ke {k}'.format(k=iso_pay.ke)
         d = dict(ket=ket, tgl=iso_inq.tgl, total=total)
         r.append(d)
     return r

def save():
    vals = dict()
    data = r_iso.to_dict()
    for key in ('tgl', 'mti', 'bit_003', 'bit_004', 'bit_032'):
        vals[key] = data[key]
    tgl = r_iso.tgl.date()
    amount = float(r_iso.bit_004)
    if r_iso.mti == '0210':
        if r_iso.bit_003 in INQUIRY_CODES:
            method_id = 1
        else:
            method_id = 2
    else:
        method_id = 3
    method_name = methods[method_id]
    bank_id = r_iso.bit_032[-3:]
    bank_id = int(bank_id)
    bank_name = banks[bank_id]
    msg = '{id} {data} -> {tgl} {bank} {method} {amount}'.format(
            id=r_iso.id, tgl=tgl, bank=bank_name, method=method_name,
            amount=amount, data=vals)
    print(msg)
    q = DBSession.query(Summary).filter_by(
            jenis_id=r_iso.jenis_id, tgl=tgl, method_id=method_id,
            bank_id=bank_id)
    r_sum = q.first()
    if r_sum:
        r_sum.trx_count += 1
        r_sum.trx_amount += amount
    else:
        r_sum = Summary()
        r_sum.jenis_id = r_iso.jenis_id
        r_sum.tgl = tgl
        r_sum.method_id = method_id
        r_sum.bank_id = bank_id
        r_sum.trx_count = 1
        r_sum.trx_amount = amount
    DBSession.add(r_sum)
    save_conf()

 def ack_already_paid(self):
     pay = self.calc.invoice2payment()
     ntp = ''
     if pay and self.is_transaction_owner(pay):
         calc = self.calc
         q = DBSession.query(models.Payment).filter_by(
                 propinsi=calc.propinsi,
                 kabupaten=calc.kabupaten,
                 kecamatan=calc.kecamatan,
                 kelurahan=calc.kelurahan,
                 blok=calc.blok,
                 urut=calc.urut,
                 jenis=calc.jenis,
                 tahun=calc.tahun).order_by(
                 models.Payment.ke.desc())
         iso_pay = q.first()
         if iso_pay:
             ntp = iso_pay.id
     self.set_ntp(ntp)
     return self.parent.ack_already_paid()

 def commit(self):
     DBSession.commit()
     self.parent.ack()