__init__.py

import json
import base64
import logging
from datetime import datetime

from opensipkd.base import get_settings, is_devel, get_host
from opensipkd.base.models import flush_row
from pyramid.httpexceptions import HTTPFound
from . import Nicepay
from ..vendor import VendorClass, sha256

log = logging.getLogger(__name__)


class Vendor(VendorClass):  # VendorClass
    def __init__(self, vendor_produk, invoice_det, **kwargs):
        VendorClass.__init__(self, vendor_produk, invoice_det=invoice_det, **kwargs)
        settings = get_settings()

        self.v_produk_kd = vendor_produk.kode
        self.bank_cd, self.pay_method = self.v_produk_kd.split('-')

        print('partner imid >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
        print()

        np_imid = self.invoice_det.customer.np_imid
        np_key = self.invoice_det.customer.np_key

        if not np_imid:
            np_imid = 'np_mid' in settings and settings['np_mid'] or None
        if not np_key:
            np_key = self.key = 'np_key' in settings and settings['np_key'] or None

        self.mid = np_imid
        self.key = np_key

        if self.pay_method == '06' and 'np_loan_mid' in settings and settings['np_loan_mid']:
            self.mid = settings['np_loan_mid']
        
        self.url = 'np_url' in settings and settings['np_url'] or None
        self.callback_url = "{}/api/vendor/np/callback".format(get_host())
        self.notify_url = "{}/api/vendor/np/notify".format(get_host())

        key = ":".join([self.mid, self.key]).encode()
        self.auth = base64.b64encode(key).decode()

        self.ccard = "ccard" in kwargs and kwargs["ccard"] or None
        self.cp = "cp" in kwargs and kwargs["cp"] or None
        self.cvs = "cvs" in kwargs and kwargs["cvs"] or None
        self.va = "va" in kwargs and kwargs["va"] or None
        self.pl = "pl" in kwargs and kwargs["pl"] or None

        customer = self.invoice_det.customer
        if customer:
            self.cust_kd = customer.kode
            self.cust_inv_no = self.invoice_det.cust_inv_no

        # if self.pay_method == "02" and is_devel():
        #     # self.mid = "VACTFOPEND"   # sama dgn yang lain
        #     key = ":".join([self.mid, self.key]).encode()
        #     self.auth = base64.b64encode(key).decode()

        self.va_typ = None
        self.reccuring = False
        self.amt = str(self.invoice_det.amt_sell)

    def set_static_params(self):
        if not self.cust_inv_no:
            return

        Nicepay.set('timeStamp', self.invoice_det.inv_time_stamp)  #
        Nicepay.set('iMid', self.mid)
        Nicepay.set('referenceNo', self.cust_inv_no)
        Nicepay.set('amt', str(self.invoice_det.amt_sell))
        Nicepay.merchantKey = self.key
        Nicepay.set('merchantToken', Nicepay.merchantToken())
        return True

    def set_billing_param(self):
        if not self.invoice_det:
            return

        Nicepay.set('payMethod', self.pay_method)
        Nicepay.set('currency', 'IDR')
        Nicepay.set('userIP', self.invoice_det.inv_cust_ip)
        Nicepay.set('dbProcessUrl', self.notify_url)
        Nicepay.set("userLanguage", "")
        Nicepay.set('reqClientVer', '')

        Nicepay.set('goodsNm', self.invoice_det.notes)
        Nicepay.set('billingNm', self.invoice_det.inv_cust_nm)
        Nicepay.set('billingPhone', self.invoice_det.inv_cust_phone)
        Nicepay.set('billingEmail', self.invoice_det.inv_cust_email)
        Nicepay.set('billingCity', self.invoice_det.inv_cust_city)
        Nicepay.set('billingState', self.invoice_det.inv_cust_state)
        Nicepay.set('billingPostCd', self.invoice_det.inv_cust_pos)
        Nicepay.set('billingCountry', self.invoice_det.inv_cust_country)
        Nicepay.set('amt', str(self.invoice_det.amt_sell))

        Nicepay.set('billingAddr', self.invoice_det.inv_cust_addr)
        Nicepay.set('description', self.invoice_det.notes)
        Nicepay.set('reqDomain', self.invoice_det.domain)
        Nicepay.set('reqServerIP', self.invoice_det.server_ip)
        Nicepay.set('userAgent', self.invoice_det.inv_cust_agent)
        Nicepay.set('userIP', self.invoice_det.inv_cust_ip)
        Nicepay.set('userSessionID', self.invoice_det.inv_cust_session)

        return True

    def set_optional_param(self):
        Nicepay.set('deliveryNm', self.invoice_det.delivery_nm)
        Nicepay.set('deliveryPhone', self.invoice_det.delivery_phone)
        Nicepay.set('deliveryAddr', self.invoice_det.delivery_addr)
        Nicepay.set('deliveryCity', self.invoice_det.delivery_city)
        Nicepay.set('deliveryState', self.invoice_det.delivery_state)
        Nicepay.set('deliveryPostCd', self.invoice_det.delivery_pos)
        Nicepay.set('deliveryCountry', self.invoice_det.delivery_country)
        Nicepay.set('reqClientVer', '')
        Nicepay.set('reqDt', self.invoice_det.req_dt)  # Format (YYYYMMDD)
        Nicepay.set('reqTm', self.invoice_det.req_tm)  # Format (HHiiss)

    def register(self):
        Nicepay.requestData = {}
        if not self.set_billing_param() or not self.set_static_params():
            return

        data = self.invoice_det.cart
        cart_data = data or {}
        Nicepay.set('cartData', cart_data)
        self.set_optional_param()
        # For Credit Card (Don't forgot change payMethod to '01')
        if self.pay_method == '01':
            Nicepay.set('recurrOpt', str(self.invoice_det.recurr_opt))
            Nicepay.set('instmntMon', str(self.invoice_det.instmnt_mon) or '')
            Nicepay.set('instmntType', str(self.invoice_det.instmnt_type) or '')
            vat = self.invoice_det.vat and int(self.invoice_det.vat) > 0 and \
                  str(self.invoice_det.vat) or ''
            fee = self.invoice_det.fee and int(self.invoice_det.fee) > 0 and \
                  str(self.invoice_det.fee) or ''
            Nicepay.set('vat', vat)
            Nicepay.set('fee', fee)
            no_tax_amt = self.invoice_det.notax_amt and \
                         int(self.invoice_det.notax_amt) > 0 and \
                         str(self.invoice_det.notax_amt) or ''

            Nicepay.set('notaxAmt', no_tax_amt)
        # For Virtual Account (Don't forgot change payMethod to '02')
        elif self.pay_method == '02':
            Nicepay.set('bankCd', self.bank_cd)
            Nicepay.set('vacctValidDt', self.invoice_det.inv_valid_date)
            Nicepay.set('vacctValidTm', self.invoice_det.inv_valid_time)
            if self.invoice_det.inv_cust_va:
                self.va_typ = 'fixed'
                # Nicepay.set('merFixAcctId', self.invoice_det.inv_cust_va)
            else:
                self.va_typ = 'float'
                # Nicepay.set('merFixAcctId', '')

            # merFixAcctId dikosongkan saja
            Nicepay.set('merFixAcctId', '')

        # For CVS
        # (Don't forgot change payMethod to '03'/'04'/'05')
        elif self.pay_method in ['03']:
            Nicepay.set('mitraCd', self.bank_cd)
            Nicepay.set('payValidDt', self.invoice_det.inv_valid_date)  # Format (YYYYMMDD)
            Nicepay.set('payValidTm', self.invoice_det.inv_valid_time)  # Format (HHiiss)

        # For Click Pay
        elif self.pay_method == '04':
            Nicepay.set('mitraCd', self.bank_cd)

        # E-Wallet
        elif self.pay_method == '05':
            Nicepay.set('mitraCd', self.bank_cd)

        # For Pay Loan
        elif self.pay_method == '06':
            Nicepay.set('recurrOpt', str(self.invoice_det.recurr_opt))
            Nicepay.set('instmntMon', str(self.invoice_det.instmnt_mon) or '')
            Nicepay.set('instmntType', str(self.invoice_det.instmnt_type) or '')
            Nicepay.set('mitraCd', self.bank_cd)
            Nicepay.set('payValidDt', self.invoice_det.inv_valid_date)  # Format (YYYYMMDD)
            Nicepay.set('payValidTm', self.invoice_det.inv_valid_time)  # Format (HHiiss)

        # Process to nice pay register
        self.request = Nicepay.requestData
        np_request = self.request
        np_request["cartData"] = json.dumps(np_request["cartData"])

        log.info("NP PRE REQUEST: {}".format(np_request))
        log.info("NP REQUEST: {}".format(json.dumps(np_request)))
        self.save_log('inquiry')
        result_data = Nicepay.niceRegister()
        response = json.loads(result_data)
        self.response = response
        log.info("NP RESPONSE: {}".format(json.dumps(self.response)))
        self.response = response
        self.save_log("inquiry")
        # Register Response String Format
        if 'resultCd' not in response:
            self.result = dict(
                error="Connection Timeout. Please Try Again!"
            )
            self.save_log(typ="inquiry")
            return
        else:
            result = dict()

        try:
            result_code = int(response['resultCd'])
        except:
            result_code = 999
        result["code"] = result_code
        result["message"] = response['resultMsg']
        if result_code == 0:  # or self.pay_method == '01':
            result["code"] = 0
            result["message"] = 'SUCCESS'
            time_stamp = datetime.now().strftime('%Y%m%d%H%M%S')
            key = sha256("{}{}".format(self.cust_inv_no, time_stamp))
            tx_id = "{}{}".format(self.invoice_det.customer.users.user_name, key)
            result["tx_id"] = tx_id
            result["invoice_no"] = response['referenceNo']
            result["amount"] = response['amt']
            result["trans_date"] = response['transDt']
            result["trans_time"] = response['transTm']
            result["description"] = response['description']
            self.invoice_det.trans_dt = response["transDt"]
            self.invoice_det.trans_tm = response["transTm"]
            self.invoice_det.tx_id = tx_id
            self.vend_inv_no = response["tXid"]

            if self.pay_method == "02":
                result["va"] = dict(
                    vacct_no=response['vacctNo'],
                    valid_date=response['vacctValidDt'],
                    valid_time=response['vacctValidTm'],
                )
                self.invoice_det.card_no = response['vacctNo']

            elif self.pay_method == "03":
                # CVS
                result["cvs"] = dict(
                    pay_no=response['payNo'],
                    valid_date=response['payValidDt'],
                    valid_time=response['payValidTm'],
                )
                self.invoice_det.card_no = response['payNo']

        self.result = result
        self.save_log(typ="inquiry")
        return dict(data=result)

    def payment(self, data):
        Nicepay.requestData = {}
        Nicepay.merchantKey = self.key
        self.set_static_params()
        url = "{}/payment".format(self.url)
        if self.pay_method == '01':
            if not req_fields(data, ["card_no", "callback_url", "card_exp",
                                     "card_name", "card_cvv"]):
                return
            self.invoice_det.card_no = data["card_no"]
            self.invoice_det.callback_url = data["callback_url"]
            flush_row(self.invoice_det)
            request_data = Nicepay.requestData
            script = """
                function submit_form(){
                    $("form[name='payment']").submit();
                }
                $(window).load(function(){
                    submit_form();
                });
                """
            # /api/merchant/payment
            form = """
                <form action="{url}" method="post" name="payment">
                     <input type="hidden" name="timeStamp" value="{time_stamp}">
                     <input type="hidden" name="tXid" value="{tx_id}">
                     <input type="hidden" name="merchantToken" value="{merchant_token}">
                     <input type="hidden" name="cardNo" value="{card_no}">
                     <input type="hidden" name="cardExpYymm" value="{card_exp}">
                     <input type="hidden" name="cardCvv" value="{card_cvv}">
                     <input type="hidden" name="cardHolderNm" value="{card_holder_nm}">
                     <input type="hidden" name="callBackUrl" value="{call_back_url}">
                </form>
                <script>
                    {script}
                </script>
                
                <noscript>Your browser does not support JavaScript!</noscript>
                """.format(
                url=url,
                time_stamp=self.invoice_det.inv_time_stamp,
                tx_id=self.invoice_det.vend_inv_no,
                merchant_token=request_data['merchantToken'],
                card_no=self.invoice_det.card_no,
                card_exp=str(data["card_exp"]),
                card_cvv=str(data["card_cvv"]),
                card_holder_nm=str(data["card_name"]),
                call_back_url=self.callback_url,
                script=script
            )

        elif self.pay_method == '04':
            if not req_fields(data, ["cp_no", "item3", "cp_token",
                                     "callback_url"]):
                return

            self.invoice_det.card_no = data["cp_no"]
            self.invoice_det.callback_url = data["callback_url"]
            flush_row(self.invoice_det)

            request_data = Nicepay.requestData
            script = """
                            function submit_form(){
                                $("form[name='payment']").submit();
                            }
                            $(window).load(function(){
                                submit_form();
                            });
                            """
            # /api/merchant/payment
            form = """
                    <form action="{url}" method="post" name="payment">
                         <input type="hidden" name="timeStamp" value="{time_stamp}">
                         <input type="hidden" name="tXid" value="{tx_id}">
                         <input type="hidden" name="clickPayNo" value="{cp_no}">
                         <input type="hidden" name="dataField3" value="{item3}">
                         <input type="hidden" name="clickPayToken" value="{cp_token}">
                         <input type="hidden" name="merchantToken" value="{merchant_token}">
                         <input type="hidden" name="callBackUrl" value="{call_back_url}">
                    </form>
                    <script>
                        {script}
                    </script>

                    <noscript>Your browser does not support JavaScript!</noscript>
                    """.format(
                url=url,
                time_stamp=self.invoice_det.inv_time_stamp,
                tx_id=self.invoice_det.vend_inv_no,
                merchant_token=request_data['merchantToken'],
                cp_no=self.invoice_det.card_no,
                item3=str(data["item3"]),
                cp_token=str(data["cp_token"]),
                call_back_url=self.callback_url,
                script=script
            )
        elif self.pay_method == '05':
            if not req_fields(data, ["callback_url"]):
                return

            self.invoice_det.callback_url = data["callback_url"]
            flush_row(self.invoice_det)

            request_data = Nicepay.requestData
            script = """
                            function submit_form(){
                                $("form[name='payment']").submit();
                            }
                            $(window).load(function(){
                                submit_form();
                            });
                            """
            # /api/merchant/payment
            form = """
                    <form action="{url}" method="post" name="payment">
                         <input type="hidden" name="timeStamp" value="{time_stamp}">
                         <input type="hidden" name="tXid" value="{tx_id}">
                         <input type="hidden" name="merchantToken" value="{merchant_token}">
                         <input type="hidden" name="callBackUrl" value="{call_back_url}">
                    </form>
                    <script>
                        {script}
                    </script>

                    <noscript>Your browser does not support JavaScript!</noscript>
                    """ \
                .format(url=url,
                        time_stamp=self.invoice_det.inv_time_stamp,
                        tx_id=self.invoice_det.vend_inv_no,
                        merchant_token=request_data['merchantToken'],
                        call_back_url=self.callback_url,
                        script=script
                        )
        else:
            form = """
                Payment Not Supported
            """

        self.request = data
        self.save_log("payment")
        return dict(form=form)

    def callback(self, data):
        self.response = data
        log.info("Payment Result: {}".format(data))
        self.result = get_result(self.response, self.pay_method)

        script = """
                        function submit_form(){
                            $("form[name='callback']").submit();
                        }
                        $(window).load(function(){
                            submit_form();
                        });
                        """
        # /api/merchant/payment
        f = ""
        result = self.result

        self.request = 'request' in self.invoice_det.payment and \
                       self.invoice_det.payment['request'] or ""
        self.save_log("payment")

        for r in result:
            if r and type(result[r]) == dict:
                rs = result[r]
                for s in rs:
                    f += '<input type="hidden" name="{k}" value="{v}">'.format(k=s, v=rs[s])
            else:
                f += '<input type="hidden" name="{k}" value="{v}">'.format(k=r, v=result[r])

        form = """
            <form action="{url}" method="post" name="callback">
                {f}
                 <button type="button" value="Submit" name="submit2">Submit</button>
            </form>
            <script>
                {script}
            </script>
            <noscript>Your browser does not support JavaScript!</noscript>
            """.format(
            url=self.invoice_det.callback_url,
            script=script,
            f=f
        )
        return dict(form=form)

    def advice(self):
        Nicepay.requestData = {}
        self.set_static_params()
        Nicepay.set("tXid", self.invoice_det.vend_inv_no)
        self.request = Nicepay.requestData
        log.info(self.request)
        self.save_log("advice")
        result_data = Nicepay.niceInquiry()

        response = json.loads(result_data)
        self.response = response
        log.info("NP RESPONSE: {}".format(json.dumps(self.response)))
        self.save_log("advice")

        # self.result = result
        self.result = get_result(self.response, self.pay_method)
        self.result["tx_id"] = self.invoice_det.tx_id
        self.save_log("advice")

    def cancel(self, data):
        Nicepay.requestData = {}
        self.set_static_params()
        payment = self.invoice_det.notify and "request" in self.invoice_det.notify  and \
                  self.invoice_det.notify["request"] or None
        if not payment:
            payment = self.invoice_det.payment["response"]

        Nicepay.set("payMethod", payment["payMethod"])
        Nicepay.set("cancelType", str(data["cancel_type"]))
        Nicepay.set("cancelMsg", data["cancel_msg"])
        pre_auth_token = "preAuthToken" in payment and payment["preAuthToken"] or ""
        Nicepay.set("preAuthToken", pre_auth_token)
        Nicepay.set("tXid", self.invoice_det.vend_inv_no)

        self.request = Nicepay.requestData
        log.info("CANCEL REUQEST: {}".format(self.request))
        self.save_log("cancel")
        result_data = Nicepay.niceCancel()

        response = json.loads(result_data)
        self.response = response
        log.info("CANCEL RESPONSE: {}".format(json.dumps(self.response)))
        self.save_log("cancel")

        # self.result = result
        self.result = get_result(self.response, self.pay_method)
        self.result["tx_id"] = self.invoice_det.tx_id
        self.save_log("cancel")

    def notify(self, data):
        amount = self.invoice_det.amt_sell
        vend_inv_no = self.invoice_det.vend_inv_no
        merchant_token = data["merchantToken"]
        signature = sha256("{mid}{vend_inv_no}{amount}{key}" \
                           .format(mid=self.mid, key=self.key, amount=str(amount),
                                   vend_inv_no=vend_inv_no))
        # print('>>>>', signature)
        if merchant_token != signature:
            return

        status = int(data['status'])
        if status == 0:
            # pembayaran sukses
            self.status = 1
        elif status == 1:
            # pembayaran gagal / reversal
            self.status = 2

        self.response = data

        self.result = get_result(self.response, self.pay_method)
        self.save_log("notify")
        return self.result


def get_result(response, pay_method):
    status = "status" in response and response['status'] and int(response["status"]) + 1 or 1
    try:
        code = int(response["resultCd"])
    except:
        code = 0

    try:
        message = response["resultMsg"]
    except:
        message = ''

    result = dict(
        code=code,
        message=message,
        # cancel_amt="cancelAmt" in response and int(response["cancelAmt"]) or 0,
        # deposit_date="depositDt" in response and response["depositDt"] or "",
        # deposit_time="depositTm" in response and response["depositTm"] or "",
        # tx_id= "",    # <= diisi tx_id merchant saat request register

    )
    if code!=0:
        return result

    result.update(dict(
        invoice_no="referenceNo" in response and response["referenceNo"] or "",
        amount="amt" in response and response["amt"] and int(response["amt"]) or 0,
        match_cl="matchCl" in response and response["matchCl"] and int(response["matchCl"]) or 0,
        status=status,
        trans_date="transDt" in response and response["transDt"] or "",
        trans_time="transTm" in response and response["transTm"] or "",
        currency="currency" in response and response["currency"] or "",
        description="goodsNm" in response and response["goodsNm"] or "",
        customer_nm="billingNm" in response and response["billingNm"] or "",
    ))
    if pay_method == "01":
        result.update(dict(
            credit_card=dict(
                auth_no="authNo" in response and response["authNo"] or "",
                issue_bank=response["issuBankCd"],
                issue_bank_nm='issuBankNm' in response and response["issuBankNm"] or "",
                acqu_bank=response["acquBankCd"],
                acqu_bank_nm='acquBankNm' in response and response["acquBankNm"] or "",
                acqu_status='acquStatus' in response and response["acquStatus"] or "",
                card_no='cardNo' in response and response["cardNo"] or "",
                card_exp='cardExpYymm' in response and response["cardExpYymm"] or "",
                instmnt_mon='instmntMon' in response and response["instmntMon"] or "",
                instmnt_tpe='instmntType' in response and response["instmntType"] or "",
                preauth_token='preauthToken' in response and response["preauthToken"] or "",
                recurring_token='recurringToken' in response and response["recurringToken"] or "",
                cc_trans_type='ccTransType' in response and response["ccTransType"] or "",
                vat="vat" in response and int(response["vat"]) or 0,
                fee="fee" in response and int(response["fee"]) or 0,
                no_tax_amt="notaxAmt" in response and int(response["notaxAmt"]) or 0,
            )
        ))

        """
        Additional Credit Card Response Json Object
        Parameter	    Type	Size	Description
        authNo	        N	10	Approval Number
        issuBankCd	    A	4	Issue Bank Code, refer Code at Here
        acquBankCd	    A	4	Acquire Bank Code, refer Code at Here
        cardNo	        AN	20	Card No with masking
        cardExpYymm	    N	4	card expiry(YYMM)
        instmntMon	    N	2	Installment month
        instmntType	    N	2	Installment Type, refer Code at Here
        preauthToken	AN	255	Pre-Auth Token (need for capture)
        recurringToken	AN	255	Recurring Token (Can use next payment)
        ccTransType	    AN	2	Credit Card Transaction Type
        acquStatus	    AN	2	Purchase Status
        1: Normal
        2: Recurring
        3: Pre-auth
        4: Capture
        vat	            N	12	Vat
        fee	            N	12	service fee
        notaxAmt	    N	12	tax free amount
        """
    elif pay_method == "02":
        """
        Additional Virtual Account Response Json Object
        Parameter	    Type	Size	Description
        bankCd	        AN	4	Bank Code, refer Code at Here
        vacctNo	        N	16	Bank Virtual Account number
        vacctValidDt	N	8	VA expiry date (YYYYMMDD)
        vacctValidTm	N	6	VA expiry time (HH24MISS)

        """
        result.update(dict(
            va=dict(
                vaacct_no=response["vacctNo"],
                valid_date=response["vacctValidDt"],
                valid_time=response["vacctValidTm"],
                deposit_date="depositDt" in response and response["depositDt"] or "",
                deposit_time="depositTm" in response and response["depositTm"] or "",
            )
        ))
    else:
        """
        Additional Others Response Json Object
        Parameter	Type	Size	Description
        mitraCd	    A	4	Mitra code, refer Code at Here
        (CVS, ClickPay, E-Wallet)
        payNo	    N	12	CVS number (CVS)
        payValidDt	N	8	CVS expiry date (YYYYMMDD) (CVS)
        payValidTm	N	6	CVS expiry time (HH24MISS) (CVS)
        mRefNo	    AN	20	Bank reference No (CVS)
        receiptCode	ANS	18	Authorization code (CVS)
        """
        other = dict(
            pay_no="payNo" in response and response["payNo"] or "",
            valid_date="payValidDt" in response and response["payValidDt"] or "",
            valid_time="payValidTm" in response and response["payValidTm"] or "",
            m_ref_no="mRefNo" in response and response["mRefNo"] or "",
            receipt_code="receiptCode" in response and response["receiptCode"] or "",
            deposit_date="depositDt" in response and response["depositDt"] or "",
            deposit_time="depositTm" in response and response["depositTm"] or "",
        )
        if pay_method == "03":
            result.update({"cvs": other})
        elif pay_method == "04":
            result.update({"cp": other})
        elif pay_method == "05":
            result.update({"wallet": other})
        else:
            result.update({"loan": other})
    return result


def req_fields(data, fields):
    for f in fields:
        if f not in data or not data[f]:
            return
    return True