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 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('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.cust_trx = cust_trx
        self.vend_trx =  None
        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

    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
        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

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

    ODEO will notify to affiliate if item has been successfully purchased or
    refunded.You can use any active url/IP you have to be registered, but ODEO
    suggests you to use a secure HTTPS. Please use "signature" parameter to
    validate any notification that come from ODEO. Compare the signature hash
    by generate the same hash by this following
    format:
    sha256({order_id} + {MID} + {SECRET_KEY} + {status}) [COMPLETED/REFUNDED]
    sha256({MID} + {SECRET_KEY} + {status}) [BROADCAST_NEW_PRICE]
    Also from "message" parameter, you can get data such as newest price of the
    product, and your current balance. Please refer to our apps to see all of
    message examples you can get from notify.Responded Status

    status	            reason
    COMPLETED	        item has successfully purchased
    REFUNDED	        purchase canceled, refunded to oCash balance
    BROADCAST_NEW_PRICE	there is new price for specific item
    """
    vendor_nm = request.matchdict['name']
    partner = Partner.query_kode(vendor_nm).first()
    if partner:
        row = PartnerLog()
        if vendor_nm=='odeoo':
            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