only_h2h.py 3.98 KB
import requests
from sqlalchemy import func
import transaction
from opensipkd.waktu import dmyhms
from opensipkd.string import FixLength
from opensipkd.iso8583.bjb.pad.structure import (
    PAYMENT_CODE,
    INVOICE_PROFILE,
    )
from opensipkd.iso8583.bjb.pad.models import Log
from payment_report.scripts.tools import (
    plain_values,
    update,
    )
from payment_report.scripts.common import (
    InvalidSource,
    one_day,
    get_channel_name_by_row,
    row_limit,
    )


class Handler:
    def __init__(self, parent):
        self.parent = parent

    def filter_tgl(self, q):
        q = q.filter(
                Log.created >= self.parent.tgl_awal,
                Log.created < self.parent.tgl_akhir + one_day,
                Log.ip.__ne__(None))
        return q.filter_by(mti='0210', bit_003=PAYMENT_CODE, bit_039='00')

    def get_payment_query(self):
        q = self.parent.h2h_session.query(Log)
        return self.filter_tgl(q).order_by(Log.id)

    def get_count(self):  # dipanggil parent
        q = self.parent.h2h_session.query(func.count(Log.id))
        q = self.filter_tgl(q)
        return q.scalar()

    def get_last_time(self):  # dipanggil parent
        return dmyhms(self.parent.last_pay.created)

    def get_report(self, pay):
        session = self.parent.get_session_for_save()
        q = session.query(self.parent.report_orm).filter_by(id=pay.id)
        return q.first()

    def create_data(self, pay):
        tgl = pay.created.date()
        jam = pay.created.time()
        channel_name = get_channel_name_by_row(pay)
        channel_id = pay.bit_018 or '0000'
        profile = pay.bit_062_data
        if not profile:
            profile = FixLength(INVOICE_PROFILE)
            profile.set_raw(pay.bit_062)
        return dict(
            id=pay.id, tgl=tgl, jam=jam, nomor_bayar=self.parent.invoice_id,
            jenis_pajak=profile['Nama Rekening'].strip(), masa_pajak=0,
            npwpd=profile['NPWPD'].strip(), nama_wp=profile['Nama'].strip(),
            pokok=float(profile['Tagihan']), denda=float(profile['Denda']),
            bunga=0, jml_bayar=float(pay.bit_004), channel_id=channel_id,
            channel_name=channel_name, bank_id=int(pay.bit_032))

    def update_from_date(self):
        q = self.get_payment_query()
        no = self.parent.offset
        found = False
        for pay in q.offset(self.parent.offset).limit(row_limit):
            found = True
            self.parent.invoice_id = pay.bit_061.strip()
            no += 1
            try:
                source = self.create_data(pay)
                d = plain_values(source)
                rpt = self.get_report(pay)
                if rpt:
                    target = rpt.to_dict()
                    target_update, log_msg = update(source, target)
                    if target_update:
                        s = ', '.join(log_msg)
                        msg = f'UPDATE {d} change {s}'
                        rpt.from_dict(target_update)
                    else:
                        msg = f'ALREADY SAME {d}'
                        rpt = None
                        if self.parent.count == 1 and self.last:  # Hemat log
                            print(msg)
                            print('Log yang sama, abaikan.')
                            return
                else:
                    msg = f'INSERT {d}'
                    rpt = self.parent.report_orm(**source)
                msg = f'{self.parent.get_prefix_log()} {msg}'
                log_method = self.parent.log.info
            except InvalidSource as e:
                msg = str(e)
                log_method = self.parent.log.warning
                rpt = None
            e = self.parent.get_estimate(no)
            log_method(f'#{no}/{self.parent.count} {msg}, estimate {e}')
            if rpt:
                session = self.parent.get_session_for_save()
                with transaction.manager:
                    session.add(rpt)
            self.parent.last_pay = pay
        self.parent.offset += row_limit
        return found