shop.py

"""
Scripts
read data from partner where partner_odoo not found
     and groups='shop_admin'
create company
create user company
jika shop_admin di grant ke Administrator POS administrator invoice
administrator inventory
Copy data coa dari ID_Company
Jika shop_user  di grant ke user POS user invoice
user inventory
buatkan apikey untuk user
nama api pos
update api_key pada opensipkd dengan api_key pada odoo

"""
import xmlrpc.client
from pyramid_rpc.jsonrpc import jsonrpc_method, JsonRpcError
from ziggurat_foundations.models.services.user import UserService

from opensipkd.base.models import Partner, DBSession
from opensipkd.base.models.partner import PartnerUserModel
from opensipkd.base.tools.api import auth_device, get_user_device, renew_token
from opensipkd.base.views.user_rpc import (
    register_user_, validasi_user, get_user)
from opensipkd.tools import create_now
from opensipkd.tools.api import (JsonRpcInvalidDataError, JsonRpcRegisterFailError,
                                 JsonRpcInvalidLoginError)
from .user import save_user
from ..models.partner_odoo import PartnerOdooModel


def flush(table):
    DBSession.add(table)
    DBSession.flush()


def get_partner(user):
    partner = Partner.query() \
        .join(PartnerUserModel, Partner.id == PartnerUserModel.partner_id) \
        .filter(PartnerUserModel.user_id == user.id).first()
    if not partner:
        raise JsonRpcInvalidDataError(message="Silahkan melengkapi Registrasi")
    return partner


def get_partner_odoo(user):
    partner = get_partner(user)
    partner_odoo = PartnerOdooModel.query().filter_by(partner_id=partner.id).first()
    if not partner_odoo:
        raise JsonRpcError(message="Database sedang disiapkan")
    return partner_odoo


class Odoo:
    def __init__(self, username, db, url, password):
        self.username = username
        self.db = db
        self.url = url
        self.password = password
        self.common = xmlrpc.client.ServerProxy('{}/xmlrpc/2/common'.format(url))
        self.models = xmlrpc.client.ServerProxy('{}/xmlrpc/2/object'.format(url))

    def auth(self):
        self.uid = self.common.authenticate(self.db, self.username,
                                            self.password, {})
        return self.uid

    def object(self, models, methods, params, optional=None):
        """
        the database to use, a string
        the user id (retrieved through authenticate), an integer
        the user’s password, a string
        the model name, a string
        the method name, a string
        an array/list of parameters passed by position
        a mapping/dict of parameters to pass by keyword (optional)
        """
        return self.models.execute_kw(self.db, self.username, self.password,
                                      models, methods, params, optional)


def get_user_(data):
    user = get_user(data)
    if not user.status:
        raise JsonRpcError(message="Silahkan aktivasi dulu")

    if not UserService.check_password(user, data['password']):
        raise JsonRpcInvalidLoginError
    user.last_login_date = create_now()
    flush(user)
    return user


@jsonrpc_method(method='register', endpoint='shop-api')
def register_owner(request, data):
    """
    Digunakan untuk registrasi pemilik toko
    :param request:
    :param data:{
        "user_name":str,
        "password":str,
        "email":str,
        "nama":str,
        "mobile",str
        "kode",str
    }
    :return:
    """
    user = register_user_(data, None, groups="shop_owner")
    partner = Partner.query_kode(user["kode"]).first()
    if not partner:
        raise JsonRpcError(message="Partner Not Found")
    partner_user = PartnerUserModel()
    partner_user.user_id = user["id"]
    partner_user.partner_id = partner.id
    flush(partner_user)
    return dict(message="Silahkan cek email untuk aktivasi", data=user)


@jsonrpc_method(method='login', endpoint='shop-api')
def login(request, data):
    user = get_user_(data)
    partner_odoo = get_partner_odoo(user)
    odoo = Odoo(user.email, partner_odoo.db, partner_odoo.url,
                data["password"])
    auth = odoo.auth()
    user_device = get_user_device(request, user)
    user_device = renew_token(user_device)
    data = {
        "token": user_device.token,
        "uid": auth
    }
    return dict(data=data)


@jsonrpc_method(method='adduser', endpoint='shop-api')
def adduser(request, data):
    """
    Digunakan untuk registrasi user yang lain
    :param request:
    :param data:{
        "user_name":str,
        "password":str,
        "email":str,
    }
    :return:
    """
    user = auth_device(request)
    if not ('user_name' in data and 'password' in data and 'email' in data
            and 'nama' in data and 'mobile' in data):
        raise JsonRpcInvalidDataError

    partner_odoo = get_partner_odoo(user)
    validasi_user(data)
    data['status'] = 0
    row = save_user(data, user=user)
    if not row:
        raise JsonRpcRegisterFailError

    partner_user = PartnerUserModel()
    partner_user.user_id = user["id"]
    partner_user.partner_id = partner_odoo.user_id
    flush(partner_user)
    # todo insert user ke odoo
    return dict(message="Silahkan cek email untuk aktivasi", data=data)


@jsonrpc_method(method='get_object', endpoint='shop-api')
def get_object(request, data):
    """
    Digunakan untuk login online
    :param request:
    :param data: dict {
        "user_name": str,
        "user_password": str
    }
    :return: data{
        "user_name": str,
        "token":str,
        "nik":str,
        "nama":str,
        "group":str
    }
    """
    user = auth_device(request)
    if not user.api_key:
        raise JsonRpcError("User Api key Not Found")
    partner_odoo = get_partner_odoo(user)
    odoo = Odoo(data["uid"], partner_odoo.db, partner_odoo.url, user.api_key)
    optional = "optional" in data and data["optional"] or {}
    result = odoo.object(data["models"], data["methods"], data["params"], optional)
    return dict(data=result)

#
# @jsonrpc_method(method='get_profile', endpoint='shop-api')
# def antrian_get_profile(request, data):
#     """
#         Digunakan untuk menampilkan profile user
#         :param request:
#         :param data: dict {
#             "user_name": str,
#             "user_password": str
#         }
#         :return: data{
#             "user_name": str,
#             "nik": str,
#             "email": str,
#             "mobile: str,
#             "nama": str,
#         }
#         """
#     user = auth_from_token(request)
#     return get_profile_(user)
#
#
# @jsonrpc_method(method='set_profile', endpoint='shop-api')
# def antrian_set_profile(request, data):
#     """
#     :param request:
#     :param data: dict {
#         "user_name": str,
#         "password" str,
#         "email": str,
#         "nama": str,
#         "mobile: str,
#         "nik": str,
#     }
#     :return:
#     """
#     user = auth_from_token(request)
#     return set_profile_(request, data)
#
#
# @jsonrpc_method(method='get_password', endpoint='shop-api')
# def antrian_get_password(request, data):
#     """
#
#     :param request:
#     :param data: {
#         "email": str
#     }
#     :return:
#     """
#     return get_password_(request, data)
#
#
# @jsonrpc_method(method='set_password', endpoint='shop-api')
# def antrian_set_password(request, data):
#     """
#     Digunakan untuk update data password
#     :param request:
#     :param token: str
#     :param data: dict {
#             "old_password": str,
#             "new_password":str,
#             "conf_password":str,
#         }
#
#     :return:
#         {
#         "token": str,
#         "data":null
#         }
#     """
#     user = auth_from_token(request)
#     data["password"] = data["old_password"]
#     token = user.security_code
#     return set_password_(token, data)
#
#
# @jsonrpc_method(method='get_departemen', endpoint='shop-api')
# def antrian_get_departemen(request, data):
#     """
#     Digunakan untuk mengambil data departemen
#     :param request:
#     :param data: dict {
#         "id":int  # optional
#     }
#     :return:
#         {
#             "data": [
#                 {"id": int, "nama": str},
#                 ...
#                 {"id": int, "nama": str},
#             ]
#         }
#     """
#     auth_from_token(request)
#     data = antrian_get_departemen_(data)
#     i = 0
#     for d in data["data"]:
#         print(d)
#         d["logo"] = f"{request.route_url('home')[:-1]}{d['logo']}"
#         data["data"][i] = d
#     i += 1
#     return data
#
#
# @jsonrpc_method(method='get_layanan', endpoint='shop-api')
# def antrian_get_layanan(request, data):
#     """
#     Digunakan untuk mengambil data layanan
#     :param request:
#     :param data: dict {
#         "id":int  # optional
#         "departemen_id":int  # optional
#     }
#     :return:
#         {
#             "data": [
#                 {"id": int, "nama": str, "departemen": str},
#                 ...
#                 {"id": int, "nama": str, "departemen": str},
#             ]
#         }
#     """
#     auth_from_token(request)
#     return antrian_get_layanan_(data)
#
#
# @jsonrpc_method(method='get_time', endpoint='shop-api')
# def antrian_get_time(request, data):
#     """
#     Digunakan untuk menampilkan waktu yang tersedia
#     Jika waktu<=0 harus di disable disisi user atu di hide
#     :param request:
#     :param data: dict{
#         "tanggal": str "YYYY-MM-DD",
#         "layanan_id":int,
#         "antrian_id": int optional
#     }
#     :return:
#         data: [
#             {"jam": str, "waktu":int},
#             ...
#             {"jam": str, "waktu":int},
#         ]
#     """
#     auth_from_token(request)
#     return antrian_get_time_(data)
#
#
# @jsonrpc_method(method='get_antrian', endpoint='shop-api')
# def antrian_get_antrian(request, data):
#     """
#         Digunakan untuk memperoleh data antrian
#         :param request:
#         :param data: dict{
#             "antrian_id": int
#             "user_id":int,
#         }
#         :return:
#             data: {
#                 "antrian_id": int,
#                 "departemen_id": int,
#                 "layanan_id": int,
#                 "tanggal": str "YYYY-MM-DD",
#                 "jam": str "HH",
#                 "durasi": int,
#                 "user_id": int,
#                 "departemen": str,
#                 "layanan": str
#             }
#         """
#     auth_from_token(request)
#     return antrian_get_antrian_(data)
#
#
# @jsonrpc_method(method='set_antrian', endpoint='shop-api')
# def antrian_set_antrian(request, data):
#     """
#         Digunakan untuk menyimpan data antrian
#         :param request:
#         :param data: dict{
#             "tanggal": str "YYYY-MM-DD",
#             "jam": str "hh"
#             "layanan_id":int,
#             "user_id":int,
#         }
#         :return:
#             data: {
#                 "tanggal": str "YYYY-MM-DD",
#                 "jam": str "hh"
#                 "layanan_id":int,
#                 "user_id":int,
#                 "kode": str
#             ]
#         """
#     user = auth_from_token(request)
#     return antrian_set_antrian_(request, data, user)
#
#
# @jsonrpc_method(method='set_report', endpoint='shop-api')
# def antrian_set_report(request, data):
#     """
#         Digunakan untuk menerima data antrian
#         :param request:
#         :param data: dict{
#             "jenis": Int,
#             "no_registrasi": Str,
#             "no_urut": Str,
#             "status": Int,
#             "departemen":str,
#             "layanan":str,
#             "tanggal": Str("YYYY-MM-DD"),
#             "mulai": Str("hh:mm"),
#             "selesai": Str("hh:mm",
#             "ikm": Array[
#                 {"kode": Str,
#                 "uraian": String,
#                 "nilai": Integer,
#                 },
#                 ....,
#                 {"uraian": String,
#                 "nilai": Integer,
#                 }
#             ]
#         }
#         :return:
#             data: {
#                 "message": str
#             ]
#         """
#     auth_from_token(request)
#     return antrian_set_report_(data)
#
#
# @jsonrpc_method(method='get_dashboard', endpoint='shop-api')
# def antrian_get_dashboard(request, data):
#     """
#         Digunakan untuk informasi dashboard
#         :param request:
#         :param data: dict{
#             "departemen_nama": str, # optional
#         }
#         :return:
#             data: {
#                 "tahun": int,
#                 "bulan": int,
#                 "minggu": int,
#                 "hari": int
#             }
#         """
#     auth_from_token(request)
#     return antrian_get_dashboard_(data)
#
#
# @jsonrpc_method(method='get_dep_report', endpoint='shop-api')
# def antrian_get_dep_report(request, data):
#     """
#         Digunakan untuk informasi dashboard
#         :param request:
#         :param data: dict{
#             "departemen_nm": str, # optional
#         }
#         :return:
#             data: {
#                 "departemen_nm": str,
#                 "tahun": int,
#                 "bulan": int,
#                 "minggu": int,
#                 "hari": int
#             }
#         """
#     auth_from_token(request)
#     return antrian_get_dep_report_(data)
#
#
# @jsonrpc_method(method='get_ikm', endpoint='shop-api')
# def antrian_get_ikm(request, data):
#     """
#     Digunakan untuk mengambil data ikm
#     :param request:
#     :param data: dict {
#         "departemen_nm":str  # optional
#     }
#     :return:
#         data: {
#                 "ikm_nm": str,
#                 "nilai": int
#             }
#     """
#     auth_from_token(request)
#     return antrian_get_ikm_(data)
#
#
# @jsonrpc_method(method='get_dep_ikm', endpoint='shop-api')
# def antrian_get_dep_ikm(request, data):
#     """
#     Digunakan untuk mengambil data ikm
#     :param request:
#     :param data: dict {
#         "departemen_nm":str  # optional
#     }
#     :return:
#         data: {
#                 "departemen_nm": str,
#                 "ikm": [
#                     {
#                         "ikm_nm": str,
#                         "nilai": int,
#                     }
#                 ]
#             }
#     """
#     auth_from_token(request)
#     return antrian_get_dep_ikm_(data)