api.py

# from tangsel.pbb.models import *
# from sqlalchemy import func, or_, text, literal
# from sqlalchemy.sql import sqltypes

# from tangsel.tools.api import JsonRpcDataNotFoundError

# from tangsel.tools import round_up, ymd, date_from_str, datetime_from_str

# from tangsel.tools.pbb import FixNop, FixKelurahan, FixBlok

# from tangsel.base.tools.api import auth_from_rpc
# from pyramid_rpc.jsonrpc import jsonrpc_method
# import logging

# log = logging.getLogger(__name__)



# class ApiBase(object):
#     def __init__(self, request):
#         self.req = request
#         self.data = ''

#     def filter_dati2(self, qry, val):
#         kode = FixDati2(val)
#         return qry.filter_by(kd_propinsi=kode["kd_propinsi"],
#                              kd_dati2=kode["kd_dati2"],
#                              )

#     def filter_kecamatan(self, qry, val):
#         qry = self.filter_dati2(qry, val)
#         kode = FixKelurahan(val)
#         return qry.filter_by(kd_kecamatan=kode["kd_kecamatan"], )

#     def filter_desa(self, qry, val):
#         qry = self.filter_kecamatan(qry, val)
#         kode = FixKelurahan(val)
#         return qry.filter_by(kd_kelurahan=kode["kd_kelurahan"])

#     def filter_blok(self, qry, val):
#         qry = self.filter_desa(qry, val)
#         kode = FixBlok(val)
#         return qry.filter_by(kd_blok=kode["kd_blok"])

#     def filter_nop(self, qry, val):
#         qry = self.filter_blok(qry, val)
#         kode = FixNop(val)
#         return qry.filter_by(no_urut=kode["no_urut"],
#                              kd_jns_op=kode["kd_jns_op"])

#     def _get_filter(self, orm, data, *fields, paging=True, ):
#         qry = orm.query()
#         if "where" in data:
#             for w in data["where"]:
#                 key = w["key"]
#                 val = w["val"]
#                 if key == "nop":
#                     qry = self.filter_nop(qry, val)
#                 elif key == "blok":
#                     qry = self.filter_blok(qry, val)
#                 elif key == "desa":
#                     qry = self.filter_desa(qry, val)
#                 elif key == "kecamatan":
#                     qry = self.filter_kecamatan(qry, val)
#                 elif key == "dati2":
#                     qry = self.filter_dati2(qry, val)
#                 else:
#                     opr = "opr" in w and w["opr"] or "="
#                     if hasattr(orm, key):
#                         key = getattr(orm, key)
#                         if isinstance(key.type, sqltypes.String):
#                             key = func.trim(key)
#                         elif type(key.type) in [sqltypes.Date]:
#                             val = date_from_str(val)
#                         elif type(key.type) in [sqltypes.DateTime]:
#                             val = datetime_from_str(val)

#                         # qry = qry.filter( == val)
#                         # else:
#                         #     qry = qry.filter(key == val)
#                         if opr == "=":
#                             qry = qry.filter(key == val)
#                         elif opr == ">":
#                             qry = qry.filter(key > val)
#                         elif opr == "<":
#                             qry = qry.filter(key < val)
#                         elif opr == ">=":
#                             qry = qry.filter(key >= val)
#                         elif opr == "<=":
#                             qry = qry.filter(key <= val)

#         if "in_where" in data and data['in_where']:
#             if isinstance(data['in_where'], list):
#                 key = data['in_where'][0]["key"]
#                 val = data['in_where'][0]["val"]
#             else:
#                 key = data['in_where']["key"]
#                 val = data['in_where']["val"]
#             if hasattr(orm, key):
#                 key = getattr(orm, key)
#                 if isinstance(key.type, sqltypes.String):
#                     qry = qry.filter(func.trim(key).in_(val))
#                 else:
#                     qry = qry.filter(key.in_(val))

#         if "order" in data:
#             for o in data["order"]:
#                 if hasattr(orm, o):
#                     key = getattr(orm, o)
#                     qry = qry.order_by(key)
#         if fields:
#             qry = qry.select_from(*fields)

#         return qry

#     def get_filter(self, orm, data, *fields, paging=True, ):
#         qry = self._get_filter(orm, data, *fields)
#         total_page = page = 1
#         if paging:
#             page_size = "page_size" in data and int(data["page_size"]) or 20
#             if page_size > 0:
#                 page = "page" in data and int(data["page"]) or 1
#                 total_page = round_up(float(qry.count()) / float(page_size))
#                 if total_page and page > total_page:
#                     page = int(total_page)
#                 offset = (page - 1) * page_size
#                 qry = qry.offset(offset).limit(page_size)

#         result = []
#         row = qry.first()
#         if not row:
#             raise JsonRpcDataNotFoundError

#         for row in qry.all():
#             result.append(row.to_dict(True))

#         return dict(record=result,
#                     total_page=total_page,
#                     page=page)

#     def sql(self, data):
#         table = data.get("table")
#         where = data.get("where")


# class Api(ApiBase):

#     @jsonrpc_method(method='get', endpoint='pbb-api')
#     def get(self, data):
#         """
#         Digunakan untuk query data objek
#         @param data: dict
#         {
#             "table" : "", Class Table
#             "where" : [
#             {
#                 "key": field0,
#                 "value": value0,
#             },
#             {
#                 "key": field2,
#                 "value": value2,
#             },

#             ],
#             "order" : [
#                  field0, field1
#             },
#             "page": page_number, [optional default 1]
#             "page_size": page_size, [optional default 20]

#         }
#         @return: dict
#              List Of Objek Pajak
#         """
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         auth_from_rpc(request)
#         table = eval(data["table"])
#         result = self.get_filter(table, data)
#         return dict(data=result)

#     @jsonrpc_method(method='get_nop', endpoint='pbb-api')
#     def get_nop(self, data):
#         """
#         Digunakan untuk query data objek
#         @param data: dict
#         {
#             "where" : [
#             {
#                 "key": field0,
#                 "value": value0,
#             },
#             {
#                 "key": field2,
#                 "value": value2,
#             },

#             ],
#             "order" : [
#                  field0, field1
#             },
#             "page": page_number, [optional default 1]
#             "page_size": page_size, [optional default 20]

#         }
#         @return: dict
#              List Of Objek Pajak
#         """
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         auth_from_rpc(request)
#         result = self.get_filter(DatObjekPajak, data)
#         return dict(data=result)

#     @jsonrpc_method(method='get_sppt', endpoint='pbb-api')
#     def get_sppt(self, data):
#         """
#         Digunakan untuk query data SPPT
#         @param data: dict
#         {
#             "where" : [
#             {
#                 "key": field0,
#                 "value": value0,
#             },
#             {
#                 "key": field2,
#                 "value": value2,
#             },

#             ],
#             "order" : [
#                  field0, field1
#             },
#             "page": page_number, [optional default 1]
#             "page_size": page_size, [optional default 20]

#         }
#         @return: dict
#              List Of SPPT
#         """
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         auth_from_rpc(request)
#         # todo cek bila yang dikirim kode desa dan atau kode kecamatan backward compatibility
#         """
#         if len(r['kode'])==7: #kode= 7 digit berarti nop per kecamatan
#             rows = Sppt.get_nop_by_kecamatan(r['kode'],r['tahun']).all()
#         if len(r['kode'])==10: #kode= 10 digit berarti nop per desa
#             rows = Sppt.get_nop_by_kelurahan(r['kode'],r['tahun']).all()
#         else:
#             if 'tahun' in r and r['tahun']:
#                 rows = Sppt.get_nop_by_nop_thn(r['kode'],r['tahun']).all()"""
#         result = self.get_filter(Sppt, data)
#         return dict(data=result)

#     @jsonrpc_method(method='get_sppt_bersama', endpoint='pbb-api')
#     def get_sppt_bersama(self, data):
#         """
#         Digunakan untuk query data SPPT Bersama
#         @param data: dict
#         {
#             "where" : [
#             {
#                 "key": field0,
#                 "value": value0,
#             },
#             {
#                 "key": field2,
#                 "value": value2,
#             },

#             ],
#             "order" : [
#                  field0, field1
#             },
#             "page": page_number, [optional default 1]
#             "page_size": page_size, [optional default 20]

#         }
#         @return: dict
#              List Of SPPT
#         """
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         auth_from_rpc(request)
#         result = self.get_filter(SpptOpBersama, data)
#         return dict(data=result)

#     @jsonrpc_method(method='get_kelurahan', endpoint='pbb-api')
#     def get_kelurahan(self, data):
#         """
#         Digunakan untuk query data SPPT
#         @param data: dict
#         {
#             "where" : [
#             {
#                 "key": field0,
#                 "value": value0,
#             },
#             {
#                 "key": field2,
#                 "value": value2,
#             },

#             ],
#             "order" : [
#                  field0, field1
#             },
#             "page": page_number, [optional default 1]
#             "page_size": page_size, [optional default 20]

#         }
#         @return: dict
#              List Of SPPT
#         """
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         auth_from_rpc(request)
#         result = self.get_filter(Kelurahan, data)
#         return dict(data=result)

#     @jsonrpc_method(method='get_kecamatan', endpoint='pbb-api')
#     def get_kecamatan(self, data):
#         """
#         Digunakan untuk query data SPPT
#         @param data: dict
#         {
#             "where" : [
#             {
#                 "key": field0,
#                 "value": value0,
#             },
#             {
#                 "key": field2,
#                 "value": value2,
#             },

#             ],
#             "order" : [
#                  field0, field1
#             },
#             "page": page_number, [optional default 1]
#             "page_size": page_size, [optional default 20]

#         }
#         @return: dict
#              List Of SPPT
#         """
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         auth_from_rpc(request)
#         result = self.get_filter(Kecamatan, data)
#         return dict(data=result)

#     @jsonrpc_method(method='get_dati2', endpoint='pbb-api')
#     def get_dati2(self, data):
#         """
#         Digunakan untuk query data SPPT
#         @param data: dict
#         {
#             "where" : [
#             {
#                 "key": field0,
#                 "value": value0,
#             },
#             {
#                 "key": field2,
#                 "value": value2,
#             },

#             ],
#             "order" : [
#                  field0, field1
#             },
#             "page": page_number, [optional default 1]
#             "page_size": page_size, [optional default 20]

#         }
#         @return: dict
#              List Of SPPT
#         """
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         auth_from_rpc(request)
#         result = self.get_filter(Dati2, data)
#         return dict(data=result)

#     @jsonrpc_method(method='get_jenis_pelayanan', endpoint='pbb-api')
#     def get_jenis_pelayanan(self, data):
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         auth_from_rpc(request)
#         result = self.get_filter(JenisPelayanan, data)
#         return dict(data=result)

#     @jsonrpc_method(method='get_payment', endpoint='pbb-api')
#     def get_payment(self, data):
#         """
#         Digunakan untuk query data Pembayaran
#         @param data: dict
#         {
#             "where" : [
#             {
#                 "key": field0,
#                 "value": value0,
#             },
#             {
#                 "key": field2,
#                 "value": value2,
#             },

#             ],
#             "order" : [
#                  field0, field1
#             },
#             "page": page_number, [optional default 1]
#             "page_size": page_size, [optional default 20]

#         }
#         @return: dict
#              List Of SPPT
#         """
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         auth_from_rpc(request)
#         result = self.get_filter(PembayaranSppt, data)
#         return dict(data=result)

#     @jsonrpc_method(method='get_payment_by_date', endpoint='pbb-api')
#     def get_payment_by_date(self, data):
#         """
#         Digunakan untuk query data Rekap Pembayaran
#         @param data: dict
#         {
#             "where" : [
#             {
#                 "start": field0,
#                 "stop": value0,
#             }
#         }
#         @return: dict
#              List Of SPPT
#         """
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         # auth_from_rpc(request)
#         qry_sub = self._get_filter(PembayaranSppt, data,
#                                    paging=False).subquery()
#         qry = PbbDBSession.query(
#             func.sum(qry_sub.c.jml_sppt_yg_dibayar).label("bayar"),
#             func.sum(qry_sub.c.denda_sppt).label("denda"))
#         row = qry.first()
#         if not row:
#             raise JsonRpcDataNotFoundError

#         data = dict(record=[{"pokok": row.bayar - row.denda,
#                              "denda": row.denda,
#                              "bayar": row.bayar}])

#         return dict(data=data)

#     def call_proc_func(self, name, vars, type='proc'):
#         engine = PbbDBSession.get_bind()
#         connection = engine.raw_connection()
#         try:
#             cursor = connection.cursor()
#             if type=='func':
#                 cursor.callfunc(name, vars)
#             else:
#                 cursor.callproc(name, vars, out)
#             results = list(cursor.fetchall())
#             cursor.close()
#             connection.commit()
#             return results
#         finally:
#             connection.close()
    
#     @jsonrpc_method(method='run_proc', endpoint='pbb-api')
#     def run_proc(self, data):
#         """
#         Digunakan untuk running proc
#         @param data: dict
#         [
#             {
#                 "proc_name":"",
#                 "vars":"",
#             },
#             {
#                 "proc_name":"",
#                 "vars":"",
#             },
#         ]
#         @return: dict
#         {
#             "proc_name":"",
#             "proc_name":""
#         }
#         """
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         auth_from_rpc(request)
#         data = (type(data) is list) and data or [data]
#         result = []
#         for d in data:
#             res = self.call_proc_func(d['proc_name'],d['vars'])
#             if res:
#                 result.append({d['proc_name']:res})
#             else:
#                 result.append({d['proc_name']:'Failed'})
#         return dict(data=result)
        
#     @jsonrpc_method(method='run_func', endpoint='pbb-api')
#     def run_func(self, data):
#         """
#         Digunakan untuk running proc
#         @param data: dict
#         [
#             {
#                 "func_name":"",
#                 "vars":"",
#             },
#             {
#                 "func_name":"",
#                 "vars":"",
#             },
#         ]
#         @return: dict
#         {
#             "func_name":"",
#             "func_name":""
#         }
#         """
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         auth_from_rpc(request)
#         data = (type(data) is list) and data or [data]
#         result = []
#         for d in data:
#             res = self.call_proc_func(d['func_name'],d['vars'],type='func')
#             if res:
#                 result.append({d['func_name']:res})
#             else:
#                 result.append({d['func_name']:'Failed'})
#         return dict(data=result)
        
#     @jsonrpc_method(method='get_kode_sppt', endpoint='pbb-api')
#     def get_kode_sppt(self, data):
#         """
#         Digunakan untuk running proc
#         @param data: dict
#         {
#                 "kd_propinsi":"",
#                 "kd_dati2":"",
#                 "kd_kecamatan":"",
#                 "kd_kelurahan":"",
#                 "kd_blok":"",
#                 "no_urut":"",
#                 "kd_jns_op":"",
#                 "thn_pajak_sppt":""
#         }
#         @return: dict
#         {
#             "kode_sppt":""
#         }
#         """
#         self.data = data
#         request = self.req
#         log.warning("Req from {}: {}".format(request.client_addr, self.data))
#         auth_from_rpc(request)

#         kode_sppt = PbbDBSession.query(func.concat(func.concat(func.concat(func.concat(literal('#'),func.substr(
#             func.coding_sppt(Sppt.kd_propinsi,Sppt.kd_dati2,\
#             Sppt.kd_kecamatan,Sppt.kd_kelurahan,Sppt.kd_blok,Sppt.no_urut,Sppt.kd_jns_op,\
#             Sppt.thn_pajak_sppt,Sppt.kd_kanwil,Sppt.kd_kantor,Sppt.nm_wp_sppt,Sppt.pbb_yg_harus_dibayar_sppt,\
#             '1'),0,24)),'ES/'),func.trim(func.to_char(Sppt.siklus_sppt,literal('00')))),literal('#'))\
#             .label('kode_sppt'))\
#             .filter(Sppt.kd_propinsi == self.data['kd_propinsi'],
#                     Sppt.kd_dati2 == self.data['kd_dati2'], 
#                     Sppt.kd_kecamatan == self.data['kd_kecamatan'],
#                     Sppt.kd_kelurahan == self.data['kd_kelurahan'], 
#                     Sppt.kd_blok == self.data['kd_blok'],
#                     Sppt.no_urut == self.data['no_urut'],
#                     Sppt.kd_jns_op == self.data['kd_jns_op'], 
#                     Sppt.thn_pajak_sppt == self.data['thn_pajak_sppt'])\
#             .scalar()
#         if kode_sppt:
#             log.debug('Kode SPPT : {}'.format(kode_sppt))
#             return dict(data=kode_sppt)
            
#         return dict(data={})

# CODE_OK = '00'
# CODE_DATA_INVALID = '55'


# # url /rpc/pbb
# @jsonrpc_method(method='isppt', endpoint='pbb-api')
# def isppt(request, data):
#     # Digunakan untuk informasi sppt
#     # parameter nop, [tahun], [count]
#     resp, ws_user = auth_from_rpc(request)
#     if resp['code'] != 0:
#         return resp
#     ret_data = []
#     for dat in data:
#         sppt = Sppt.query_nop(dat['nop'])
#         if 'tahun' in dat and dat['tahun']:
#             sppt = sppt.filter(Sppt.thn_pajak_sppt == dat['tahun'])
#         if 'count' in dat and dat['count']:
#             sppt = sppt.limit(int(dat['count']))
#         rows = sppt.all()  # order_by(Sppt.thn_pajak_sppt.desc()).all()

#         for row in rows:
#             bayar = PembayaranSppt.query_bayar(row.nop,
#                                                row.thn_pajak_sppt).first()
#             denda = bayar and bayar.denda or 0
#             pokok = row.pbb_yg_harus_dibayar_sppt
#             bayar1 = bayar and bayar.bayar or 0
#             sisa = pokok - (bayar1 - denda)
#             ret_data.append(
#                 dict(nop=row.nop,
#                      tahun=row.thn_pajak_sppt,
#                      luas_bumi=row.luas_bumi_sppt,
#                      luas_bng=row.luas_bng_sppt,
#                      pokok=pokok,
#                      denda=denda,
#                      bayar=bayar1,
#                      sisa=sisa,
#                      tgl_byr=bayar and bayar.tanggal and bayar.tanggal.strftime(
#                          '%d-%m-%Y') or '',
#                      jth_tempo=row.tgl_jatuh_tempo_sppt.strftime('%d-%m-%Y')
#                      )
#             )

#     if not ret_data:
#         return dict(code=CODE_DATA_INVALID, message='Data Tidak Ditemukan')

#     return dict(code=CODE_OK, message='Sukses Ambil Data SPPT', data=ret_data)


# @jsonrpc_method(method='iop', endpoint='pbb-api')
# def iop(request, data):
#     # Digunakan untuk informasi objek pajak
#     # parameter nop
#     user = auth_from_rpc(request)
#     ret_data = []
#     for dat in data:
#         row = DatObjekPajak.query_id(dat['nop']).first()
#         if row:
#             dom = DatOpAnggota.query_id(dat['nop']).first()
#             ret_data.append(
#                 dict(nop=row.nop,
#                      jalan=row.jalan_op,
#                      blok=row.blok_kav_no_op,
#                      rw=row.rw_op,
#                      rt=row.rt_op,
#                      luas_bumi=row.total_luas_bumi,
#                      luas_bng=row.total_luas_bng,
#                      njop_bumi=row.njop_bumi,
#                      njop_bng=row.njop_bng,
#                      luas_bumi_bersama=dom and dom.luas_bumi_beban or 0,
#                      luas_bng_bersama=dom and dom.luas_bng_beban or 0,
#                      njop_bumi_bersama=dom and dom.njop_bumi_beban or 0,
#                      njop_bng_bersama=dom and dom.njop_bng_beban or 0,
#                      )
#             )

#     if not ret_data:
#         raise JsonRpcDataNotFoundError

#     return dict(code=CODE_OK, message='Sukses Ambil Data Objek Pajak',
#                 data=ret_data)