vendor.py

"""
Module proses:
Save
Invoice To Vendor
Invoice To Customer
"""

import re
from datetime import datetime
from importlib import import_module

import colander
import requests
import xmltodict
from deform import widget, Form, ValidationFailure
from opensipkd.base.tools.api import JsonRpcParameterNotFound
from opensipkd.pasar.models import PartnerLog
from pyramid.httpexceptions import HTTPFound
from pyramid.renderers import render_to_response
from pyramid.view import view_config
import json

from . import BaseView  # , save_file_upload
from ..models import (DBSession, flush_row, Partner, PartnerProduk)
from ..models import (Produk, ProdukCategory)
from ..tools import (btn_next, date_from_str, get_settings, btn_reset,
                     btn_inquiry, btn_advice, btn_payment, get_random_number)


def vendor():
    return DBSession.query(Partner.id, Partner.nama)\
        .filter(Partner.is_vendor == 1).all()

def customer():
    return DBSession.query(Partner.id, Partner.nama)\
        .filter(Partner.is_customer == 1).all()

def produk():
    return DBSession.query(Produk.id, Produk.nama)\
        .join(ProdukCategory, Produk.kategori_id==ProdukCategory.id)\
        .filter(ProdukCategory.kode.in_(['e-pulsa', 'e-voucher', 'e-payment'])).all()


def build_request(typ, values):
    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

    vendor_product = PartnerProduk.query() \
        .join(Produk, PartnerProduk.produk_id==Produk.id) \
        .filter(PartnerProduk.partner_id == vendor_id,
                PartnerProduk.produk_id == produk_id).first()
    if not vendor_product:
        return dict(data = dict(error='Data Tidak Ditemukan'))

    row = None
    if "trx_id" in values and values['trx_id']:
        trx_id = int(values['trx_id'])
        row = PartnerLog.query().filter_by(id=trx_id).first()

    modules = import_module('.'+vendor_product.modules, 'agratek.api.merchant.views')

    cls_module = modules.Vendor(vendor_product, bill_no, customer_id,
                                cust_trx_id, row)

    cls = hasattr(cls_module, typ) and getattr(cls_module, typ) or None
    if cls:
        data = cls()
        result = dict(data=data)
        result["f_request"] = cls_module.request
        result["f_response"] = cls_module.response
        result["url"] = cls_module.url
    else:
        result = dict(data=dict(error='Fungsi %s tidak ada' % typ,
                                code=9999))
    return result

    # if typ=='inquiry':
    #     data = cls_module.inquiry()
    #     result =  dict(data=data)
    #     result["f_request"] = cls_module.request
    #     result["f_response"] = cls_module.response
    #     return result
    #
    # elif typ=='payment':
    #     data = cls_module.payment()
    #     result =  dict(data=data)
    #     result["f_request"] = cls_module.request
    #     result["f_response"] = cls_module.response
    #     return result
    #
    # elif typ == 'advice':
    #     data = hasattr(cls_module, typ) and cls_module.advice() or None
    #     result =  dict(data=data)
    #     result["f_request"] = cls_module.request
    #     result["f_response"] = cls_module.response
    #     return result
    #
    # elif typ == 'info':
    #     data = hasattr(cls_module, typ) and cls_module.info() or None
    #     result = dict(data=data)
    #     result["f_request"] = cls_module.request
    #     result["f_response"] = cls_module.reesponse
    #     return result
    # else:
    #     return dict(error='Function %s tidak ditemukan' % typ)


@colander.deferred
def deferred_vendor(node, kw):
    values = kw.get('vendor', [])
    return widget.SelectWidget(values=values)


@colander.deferred
def deferred_customer(node, kw):
    values = kw.get('customer', [])
    return widget.SelectWidget(values=values)


@colander.deferred
def deferred_produk(node, kw):
    values = kw.get('produk', [])
    return widget.SelectWidget(values=values)


class AddSchema(colander.Schema):
    produk_id = colander.SchemaNode(
        colander.Integer(), title='Produk',
        oid="produk_id", widget=deferred_produk)

    destination = colander.SchemaNode(
        colander.String(), title='No.Tujuan/ID Pelanggan',
        oid="destination", widget=widget.TextInputWidget())

    vendor_id = colander.SchemaNode(
        colander.Integer(), title='Vendor',
        oid="vendor_id", widget=deferred_vendor)
    trx_id = colander.SchemaNode(
        colander.String(), title='TRX ID',
        missing=colander.drop,
        oid="trx_id",
        widget=widget.TextInputWidget(css_class="readonly")
    )
    ref_no = colander.SchemaNode(
        colander.String(), title='REF. NO',
        missing=colander.drop,
        oid="ref_no",
        widget=widget.TextInputWidget(css_class="readonly")
    )

    vend_trx = colander.SchemaNode(
        colander.String(), title='TRX Vendor',
        missing=colander.drop,
        oid="vend_trx",
        widget=widget.TextInputWidget(css_class="readonly")
    )
    cust_trx = colander.SchemaNode(
        colander.String(), title='TRX Customer',
        missing=colander.drop,
        oid="cust_trx",
        widget=widget.TextInputWidget(css_class="readonly")
    )

    f_result = colander.SchemaNode(
        colander.String(), title='Result',
        missing=colander.drop,
        oid="result",
        widget=widget.TextAreaWidget(rows=10, css_class="readonly")
    )

    f_request = colander.SchemaNode(
        colander.String(), title='Request',
        missing=colander.drop,
        oid="result",
        widget=widget.TextAreaWidget(rows=10, css_class="readonly")
    )

    f_response = colander.SchemaNode(
        colander.String(), title='Response',
        missing=colander.drop,
        oid="result",
        widget=widget.TextAreaWidget(rows=10, css_class="readonly")
    )

class EditSchema(AddSchema):

    id = colander.SchemaNode(
        colander.Integer(), title='ID',
        missing=colander.drop,
        oid="id", widget=widget.HiddenWidget())


def form_validator(form, value):
    pass


def get_form(request, class_form, buttons=None, row=None):
    schema = class_form(validator=form_validator)
    schema = schema.bind(vendor=vendor(),
                         produk=produk())
    schema.request = request
    if row:
        schema.deserialize(row)
    if not buttons:
        buttons = (btn_inquiry, btn_reset)
    return Form(schema, buttons=buttons)



def route_list(request):
    return HTTPFound(location=request.route_url('simkel-permohonan'))


def save(values, row):
    if not row:
        row = Penduduk()
        kode = re.sub("\D", "", values["kode"])
        values['kode'] = kode
        values['is_vendor'] = 0
        values['is_customer'] = 1
        row.create_uid = values['uid']
        row.created = datetime.now()
    else:
        row.update_uid = values['uid']
        row.updated = datetime.now()

    row.from_dict(values)
    flush(row)
    return row



def save_request(request, values, row=None):
    values['tgl_lahir'] = date_from_str(values['tgl_lahir'])
    values['uid'] = request.user.id
    row = save(values, row)
    row_permohonan = Permohonan.query(). \
        filter(Permohonan.partner_id == row.id,
               Permohonan.status == 0,
               Permohonan.jenis_id == values['jenis_id']). \
        first()
    if not row_permohonan:
        row_permohonan = save_permohonan(values, row)

    request.session.flash('Data %s Berhasil disimpan' % values['nama'])
    return row_permohonan


form_params_edit = dict(scripts="""
$(document).ready(function(){
    $(".tanggal").datepicker({format:"dd-mm-yyyy"});
    $(".tanggal").attr("readonly", true);
    $(".readonly").attr("readonly", true);
});
""")

form_params_view = dict(scripts="""
$(document).ready(function(){
    $("#nip_penerima, #nopel").attr("readonly", true);
    $(".readonly").attr("readonly", true);
});
""")


def query_id(request):
    id = request.matchdict['id']
    return ApInvoice.query_id(id)


class ViewHome(BaseView):
    @view_config(route_name='api-vendor-doc',
                 permission="api-vendor-doc",
                 renderer='templates/vendor_doc.pt')
    def view_merchant_doc(self):
        return dict()

    @view_config(route_name='api-vendor-add',
                 permission="api-vendor-add",
                 renderer='templates/form.pt')
    def view_home(self):
        request = self.req
        session = self.ses
        form = get_form(request, AddSchema, (btn_inquiry, btn_payment, btn_advice, btn_next))
        # form_params = dict(scripts=None)
        settings = get_settings()
        if request.POST:
            controls = request.POST.items()
            try:
                c = form.validate(controls)
            except ValidationFailure as e:
                form.set_appstruct(e.cstruct)
                return dict(form=form, params=form_params_edit)

            values = dict(c.items())
            # if 'trx_id' not in values or not values['trx_id']:
            #     values['trx_id'] = get_random_number(10)
            # result = build_request('inquiry', values)
            #
            result = None
            if 'inquiry' in request.POST:
                result = build_request('inquiry', values)
            elif 'payment' in request.POST:
                result = build_request('payment', values)
            elif 'advice' in request.POST:
                result = build_request('advice', values)
            elif 'info' in request.POST:
                result = build_request('info', values)

            # if not result:
            #     session.flash('Data Tidak Ditemukan', 'error')

            if result and 'data' in result:
                data = result['data']
                values['f_request'] = 'f_request' in result \
                                      and json.dumps(result['f_request'], indent=4) or ''
                values['f_response'] = 'f_response' in result \
                                      and json.dumps(result['f_response'], indent=4) or ''

                values['f_result'] = 'data' in result \
                                      and json.dumps(result['data'], indent=4) or ''
                values['ref_no'] = 'ref_no' in data  and data["ref_no"] or ""
                values['trx_id'] = 'trx_id' in data and data['trx_id'] or ""
                values['vend_trx'] = 'vend_trx' in data and data['vend_trx'] or ""
                if 'error' in data and data['error']:
                    session.flash(data['error'], 'error')

            form.render(values)
            return dict(form=form, params=form_params_view)

        return dict(form=form, params=form_params_edit)

class VendorClass(object):
    def __init__(self, vendor_produk, bill_no, customer_id=None,
                 cust_trx=None, row=None):
        """
        :param cid:
            merupakan customer id seperti MSN dan atu id pelanggaan
        """

        self.settings = get_settings()
        self.vendor_id = vendor_produk.id
        self.produk_id = vendor_produk.produk_id
        self.bill_no = bill_no
        self.customer_id = customer_id
        self.response = None
        self.request = None
        self.partner_log = row
        self.partner_log_id = row and row.id or None
        self.v_produk_kd = vendor_produk.kode
        self.kategori = vendor_produk.produk.kategori.nama

        self.status = row and row.status or 0
        self.amt_buy = row and row.amt_buy or 0
        self.amt_sell = row and row.amt_sell or 0
        self.cust_trx = row and row.cust_trx or ""
        self.vend_trx = row and row.vend_trx or ""

    def save_log(self, typ):
        # if not self.partner_log:
        row = self.partner_log and self.partner_log or PartnerLog()
        row.vendor_id = self.vendor_id
        row.produk_id = self.produk_id
        row.bill_no = self.bill_no
        row.customer_id = self.customer_id

        row.cust_trx = self.cust_trx
        row.vend_trx = self.vend_trx
        row.status = self.status
        row.amt_buy = self.amt_buy
        row.amt_sell = self.amt_sell
        if typ == 'inquiry':
            row.inquiry = dict(request=self.request,
                       response=self.response)
        elif typ == 'payment':
            row.payment = dict(request=self.request,
                               response=self.response)
        elif typ == 'advice':
            row.advice = dict(request=self.request,
                               response=self.response)
        elif typ == 'info':
            row.info = dict(request=self.request,
                               response=self.response)

        flush_row(row)
        self.partner_log = row
        self.partner_log_id = row.id

    def get_product(self):
        pass

    def inquiry(self):
        pass

    def payment(self):
        pass

import hashlib

def sha256(hash_string):
    return  hashlib.sha256(hash_string.encode()).hexdigest()

def proses_odeo(request):
    settings = get_settings()
    data = json.loads('{a:1}')
    mid = 'odeo_mid' in settings and settings["odeo_mid"] or None
    key = 'odeo_key' in settings and settings["odeo_key"] or None
    partner = Partner.query_kode("ODEO").first()
    status = str(data["status"])
    if status == "BROADCAST_NEW_PRICE":
        signature = sha256("{mid}{key}{status}"\
                           .format(mid=mid, key=key, status=status))

        if signature!=data["signature"]:
            return

        new_price = data["new_price"]
        k, v = new_price
        row = PartnerProduk.query().filter_by(kode=k, partner_id=partner.id).first()
        if row:
            row.harga = v
            flush_row(row)
        return
    else:
        order_id = str(data["order_id"])
        signature = sha256("{order_id}{mid}{key}{status}"\
                           .format(order_id=order_id, mid=mid, key=key,
                                   status=status))
        if signature != data["signature"]:
            return

        order = PartnerLog.query()\
            .filter(vendor_id=partner.id, vend_trx=str(order_id)).first()

        if order:
            if status == "COMPLETED":
                order.status = 1
            else:
                order.status = -1
            flush_row(order)
            customer = Partner.query_id(order.customer_id).first()
            if customer and customer.url:
                users = customer.users
                url = customer.url
                c_data = dict(trx_id = order.cust_trx,
                              status = status,
                              signature = sha256(users.user_name+users.api_key))
                with requests.session():
                    requests.post(url, data=c_data)



@view_config(route_name='api-vendor-notify', renderer='json')
def api_vendor_notify(request):

    vendor_nm = request.matchdict['name']
    if vendor_nm == "odeo":
        proses_odeo(request)

    # if partner:
    #     row = PartnerLog()
    #
    #     if vendor_nm=='vsi':
    #         env = request.environ
    #         if not 'HTTP_SIGNATURE' in env:
    #             return JsonRpcParameterNotFound(message='SIGNATURE not found')
    #
    #         row.log=env['HTTP_SIGNATURE']
    #     row.partner_id = partner.id
    #     flush_row(row)

# from pyramid_xmlrpc import XMLRPCView, xmlrpc_response

import logging
log = logging.getLogger(__name__)

@view_config(route_name='api-vendor-test', renderer="string")
def vendor_test(request):
    params = request.params
    vendor = request.matchdict['vendor']
    result = dict(a=1)
    request.response.content_type = "text / xml"
    if vendor=="vsi":
        controls = request.GET.items()
        params = dict(controls)
        params["status"] = "SUCCESS"
        result = dict(root=params)
        result = xmltodict.unparse(result)
    elif vendor == "odeoo":
        params = json.loads(request.text)

        result = request.text
    return result