doc.py

import json
# from opensipkd.iso8583.base.modules.network import models
import transaction
import re
import sys
import traceback
from opensipkd.string import FixLength

import requests
from opensipkd.iso8583.bjb.samsat.structure import (
    INVOICE_ID,
    INVALID_NIK,
    INVOICE_PROFILE,
    RC_NOT_AVAILABLE,
    RC_ALREADY_PAID,
    RC_INVALID_NUMBER,
    RC_EXPIRE,
    RC_DUPLIKASI_TGL_AKHIR_PAJAK,
    ERR_INVALID_NUMBER,
    ERR_INVALID_NUMBER_2,
    ERR_NOT_AVAILABLE,
    ERR_ALREADY_PAID,
    ERR_INQUIRY_TIMEOUT,
    ERR_PAYMENT_TIMEOUT,
    ERR_PAYMENT_FAILED,
    ERR_PAYMENT_NOT_FOUND,
    ERR_REVERSAL_DONE,
    ERR_REVERSAL_TIMEOUT,
    ERR_REVERSAL_FAILED,
    ERR_INVALID_CHANNEL,
    ERR_INVALID_NIK,
    ERR_DB,
    ERR_INVALID_BANK,
    ERR_EXPIRE,
    ERR_DUPLIKASI_TGL_AKHIR_PAJAK,
)
from opensipkd.iso8583.bjb.samsat.transaction import Transaction
from opensipkd.string import FixLength

# todo: harusnya diimport daro opensipkd.tools.rpc
from ..api import get_header, get_jsonrpc
from ..models import SamsatPayment, SamsatReversal, Base, DBSession
if sys.version < '3':
    from StringIO import StringIO
else:
    from io import StringIO

CODE_54 = ['05', '23']
CODE_55 = ['01', '02', '03', '04', '06', '09', '10', '11', '12', '15', '99',
           '24', '22']

from datetime import date
class DateVar(FixLength):
    def __init__(self):
        FixLength.__init__(self, [
            ['year', 4, 'N'],
            ['month', 2, 'N'],
            ['day', 2, 'N'],
            ])

    def get_value(self, year=None):
        return date(self.get('year'), self.get('month'), self.get('day'))

def date2str(d):
    return d and d.strftime('%Y%m%d') or None


class Doc(Transaction):
    def __init__(self, *args, **kwargs):
        self.invoice_id = FixLength(INVOICE_ID)
        self.invalid_nik = FixLength(INVALID_NIK)
        self.invoice_profile = FixLength(self.get_invoice_profile_definition())
        # self.other_engine = OtherEngine(db_name, db_user, db_pass)
        Transaction.__init__(self, *args, **kwargs)

        if not self.mod_conf:
            raise ValueError("Perbaiki konfigurasi")

        self.invoice_id_raw = None

    def get_channel(self):
        return self.get_channel_id()

    def send_rpc(self, method, message):
        userid = self.mod_conf['user']
        password = self.mod_conf['key']
        url = self.mod_conf['url']
        headers = get_header(userid, password)
        params = dict(data=message)
        data = get_jsonrpc(method, params)
        self.log_info(url)
        self.log_info("REQUEST {}".format(data))
        results = requests.post(url, json=data, headers=headers)  # data=jsondata,
        if results.status_code != 200:
            self.log_error(results)
            self.log_error(results.text)
            return

        rows = results.text and json.loads(results.text) or None
        self.log_info("RESPONSE {}".format(rows))
        return rows

    # @staticmethod
    def get_invoice_profile_definition(self):
        return INVOICE_PROFILE

    def is_allowed(self):
        # return True
        # todo: to be updated
        # if 'allowed id' not in self.conf.host:
        #     return True
        #
        bank_id = self.from_iso.getBit(32)
        return bank_id in self.conf['banks']

    ###########
    # Inquiry #
    ###########
    def inquiry_request(self, data={}):
        for p in data:
            self.setBit(int(p), data[p])
        self.setMTI('0200')
        self.set_transmission()
        self.set_stan()

    def inquiry_response_(self):
        if not self.is_allowed():
            return self.ack_not_allowed()
        self.setBit(4, 0)
        tagihan = self.get_invoice()
        if tagihan:
            self.setBit(4, tagihan['jumlah'] or 0)
            return tagihan

    def inquiry_response(self):
        self.inquiry_response_()
        try:
            pass
        except:
            self.ack_other('Ada kesalahan yang belum dipahami.')
            f = StringIO()
            traceback.print_exc(file=f)
            self.log_error(f.getvalue())
            f.close()

    def get_invoice_id_structure(self):
        invoice_id_raw = self.get_invoice_id_raw()
        invoice_id_raw = invoice_id_raw.strip().replace('.', '').strip()
        if len(invoice_id_raw) in [10, 16]:
            if len(invoice_id_raw) == 10:
                invoice_id_raw = invoice_id_raw.ljust(16, ' ')
            invoice_id_raw = invoice_id_raw.ljust(32, '0')
        # self.log_info(invoice_id_raw)
        r = self.invoice_id.set_raw(invoice_id_raw)
        if not r:
            return self.ack_invalid_number_2(invoice_id_raw)
        self.invoice_id['Nomor Bayar'] = self.invoice_id['Nomor Bayar'].strip()
        if self.invoice_id['Nomor Identitas'] is None:
            self.invoice_id['Nomor Identitas'] = ''
        else:
            self.invoice_id['Nomor Identitas'] = \
                self.invoice_id['Nomor Identitas'].strip()
        self.invoice_id_raw = self.invoice_id['Nomor Bayar'].ljust(16) + \
                              self.invoice_id['Nomor Identitas']
        return r

    def get_data(self):
        return dict(kd_bank=str(self.get_bank_id()).rjust(3, '0'),
                    kd_channel=self.from_iso.get_channel(),
                    invoice_no=self.invoice_id_raw[:16],
                    kd_biller=self.mod_conf['kd_biller'],
                    kd_produk=self.mod_conf['kd_produk']
                    )

    def get_invoice(self):
        if not self.get_invoice_id_structure():
            return self.ack_invalid_number()
        if len(self.invoice_id['Nomor Bayar']) != 16:
            return self.ack_invalid_number()
        data = self.get_data()
        rows = self.send_rpc('inquiry', data)

        if 'error' in rows:
            code = rows['error']['code'] \
                   and rows['error']['code'] or '91'
            code = len(str(code)) > 2 and '91' or code
            if code in CODE_55:
                code = '55'

            elif code in CODE_54:
                code = '54'
            else:
                code = '91'

            message = rows['error']['message'] and rows['error']['message'] or 'Link Down'
            self.log_info('Nomor Bayar {nb} NIK {nik} kode = {code}, {message}'.format(
                nb=self.invoice_id['Nomor Bayar'],
                nik=self.invoice_id['Nomor Identitas'],
                code=code,
                message=message))

            self.setBit(62, message)
            self.ack(code, message)
            return self.ack(code, message)

        if rows:
            invoice = rows['result']['data']
            self.set_profile(invoice)
            return invoice
        self.ack_inquiry_timeout()

    def get_bank_channel_id(self):
        bank_id = self.get_bank_id()
        bank_id = str(bank_id).zfill(3)
        channel_id = self.from_iso.get_channel_id()
        channel_id = self.from_iso.get_channel_name_to_id() + channel_id
        # channel_id = str(channel_id).zfill(7)
        return '{b}{c}'.format(b=bank_id, c=channel_id)

    def set_profile_(self, invoice):
        self.invoice_profile.from_dict({
            'Nomor Bayar': invoice['invoice_no'],
            'Nomor Rangka': invoice['no_rangka'],
            'Nomor Mesin': invoice['no_mesin'],
            'Nomor Identitas': invoice['no_identitas'],
            'Nama Pemilik': invoice['nm_wp'],
            'Alamat Pemilik': invoice['jln_wp'],
            'Nomor Polisi': 'no_polisi' in invoice and invoice['no_polisi'] or '',
            'Warna Plat': invoice['warna_tnkb'],
            'Milik Ke': invoice['milik_ke'],
            'Nama Jenis KB': invoice['jenis_op'],
            'Nama Merk KB': 'nm_op' in invoice and invoice['nm_op'] or '',
            'Nama Model KB': invoice['model_op'],
            'Tahun Buatan': 'tahun_produksi' in invoice and invoice['tahun_produksi'] or invoice['tahun_produksi '],
            'Tgl Akhir Pajak Lama': re.sub("\D", "", invoice['tgl_lama']),
            'Tgl Akhir Pajak Baru': re.sub("\D", "", invoice['tgl_baru']),
            'Pokok BBN': invoice['pokok_bbn'],
            'Denda BBN': invoice['denda_bbn'],
            'Pokok PKB': invoice['pokok_pkb'],
            'Denda PKB': invoice['denda_pkb'],
            'Pokok SWD': invoice['pokok_swd'],
            'Denda SWD': invoice['denda_swd'],
            'Pokok Adm STNK': invoice['pokok_adm_stnk'],
            'Pokok Adm TNKB': invoice['pokok_adm_tnkb'],
            'Jumlah': invoice['jumlah'],
            'Keterangan': invoice['keterangan'],
            'Kode Wilayah': invoice['reserved_01']})
        self.set_invoice_profile(self.invoice_profile.get_raw())

    def set_profile(self, invoice):
        self.set_profile_(invoice)
        # kode = invoice['kd_status']
        self.log_info('Nomor Bayar {nb} NIK {nik}'.format(
            nb=self.invoice_id['Nomor Bayar'],
            nik=self.invoice_id['Nomor Identitas']))
        return self.ack()

        # if kode == '1':
        #     return self.ack()
        # self.set_error_msg(invoice['ket'])
        # if kode == 'A':
        #     nik_samsat = invoice['nik_nasabah'].strip()
        #     if self.invoice_id['Nomor Identitas'] == nik_samsat:
        #         return self.ack_not_available()
        #     self.invalid_nik.from_dict({
        #         'Nomor Identitas Bank': self.invoice_id['Nomor Identitas'],
        #         'Nomor Identitas Pemprov': nik_samsat})
        #     self.set_invoice_profile(self.invalid_nik.get_raw())
        #     return self.ack_invalid_nik(invoice)
        # if kode == 'B':
        #     return self.ack_other('Harus ke kantor SAMSAT')
        # if kode == 'F':
        #     return self.ack_already_paid()
        # if kode == 'H':
        #     return self.ack_expire()
        # if kode == 'C':
        #     return self.ack_duplikasi_tgl_akhir_pajak()
        # if kode == 'G':
        #     return self.ack_other('Jam pelayanan usai')
        # self.ack_other()

    def set_error_msg(self, msg):
        self.setBit(62, msg)

    def tgl_bayar(self):
        t = self.from_iso.get_transaction_date()
        return t.strftime('%m-%d-%Y')

    ###########
    # Payment #
    ###########
    def payment_request(self, data=()):
        for p in data:
            self.setBit(int(p), data[p])
        self.setMTI('0200')
        self.set_stan()
        self.set_transmission()

    def payment_response(self):
        self.payment_response_()

    def payment_response_(self):
        if not self.is_allowed():
            return self.ack_not_allowed()
        self.copy([4, self.get_bit_invoice_profile()])
        pay = self.get_payment()
        if not pay:
            return
        no_identitas = self.from_iso.get_invoice_id_raw()[16:]
        self.invoice_id_raw = ''.join([
            pay['invoice_no'].ljust(16),
            no_identitas])
        ntpd = pay['ntp']  # self.ntpd(bank_id)
        self.set_ntp(ntpd)
        return self.save_payment(ntpd)

    def get_payment(self):
        self.invoice_id_raw = self.from_iso.get_invoice_id_raw()[:16].strip()

        if len(self.invoice_id_raw) == 16:
            data = self.get_data()
            data.update(
                dict(ntb=self.get_ntb(),
                     tgl_transaksi=self.get_transaction_date().strftime('%Y%m%d'),
                     jam_transaksi=self.get_transaction_time().strftime("%H%M%S"),
                     amount=self.get_amount())
            )
            rows = self.send_rpc('payment', data)
            if 'error' in rows:
                if 'error' in rows['error']:
                    rows = rows['error']
                code = rows['error']['code']

                message = rows['error']['message']
                self.log_info('Nomor Bayar {nb} NIK {nik} kode = {code}, {message}'.format(
                    nb=self.invoice_id['Nomor Bayar'],
                    nik=self.invoice_id['Nomor Identitas'],
                    code=code,
                    message=message))

                if code in CODE_55:
                    code = '55'
                elif code in CODE_54:
                    code = '54'
                else:
                    code = '91'

                self.setBit(62, message)
                self.ack(code[-2:], message)
                return

            if rows:
                invoice = 'result' in rows and rows['result']['data'] or None
                # self.set_profile(invoice)
                return invoice
            return

        elif self.get_invoice_id_structure():
            pass
            # q = DBSession.query(Payment).filter_by(
            #     nomor_bayar=self.invoice_id['Nomor Bayar'],
            #     nik=self.invoice_id['Nomor Identitas'])
        else:
            return

        return

    def save_payment(self, ntpd):
        channel_id = self.from_iso.get_channel_id()
        ntb = self.from_iso.get_ntb()
        total_bayar = self.from_iso.get_amount()
        profile = self.from_iso.getBit(61)
        self.invoice_profile.set_raw(profile)
        data = dict()
        for f in INVOICE_PROFILE:
            field = f[0].replace(" ","_").lower()
            if field in ["tgl_akhir_pajak_lama", "tgl_akhir_pajak_baru"]:
                v = str(self.invoice_profile[f[0]])
                tgl = DateVar()
                tgl.set_raw(v)
                v = tgl.get_value()
            else:
                v = self.invoice_profile[f[0]]
            data[field] = v

        pay = SamsatPayment()
        pay.from_dict(data)
        pay.ntb = ntb
        pay.ntp = ntpd
        pay.nomor_bayar = self.invoice_id_raw[:16].strip()
        pay.nik = self.invoice_id_raw[16:32].strip()
        # pay.tgl_bayar = self.from_iso.get_transaction_date()
        pay.jumlah = total_bayar
        pay.channel_id = channel_id
        pay.channel_name = self.from_iso.getBit(43)
        pay.bank_ip = self.get_bank_ip()
        # pay.biller_id = self.mod_conf['kd_biller']
        # todo: mustbe transaction_date_time
        pay.tgl = self.from_iso.get_transaction_datetime()

        # if 'id' in self.mod_conf:
        #    pay.bank_id = self.mod_conf.get('id')
        # else:
        pay.bank_id = int(self.from_iso.getBit(32))

        # pay.iso_request = self.from_iso.raw.upper()
        pay.transmission = self.from_iso.get_transmission_datetime()
        pay.stan = self.from_iso.get_value(11)
        pay.kd_wil = self.invoice_profile['Kode Wilayah']
        pay.settlement = self.from_iso.get_settlement_date()
        pay.bit_inv_profile = self.from_iso.get_invoice_id_raw()
        DBSession.add(pay)
        DBSession.flush()
        transaction.commit()
        self.ack()

    ############
    # Reversal #
    ############
    def reversal_request(self, data=()):
        for p in data:
            self.setBit(int(p), data[p])
        self.setMTI('0400')
        self.set_stan()
        
    def execute_reversal(self):
        self.invoice_id_raw = self.from_iso.get_invoice_id_raw()[:16].strip()

        if len(self.invoice_id_raw) == 16:
            data = self.get_data()
            data.update(
                dict(ntb=self.get_ntb(),
                     tgl_transaksi=self.get_transaction_date().strftime('%Y%m%d'),
                     jam_transaksi=self.get_transaction_time().strftime("%H%M%S"))
            )
            # penambahan parameters
            rows = self.send_rpc('reversal', data)
            if 'error' in rows:
                code = rows['error']['code']
                message = rows['error']['message']
                self.log_info('Nomor Bayar {nb} NIK {nik} kode = {code}, {message}'.format(
                    nb=self.invoice_id['Nomor Bayar'],
                    nik=self.invoice_id['Nomor Identitas'],
                    code=code,
                    message=message))

                self.setBit(62, message)
                self.ack(code, message)
                return

            if rows:
                row = 'result' in rows and rows['result']['data'] or None
                # self.set_profile(invoice)
                return row
            return

        elif self.get_invoice_id_structure():
            pass
            # q = DBSession.query(Payment).filter_by(
            #     nomor_bayar=self.invoice_id['Nomor Bayar'],
            #     nik=self.invoice_id['Nomor Identitas'])
        else:
            return

        return

    def reversal_response_(self):
        invoice_id_raw = self.from_iso.get_invoice_id_raw()[:16]
        ntb = self.from_iso.get_ntb()
        q = DBSession.query(SamsatPayment).filter_by(
            nomor_bayar=invoice_id_raw.strip(),
            ntb=ntb)

        pay = q.first()
        if not pay:
           return self.ack_payment_not_found()

        # self.invoice_id_raw = self.from_iso.get_invoice_id_raw()
        q = DBSession.query(SamsatReversal).filter_by(id=pay.id)
        rev = q.first()
        if rev:
           return self.ack_reversal_done()

        result = self.execute_reversal()

        if not result:
            return

        return self.save_reversal(pay, result['ntp'])

    def reversal_response(self):
        try:
            self.reversal_response_()
        except:
            self.ack_other('Ada kesalahan yang belum dipahami.')
            f = StringIO()
            traceback.print_exc(file=f)
            self.log_error(f.getvalue())
            f.close()

    def save_reversal(self, pay, ntpd):
        rev = SamsatReversal()
        rev.id = pay.id
        rev.iso_request = self.from_iso.raw.upper()
        rev.tgl = self.from_iso.get_transaction_datetime()
        rev.ntp = ntpd
        DBSession.add(rev)
        DBSession.flush()
        transaction.commit()
        self.ack()

    ###################
    # Acknowledgement #
    ###################
    def ack_not_allowed(self):
        msg = ERR_INVALID_BANK.format(bank_id=self.from_iso.get_value(32))
        self.ack(RC_INVALID_NUMBER, msg)

    def ack_invalid_number(self):
        msg = ERR_INVALID_NUMBER.format(nik=self.invoice_id['Nomor Identitas'])
        # self.ack(RC_INVALID_NUMBER, msg)
        self.ack(RC_NOT_AVAILABLE, msg)
        self.set_error_msg(msg)

    def ack_invalid_number_2(self, invoice_id_raw):
        msg = ERR_INVALID_NUMBER_2.format(invoice_id=invoice_id_raw)
        # self.ack(RC_INVALID_NUMBER, msg)
        self.ack(RC_NOT_AVAILABLE, msg)
        self.set_error_msg(msg)

    def ack_not_available(self):
        msg = ERR_NOT_AVAILABLE.format(invoice_id=self.invoice_id_raw)
        self.ack(RC_NOT_AVAILABLE, msg)

    def ack_expire(self):
        msg = ERR_EXPIRE.format(invoice_id=self.invoice_id_raw)
        self.ack(RC_EXPIRE, msg)

    def ack_duplikasi_tgl_akhir_pajak(self):
        msg = ERR_DUPLIKASI_TGL_AKHIR_PAJAK.format(invoice_id=self.invoice_id_raw)
        self.ack(RC_DUPLIKASI_TGL_AKHIR_PAJAK, msg)

    def ack_invalid_channel(self):
        nomor_bayar = self.invoice_id['Nomor Bayar']
        channel_id = self.from_iso.get_channel_id()
        msg = ERR_INVALID_CHANNEL.format(nomor_bayar=nomor_bayar,
                                         channel_id=channel_id)
        self.ack_other(msg)

    def ack_invalid_nik(self, invoice):
        msg = ERR_INVALID_NIK.format(
            identitas_bank=self.invoice_id['Nomor Identitas'],
            identitas_pemprov=invoice['nik_nasabah'].strip())
        self.ack(RC_NOT_AVAILABLE, msg)

    def ack_inquiry_timeout(self):
        msg = ERR_INQUIRY_TIMEOUT.format(
            kd_bayar=self.invoice_id['Nomor Bayar'])
        self.ack_other(msg)

    def ack_already_paid(self):
        msg = ERR_ALREADY_PAID.format(invoice_id=self.invoice_id_raw)
        self.ack(RC_ALREADY_PAID)

    def ack_db_error(self, db_error):
        self.log_error(db_error)
        self.ack_other(ERR_DB)

    def ack_payment_timeout(self):
        kd_bayar = self.invoice_profile['Nomor Bayar']
        ntb = self.from_iso.get_ntb()
        msg = ERR_PAYMENT_TIMEOUT.format(kd_bayar=kd_bayar, ntb=ntb)
        self.ack_other(msg)

    def ack_payment_failed(self, result):
        kd_bayar = self.invoice_profile['Nomor Bayar']
        ntb = self.from_iso.get_ntb()
        msg = ERR_PAYMENT_FAILED.format(kd_bayar=kd_bayar, ntb=ntb,
                                        kd_status=result['kd_status'])
        self.ack_other(msg)

    def ack_payment_not_found(self):
        ntb = self.from_iso.get_ntb()
        msg = ERR_PAYMENT_NOT_FOUND.format(invoice_id=self.invoice_id_raw,
                                           ntb=ntb)
        self.ack(RC_NOT_AVAILABLE, msg)

    def ack_reversal_done(self):
        ntb = self.from_iso.get_ntb()
        msg = ERR_REVERSAL_DONE.format(invoice_id=self.invoice_id_raw,
                                       ntb=ntb)
        self.ack(RC_ALREADY_PAID, msg)

    def ack_reversal_timeout(self):
        kd_bayar = self.invoice_profile['Nomor Bayar']
        ntb = self.from_iso.get_ntb()
        msg = ERR_REVERSAL_TIMEOUT.format(kd_bayar=kd_bayar, ntb=ntb)
        self.ack_other(msg)

    def ack_reversal_failed(self, result):
        kd_bayar = self.invoice_profile['Nomor Bayar']
        ntb = self.from_iso.get_ntb()
        msg = ERR_REVERSAL_FAILED.format(kd_bayar=kd_bayar, ntb=ntb,
                                         kd_status=result['kd_status'])
        self.ack_other(msg)