api_merchant.py

import logging
from importlib import import_module
from opensipkd.base.models import Partner, flush_row
from opensipkd.base.tools.api import (auth_from_rpc,
                                      JsonRpcProdukNotFoundError, JsonRpcCustomerNotFoundError,
                                      JsonRpcParameterNotFound)
from opensipkd.pasar.models import Produk, PartnerProduk
from opensipkd.pasar.models.produk import H2hArInvoice, H2hArInvoiceDet, PartnerLog, PartnerPay
from pyramid_rpc.jsonrpc import jsonrpc_method
from ..tools import JsonRpcInvoiceFoundError, JsonRpcError

log = logging.getLogger(__name__)


def save_partner_log(values, vendor_produk):
    partner_log = PartnerLog()
    partner_log.vendor_id = vendor_produk.partner_id
    partner_log.produk_id = vendor_produk.produk.id
    partner_log.customer_id = values["customer_id"]
    partner_log.id_pel = values["id_pel"]
    flush_row(partner_log)
    return partner_log


def qry_vendor_produk():
    return PartnerProduk.query() \
        .join(Partner, Partner.id == PartnerProduk.partner_id) \
        .join(Produk, Produk.id == PartnerProduk.produk_id)


def build_request(typ, vendor_produk, partner_log=None, **kwargs):
    # produk_id = values['produk_id']
    # vendor_id = values['vendor_id']
    # bill_no = values['destination']
    # customer_id = 'customer_id' in values and values['customer_id'] or None
    # cust_trx_id = 'cust_trx_id' in values and values['cust_trx_id'] or None
    pckgs = 'agratek.api.merchant.views'
    moduls = vendor_produk.modules.split('.')
    if len(moduls) > 1:
        pckg = ".".join(moduls[:-1])
        pckgs = ".".join([pckgs, pckg])
        moduls = moduls[-1:]
    modul = moduls[0]
    log.info("Module: %s Pckgs: %s" % (modul, pckgs))
    modul = '.' + modul
    modules = import_module(modul, pckgs)
    cls_module = modules.Vendor(vendor_produk, partner_log, **kwargs)
    cls = hasattr(cls_module, typ) and getattr(cls_module, typ) or None
    if cls:
        result = cls()
        # log.info("Build Req: mod %s rslt: %s" % (vendor_produk.modules, data))
        log.info("Request %s" % cls_module.request)
        log.info("Response %s" % cls_module.response)
        log.info("Result %s" % cls_module.result)
        result = {}
        result["f_response"] = cls_module.response
        result["f_result"] = cls_module.result
        result["f_request"] = cls_module.request
        result["id"] =cls_module.trx_id
    else:
        log.info("Module %s Not Found" % vendor_produk.modules)
        data = dict(message='Fungsi %s tidak ada' % typ,
                    code=9999)
        result = {"f_result": data}
        # dict(data=)
    return result


def get_vendor_produk(produk_kd, vendor_kd=None, harga=None):
    """
    Fungsi ini digunakan untuk mencari vendor yang paling murah
    :param produk_kd: String Kode Produk
    :param vendor_kd: Kode Vendor
    :return: row objek dari Partner Produk
    """
    qry = qry_vendor_produk().filter(Produk.kode == produk_kd)
    # Jika parameter vendor_kd disebutkan maka secara explisit mengambil dari
    # data vendor parameter secara default mengambil dari yang statusnya=1
    if vendor_kd:
        qry = qry.filter(Partner.kode == vendor_kd)
    else:
        qry = qry.filter(PartnerProduk.status == 1)
        # by tatang
        qry = qry.order_by(PartnerProduk.harga)
    row = qry.first()
    return row


@jsonrpc_method(method='inquiry', endpoint='api-merchant')
def inquiry(request, data, **kwargs):
    """
    Digunakan untuk mendapatkan data tagihan
    :param request:
    :param data:
        {
            denom: string,
            id_pel:string
        }
    :param token: (jika merchant wajib menggunakan token)
        user_token
    :return:
    {
      "data": [{
        "nopel": "530678910981",
        "nama": "SUBCRIBER NAME",
        "refno": "25641544",
        "rincian":{
          "pokok": 300000,
          "denda": 0,
          "admin": 2500,
          "tarif": "R1\/1300VA",
          "no_meter": "530678910012",
          "power": "1300VA"
        },
        "subtotal": 302500,
        "discount": 800,
        "total": 301700
      }]
    }
    """
    user = auth_from_rpc(request)
    i = 0
    is_list = type(data) == list
    data = is_list and data or [data]
    customer = Partner.query_user(user).filter(Partner.is_customer == 1).first()
    if not customer:
        raise JsonRpcCustomerNotFoundError()
    r_data = []
    for prod in data:
        # prods = "produk" in dat and dat["produk"] or None
        # for prod in prods:
        # log.info(prod)
        produk_kd = 'denom' in prod and prod['denom'] or None
        if not produk_kd:
            raise JsonRpcProdukNotFoundError(message="Produk harus diisi")
        vendor_kd = 'vendor_kd' in prod and prod['vendor_kd'] or None
        vendor_produk = get_vendor_produk(produk_kd, vendor_kd=vendor_kd)
        if not vendor_produk:
            raise JsonRpcProdukNotFoundError(
                    message="Produk %s tidak ditemukan" % produk_kd)
        log.info("Vendor %s Produk %s Module %s" % (vendor_produk.partner.kode,
                                                    vendor_produk.produk.kode,
                                                    vendor_produk.modules))
        values = dict(customer_id=customer.id,
                      id_pel=prod["id_pel"])
        partner_log = save_partner_log(values, vendor_produk)
        result = build_request('inquiry', vendor_produk, partner_log)
        result_code = "code" in result["f_result"] and result["f_result"]["code"] or None
        if result_code:
            raise JsonRpcError(message=result["f_result"]["message"])
        if result["f_result"]["code"] == 0:
            prod.update(result["f_result"])
        else:
            prod.update(dict(status="FAILED",
                             message=result["message"]))
        r_data.append(prod)
    data = is_list and r_data or r_data[0]
    return data


def build_purchase(vendor_produk, partner_log=None):
    return build_request('payment', vendor_produk, partner_log)


@jsonrpc_method(method='purchase', endpoint='api-merchant')
def purchase(request, data, **kwargs):
    """
    Digunakan untuk mendapatkan daftar produk
    :param request:
    :param data:
        [{
            denom: string,
            id_pel:string
            inv_no: string optional
        }]
    :param token: (jika hanya menggunakan token)
        user_token
    :return:
      [{
        denom: string,
        id_pel:string
        inv_no: string
        product_nm:string,
        harga:integer,
        admin:integer,
        discount:integer,
        total:integer,
        status:success/pending/failed
      }]
    """
    user = auth_from_rpc(request)
    i = 0
    if not data:
        raise JsonRpcParameterNotFound

    is_list = type(data) == list
    data = is_list and data or [data]
    customer = Partner.query_user(user).first()
    if not customer:
        raise JsonRpcCustomerNotFoundError
    r_data = []
    log.info("%s Payment Request: %s" % (customer.kode, data))
    for dat in data:
        if "invoice_no" not in dat or "produk" not in dat or not dat["produk"]:
            dat["status"] = "FAILED"
            dat["message"] = "Parameter tidak lengkap"
        else:
            inv_no = dat["invoice_no"]
            produk = dat["produk"]
            # todo cek apakah invoice sudah ada atau belum
            ar_invoice = H2hArInvoice.query().filter_by(cust_inv_no=inv_no).first()
            if ar_invoice:
                raise JsonRpcInvoiceFoundError()
            ar_invoice = H2hArInvoice()
            ar_invoice.customer_id = customer.id
            ar_invoice.cust_inv_no = inv_no
            ar_invoice.payment = dict(request=dat)
            flush_row(ar_invoice)
            r_prod = []
            for prod in produk:
                produk_kd = 'denom' in prod and prod['denom'] or None
                id_pel = 'id_pel' in prod and prod['id_pel'] or None
                if not produk_kd or not id_pel:
                    prod["status"] = "FAILED"
                    prod["message"] = "Denom atau id pelanggan tidak diisi"
                else:
                    vendor_produk = get_vendor_produk(produk_kd)
                    if not vendor_produk:
                        prod["status"] = "FAILED"
                        prod["message"] = "Data tidak ditemukan"
                    else:
                        ar_invoice_det = H2hArInvoiceDet()
                        ar_invoice_det.vendor_id = vendor_produk.partner_id
                        ar_invoice_det.produk_id = vendor_produk.produk.id
                        ar_invoice_det.ar_invoice_id = ar_invoice.id
                        ar_invoice_det.id_pel = prod["id_pel"]
                        ar_invoice_det.amt_sell = vendor_produk.produk.harga
                        flush_row(ar_invoice_det)
                        result = build_purchase(vendor_produk, ar_invoice_det)
                        total = "total" in result and result["total"] or 0
                        prod.update(result["f_result"])
                r_prod.append(prod)
            ar_invoice.payment["response"] = r_prod
            dat["produk"] = r_prod
        r_data.append(dat)
    data = is_list and r_data or r_data[0]
    log.info("%s Payment Response: %s " % (customer.kode, data))
    return data


def payment_advice(dat):
    if not dat['tx_id']:
        dat["status"] = "FAILED"
        dat["message"] = "Parameter tidak lengkap"
        return dat

    tx_id = dat["tx_id"]
    inv_no = dat["invoice_no"]
    inv = PartnerPay.query_txid(tx_id).filter_by(cust_inv_no=inv_no).first()
    if not inv:
        dat["status"] = "FAILED"
        dat["message"] = "Data Tagihan {} tidak ditemukan".format(inv_no)
        return dat
    vend_produk = PartnerProduk.query().filter_by(produk_id=inv.produk_id,
                                               partner_id=inv.vendor_id).first()
    if not vend_produk:
        dat["status"] = "FAILED"
        dat["message"] = "Data Produk tidak ditemukan".format(inv_no)
        return dat

    vendor_nm = vend_produk.modules
    modul = '.advice'
    pckgs = 'agratek.api.merchant.views.{}'.format(vendor_nm)
    moduls = import_module(modul, pckgs)
    typ = 'proses'
    cls = hasattr(moduls, typ) and getattr(moduls, typ) or None
    if cls:
        order = cls(inv, vend_produk)
        return order

    return dict()


def purchase_advice(customer, dat):
    inv_no = dat["invoice_no"]
    invoice = H2hArInvoice.query() \
        .filter_by(cust_inv_no=inv_no,
                   customer_id=customer.id).first()
    if not invoice:
        return dict(status = "FAILED",
                    message = "Invoice %s Tidak Ditemukan" % inv_no)
    else:
        qry = H2hArInvoiceDet.query().filter_by(ar_invoice_id=invoice.id)
        r_prod = []
        if "produk" in dat:
            prods = []
            for p in dat["produk"]:
                row = qry.join(Produk, Produk.id == H2hArInvoiceDet.produk_id) \
                    .filter(Produk.kode == p["denom"],
                            H2hArInvoiceDet.id_pel == p["id_pel"]).first()
                if not row:
                    status = "FAILED"
                    message = "Produk tidak ada"
                    p.update(dict(status=status,
                                  message=message))
                else:
                    status = row.status == -1 and 'PENDING' \
                             or row.status == 1 and 'SUCCESS' \
                             or row.status == -2 and 'PENDING' \
                             or "FAILED"
                    p.update(dict(
                        subtotal=(row.amt_sell or 0) + (row.discount or 0),
                        discount=row.discount or 0,
                        total=row.amt_sell,
                        status=status,
                        serial_number=row.serial_number or "", )
                    )
                r_prod.append(p)
        else:
            for p in qry.all():
                produk = Produk.query(). \
                    filter(Produk.id == p.produk_id).first()
                status = p.status == -1 and 'PENDING' or p.status == 1 and 'SUCCESS' \
                         or p.status == -2 and 'PENDING' or "FAILED"
                r_prod.append(dict(denom=produk.kode,
                                   id_pel=p.id_pel,
                                   subtotal=(p.amt_sell or 0) + (p.discount or 0),
                                   discount=p.discount or 0,
                                   total=p.amt_sell,
                                   status=status,
                                   serial_number=p.serial_number or "", )
                              )
            dat["produk"] = r_prod
    return dat


@jsonrpc_method(method='advice', endpoint='api-merchant')
def advice(request, data):
    """
    Digunakan untuk mendapatkan daftar produk
    :param request:
    :param data:
        {
            denom: string,
            id_pel:string
            inv_no: string optional
        }
    :param token:
        user_token
    :return:
      {
        product_nm:string,
        denom: string,
        id_pel:string
        inv_no: string optional
        denom:string,
        harga:integer,
        admin:integer,
        discount:integer,
        total:integer,
        status:success/pending/failed
    """
    user = auth_from_rpc(request)
    i = 0
    is_list = type(data) == list
    data = is_list and data or [data]
    customer = Partner.query_user(user).first()
    if not customer:
        raise JsonRpcCustomerNotFoundError
    r_data = []
    for dat in data:
        if "invoice_no" not in dat:
            dat["status"] = "FAILED"
            dat["message"] = "Parameter tidak lengkap"
        else:
            if 'tx_id' in dat:
                dat.update(payment_advice(dat))
            else:
                dat.update(purchase_advice(customer, dat))
        r_data.append(dat)
        i += 1
    data = is_list and r_data or r_data[0]
    return data


def cancel_tx(dat):
    tx_id = dat["tx_id"]
    inv_no = dat["invoice_no"]
    inv = PartnerPay.query_txid(tx_id).filter_by(cust_inv_no=inv_no).first()
    if not inv:
        dat["status"] = "FAILED"
        dat["message"] = "Data Tagihan {} tidak ditemukan".format(inv_no)
        return dat

    payment = inv.notify and "request" in inv.notify and \
                  inv.notify["request"] or None
    # inv.notify["request"]
    if not payment:
        payment = inv.payment and "response" in inv.payment and \
                  inv.payment["response"] or None

    if not payment:
        dat["status"] = "FAILED"
        dat["message"] = "Data Pembayaran {} tidak ditemukan".format(inv_no)
        return dat

    vend_produk = PartnerProduk.query().filter_by(produk_id=inv.produk_id,
                                               partner_id=inv.vendor_id).first()
    if not vend_produk:
        dat["status"] = "FAILED"
        dat["message"] = "Data Produk tidak ditemukan".format(inv_no)
        return dat

    vendor_nm = vend_produk.modules
    modul = '.cancel_tx'
    pckgs = 'agratek.api.merchant.views.{}'.format(vendor_nm)
    moduls = import_module(modul, pckgs)
    typ = 'proses'
    cls = hasattr(moduls, typ) and getattr(moduls, typ) or None
    if cls:
        order = cls(inv, vend_produk, dat)
        return order

    return dict()


@jsonrpc_method(method='cancel', endpoint='api-merchant')
def cancel_rpc(request, data):
    user = auth_from_rpc(request)
    i = 0
    is_list = type(data) == list
    data = is_list and data or [data]
    customer = Partner.query_user(user).first()
    if not customer:
        raise JsonRpcCustomerNotFoundError
    r_data = []
    for dat in data:
        if "invoice_no" not in dat or "tx_id" not in dat \
                or "cancel_type" not in dat\
                or "cancel_msg" not in dat:
            dat["status"] = "FAILED"
            dat["message"] = "Parameter tidak lengkap"
        else:
            dat.update(cancel_tx(dat))
        r_data.append(dat)
        i += 1
    data = is_list and r_data or r_data[0]
    return data