pbb.py

# Tools PBB Constanta yang digunakan di PBB karena dalam PBB primary Key
# Banyak terdiri dari beberapa field
# from types import (
# StringType,
# UnicodeType)
from sqlalchemy import func

from ..tools import FixLength, get_settings
# from models import pbbDBSession
# from models.ref import TempatPembayaran
# from models.pegawai import DatLogin
from datetime import timedelta, datetime
from math import ceil
import re

from . import left, right

PROPINSI = [('kd_propinsi', 2, 'N'), ]

DATI2 = list(PROPINSI)
DATI2.append(('kd_dati2', 2, 'N'))

KECAMATAN = list(DATI2)
KECAMATAN.append(('kd_kecamatan', 3, 'N'))

KELURAHAN = list(KECAMATAN)
KELURAHAN.append(('kd_kelurahan', 3, 'N'))

BLOK = list(KELURAHAN)
BLOK.append(('kd_blok', 3, 'N'))

NOP = list(BLOK)
NOP.extend([('no_urut', 4, 'N'),
            ('kd_jns_op', 1, 'N')])

SPPT = list(NOP)
SPPT.append(('thn_pajak_sppt', 4, 'N'))

KANTOR = [('kd_kanwil', 2, 'N'),
          ('kd_kantor', 2, 'N')]

BANK = list(KANTOR)
BANK.append(('kd_tp', 2, 'N'))
BANK_SISMIOP = [
    ('kd_kanwil_bank', 2, 'N'),
    ('kd_kppbb_bank', 2, 'N'),
    ('kd_bank_tunggal', 2, 'N'),
    ('kd_bank_persepsi', 2, 'N'),
    ('kd_tp', 2, 'N'),
]

BAYAR = list(SPPT)
BAYAR.append(('pembayaran_sppt_ke', 3, 'N'))
BAYAR.extend(BANK)

SIKLUS = list(SPPT)
SIKLUS.append(('siklus_sppt', 3, 'N'))

NOPEL = list(KANTOR)
NOPEL.extend([('tahun', 4, 'N'),
              ('bundel', 4, 'N'),
              ('urut', 3, 'N')])
NOPELDET = list(NOPEL)
NOPELDET.extend(list(NOP))

AGENDA = [('thn_agenda_kirim', 4, 'N'),
          ('kd_seksi', 2, 'N'),
          ('no_agenda_kirim', 4, 'N')]

BERKAS = list(NOPELDET)
BERKAS.extend(list(AGENDA))

FORMULIR = [('tahun', 4, 'N'),
            ('bundel', 4, 'N'),
            ('urut', 3, 'N')]


def get_value(obj, struct):
    raw = ""
    for name, typ, size in struct:
        raw += obj[name]
    return raw


class SetFixLength(FixLength):
    def __init__(self, raw, struct):
        super(SetFixLength, self).__init__(struct)
        raw = re.sub("\D", "", raw)
        self.set_raw(raw)
        for name, typ, size in struct:
            setattr(self, name, self[name])


class BaseFixLength(SetFixLength):
    def __init__(self, raw):
        super(BaseFixLength, self).__init__(raw, self.get_structure())
        raw = re.sub("\D", "", raw)
        self.set_raw(raw)

    def get_structure(self):
        pass


class FixDati2(BaseFixLength):
    def get_structure(self):
        return DATI2


class FixKecamatan(BaseFixLength):
    def get_structure(self):
        return KECAMATAN


class FixKelurahan(BaseFixLength):
    def get_structure(self):
        return KELURAHAN


class FixBlok(BaseFixLength):
    def get_structure(self):
        return BLOK


class FixKantor(BaseFixLength):
    def get_structure(self):
        return KANTOR


class FixBank(BaseFixLength):
    def get_structure(self):
        return BANK


class FixBankSismiop(BaseFixLength):
    def get_structure(self):
        return BANK_SISMIOP


class FixNop(BaseFixLength):
    def get_structure(self):
        return NOP

    def get_formatted(self):
        s = ''
        for name, size, typ in self.struct:
            v = self.get_value(name, typ)
            pad_func = typ == 'N' and right or left
            s += pad_func(v, size)
            if len(s) in [5, 11, 19]:
                s += "-"
            else:
                s += "."

        return s[:-1]


class FixSppt(BaseFixLength):
    def get_structure(self):
        return SPPT


class FixSiklus(BaseFixLength):
    def get_structure(self):
        return SIKLUS


class FixBayar(BaseFixLength):
    def get_structure(self):
        return BAYAR

    def get_sppt(self):
        return get_value(self, SPPT)

    def get_bank(self):
        return get_value(self, BANK)


class FixNopel(BaseFixLength):

    def get_structure(self):
        return NOPEL

    def get_kantor(self):
        return get_value(self, KANTOR)


class FixNopelDetail(BaseFixLength):
    def get_structure(self):
        return NOPELDET

    def get_nopel(self):
        return get_value(self, NOPEL)

    def get_nop(self):
        return get_value(self, NOP)


class FixAgenda(BaseFixLength):
    def get_structure(self):
        return AGENDA


class FixBerkas(BaseFixLength):
    def get_structure(self):
        return BERKAS

    def get_nopel(self):
        return get_value(self, NOPEL)

    def get_nop(self):
        return get_value(self, NOP)

    def get_nopel_det(self):
        return get_value(self, NOPELDET)

class FixFormulir(BaseFixLength):
    def get_structure(self):
        return FORMULIR

########### baru untuk penagihan ###########
UPTD = list(DATI2)
UPTD.append(('kd_uptd', 2, 'N'))

class FixUptd(BaseFixLength):
    def get_structure(self):
        return UPTD

############################################

def ensure_datetime(d):
    """
    Takes a date or a datetime as input, outputs a datetime
    """
    if isinstance(d, datetime):
        return d
    return datetime(d.year, d.month, d.day)


def hitung_denda(piutang_pokok, jatuh_tempo, tanggal=None, max_denda=24):
    persen_denda = 2
    # jatuh_tempo = jatuh_tempo.date()
    if not tanggal:
        tanggal = datetime.now().date()

    if ensure_datetime(tanggal) < ensure_datetime(
            jatuh_tempo):  # + timedelta(days=1):
        return 0

    kini = datetime.now()
    x = (kini.year - jatuh_tempo.year) * 12
    y = kini.month - jatuh_tempo.month
    bln_tunggakan = x + y + 1
    if kini.day <= jatuh_tempo.day:
        bln_tunggakan -= 1
    if bln_tunggakan < 1:
        bln_tunggakan = 0
    if bln_tunggakan > max_denda:
        bln_tunggakan = max_denda

    return int(ceil(bln_tunggakan * persen_denda / 100.0 * piutang_pokok))


def nop_formatted(row):
    if type(row) == str:
        row = FixNop(row)
    return "%s.%s-%s.%s-%s.%s.%s" % (
    row.kd_propinsi, row.kd_dati2, row.kd_kecamatan,
    row.kd_kelurahan, row.kd_blok, row.no_urut, row.kd_jns_op)


def nop_to_id(row):
    if type(row) in (StringType, UnicodeType):
        row = FixNop(row)
    return "%s%s%s%s%s%s%s" % (row.kd_propinsi, row.kd_dati2, row.kd_kecamatan,
                               row.kd_kelurahan, row.kd_blok, row.no_urut,
                               row.kd_jns_op)


def query_nop(table):
    return func.concat(table.kd_propinsi, '.', table.kd_dati2, '-',
                       table.kd_kecamatan,'.',table.kd_kelurahan, '-',
                       table.kd_blok, '.',table.no_urut, '-',
                       table.kd_jns_op)


# JEnis REstitusi Kompensasi
JNS_RESKOM = (
    (0, 'Pilih Jenis'),
    (1, 'Restitusi'),
    (2, 'Kompensasi'),
    (3, 'Disumbangkan'),
    (4, 'Koreksi'),)

JENIS_ID = (
    (1, 'Tagihan'),
    (2, 'Piutang'),
    (3, 'Ketetapan'))

SUMBER_ID = (
    (4, 'Manual'),
    (1, 'PBB'),
)

# def daftar_tp():    
# return pbbDBSession.query(TempatPembayaran.kd_tp,TempatPembayaran.nm_tp).\
# order_by(TempatPembayaran.kd_tp).all()

STATUS_KOLEKTIF = (
    (0, 'Individu'),
    (1, 'Kolektif'),
)

JENIS_PENGURANGAN = (
    (0, '(None)'),
    (1, 'Pengurangan Permanen'),
    (2, 'Pengurangan PST'),
    (3, 'Pengurangan Pengenaan JPB'),
    (5, 'Pengurangan Sebelum SPPT Terbit')
)

JENIS_SALINAN = (
    ('0', 'SPPT'),
    ('1', 'SKP Terhadap SPOP'),
    ('2', 'SKP Kurang Bayar')
)

JENIS_TRANSAKSI_SPOP = (
    ('11', 'Perekaman Data OP'),
    ('12', 'Pemutakhiran Data OP'),
    ('13', 'Penghapusan OP'),
    ('14', 'Penghapusan Status OP Bersama'),
)

JENIS_TRANSAKSI_LSPOP = (
    ('21', 'Perekaman Data Bangunan'),
    ('22', 'Pemutakhiran Data Bangunan'),
    ('23', 'Penghapusan Data Bangunan'),
    ('24', 'Penilaian Individu'),
)


def get_date_triwulan(tahun, tri):
    tglawal = tahun
    tglakhir = tahun
    simbol = ""
    if tri == "4":
        tglawal += "-10-01"
        tglakhir += "-12-31"
        simbol = "IV"
    elif tri == "2":
        tglawal += "-04-01"
        tglakhir += "-06-30"
        simbol = "II"
    elif tri == "3":
        tglawal += "-07-01"
        tglakhir += "-09-30"
        simbol = "III"
    else:
        tglawal += "-01-01"
        tglakhir += "-03-31"
        simbol = "I"

    return [tglawal, tglakhir, simbol]


BUKUS = {
    '11': ("Buku 1", 1, 100000),
    '12': ("Buku 1,2", 1, 500000),
    '13': ("Buku 1,2,3", 1, 2000000),
    '14': ("Buku 1,2,3,4", 1, 5000000),
    '15': ("Buku 1,2,3,4,5", 1, 999999999),
    '22': ("Buku 2", 100001, 500000),
    '23': ("Buku 2,3", 100001, 2000000),
    '24': ("Buku 2,3,4", 100001, 5000000),
    '25': ("Buku 2,3,4,5", 100001, 999999999),
    '33': ("Buku 3", 500001, 2000000),
    '34': ("Buku 3,4", 500001, 5000000),
    '35': ("Buku 3,4,5", 500001, 999999999),
    '44': ("Buku 4", 2000001, 5000000),
    '45': ("Buku 4,5", 2000001, 999999999),
    '55': ("Buku 5", 5000001, 999999999),
}


def bukus_sorted():
    from operator import itemgetter
    return sorted(BUKUS.items(), key=itemgetter(1))


def pbb_biller():
    settings = get_settings()
    return settings['pbb_biller']


def pbb_kantor():
    settings = get_settings()
    return settings['pbb_kantor']


def pbb_pemda():
    settings = get_settings()
    return settings['pbb_pemda']


def filter_nop(qry, nop, tahun=None):
    nop = FixNop(nop)
    qry = qry.filter_by(
        kd_propinsi=nop["kd_propinsi"],
        kd_dati2=nop["kd_dati2"],
        kd_kecamatan=nop["kd_kecamatan"],
        kd_kelurahan=nop["kd_kelurahan"],
        kd_blok=nop["kd_blok"],
        no_urut=nop["no_urut"],
        kd_jns_op=nop["kd_jns_op"], )
    if tahun:
        qry = qry.filter_by(thn_pajak_sppt=tahun)
    return qry


# def filter_nop(qry, param, cls=None):
#     nop = FixNop(param)
#     if cls:
#         return qry.filter(
#             cls.kd_propinsi==nop["kd_propinsi"],
#             cls.kd_dati2==nop["kd_dati2"],
#             cls.kd_kecamatan==nop["kd_kecamatan"],
#             cls.kd_kelurahan==nop["kd_kelurahan"],
#             cls.kd_blok==nop["kd_blok"],
#             cls.no_urut==nop["no_urut"],
#             cls.kd_jns_op==nop["kd_jns_op"],)
#
#     return qry.filter_by(
#         kd_propinsi=nop["kd_propinsi"],
#         kd_dati2=nop["kd_dati2"],
#         kd_kecamatan=nop["kd_kecamatan"],
#         kd_kelurahan=nop["kd_kelurahan"],
#         kd_blok=nop["kd_blok"],
#         no_urut=nop["no_urut"],
#         kd_jns_op=nop["kd_jns_op"],
#     )

def pbb_nip(user_name):
    if user_name == 'admin' or user_name == 'pbb-admin':
        return '060000000000000000'
    from opensipkd.pbb.models import PbbDBSession, DatLogin
    row = PbbDBSession.query(DatLogin). \
        filter_by(nm_login=user_name.upper()).first()
    if row:
        return row.nip
    return