Tambah query

CHANGES.txt

+0.1.1 2019-05-27
+----------------
+- Tambah default model siap pakai.
+- Tambah query.
+
 0.1 2019-01-20
 0.1 2019-01-20
 --------------
 --------------
 - Kali pertama.
 - Kali pertama.

setup.py

@@ -8,6 +8,9 @@ with open(os.path.join(here, 'README.rst')) as f:
 with open(os.path.join(here, 'CHANGES.txt')) as f:
 with open(os.path.join(here, 'CHANGES.txt')) as f:
     CHANGES = f.read()
     CHANGES = f.read()
 
 
+line = CHANGES.splitlines()[0]
+version = line.split()[0]
+
 requires = [
 requires = [
     'sqlalchemy',
     'sqlalchemy',
     ]
     ]
@@ -15,13 +18,23 @@ requires = [
 
 
 setup(
 setup(
     name='sismiop-models',
     name='sismiop-models',
-    version='0.1',
+    version=version,
     description='Struktur tabel SISMIOP',
     description='Struktur tabel SISMIOP',
     long_description=README + '\n\n' + CHANGES,
     long_description=README + '\n\n' + CHANGES,
     author='Owo Sugiana',
     author='Owo Sugiana',
     author_email='sugiana@gmail.com',
     author_email='sugiana@gmail.com',
     license='PostgreSQL License',
     license='PostgreSQL License',
-    packages=['sismiop.models'],
+    packages=[
+        'sismiop.models',
+        'sismiop.models.default',
+        'sismiop.services',
+        'sismiop.services.default',
+        'sismiop.scripts'],
     install_requires=requires,
     install_requires=requires,
     zip_safe=False,
     zip_safe=False,
+    entry_points={
+        'console_scripts': [
+            'pbb_available_invoice = sismiop.scripts.available_invoice:main',
+            ]
+        }
     )
     )

sismiop/models/default/__init__.py

+from sqlalchemy.ext.declarative import declarative_base
+from ..sppt import SpptMixin
+from ..pembayaran_sppt import PembayaranSpptMixin
+from ..kelurahan import KelurahanMixin
+from ..kecamatan import KecamatanMixin
+from ..propinsi import PropinsiMixin
+
+
+Base = declarative_base()
+
+
+class Sppt(Base, SpptMixin):
+    pass
+
+
+class PembayaranSppt(Base, PembayaranSpptMixin):
+    pass
+
+
+class Kelurahan(Base, KelurahanMixin):
+    pass
+
+
+class Kecamatan(Base, KecamatanMixin):
+    pass
+
+
+class Propinsi(Base, PropinsiMixin):
+    pass

sismiop/scripts/available_invoice.py

+import sys
+from configparser import ConfigParser
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+import sismiop.services
+from sismiop.services.default import AvailableInvoice
+
+
+def main(argv=sys.argv):
+    conf_file = argv[1]
+    conf = ConfigParser()
+    conf.read(conf_file)
+    db_url = conf.get('main', 'db_url')
+    persen_denda = conf.getfloat('main', 'persen_denda')
+    engine = create_engine(db_url)
+    session_factory = sessionmaker(bind=engine)
+    sismiop.services.DBSession = session_factory()
+    a = AvailableInvoice(persen_denda)
+    a.show()

sismiop/services/__init__.py

+DBSession = None
+
+
+def get_db_session(db_session=None):
+    return db_session or DBSession

sismiop/services/default/__init__.py

+from sismiop.models.default import (
+    Sppt,
+    PembayaranSppt,
+    Kelurahan,
+    Kecamatan,
+    Propinsi,
+    )
+from ..sppt import (
+    CalculateInvoice as BaseCalc,
+    AvailableInvoice as BaseAvailableInvoice,
+    )
+
+
+class CalculateInvoice(BaseCalc):
+    def __init__(
+            self, persen_denda, propinsi, kabupaten, kecamatan, kelurahan,
+            blok, urut, jenis, tahun):
+        BaseCalc.__init__(
+            self, Sppt, PembayaranSppt, persen_denda, propinsi, kabupaten,
+            kecamatan, kelurahan, blok, urut, jenis, tahun, Kelurahan,
+            Kecamatan, Propinsi)
+ 
+
+class AvailableInvoice(BaseAvailableInvoice):
+    def __init__(self, persen_denda):
+        BaseAvailableInvoice.__init__(self, Sppt, PembayaranSppt, persen_denda)

sismiop/services/sppt.py

+from time import time
+from datetime import date
+from sqlalchemy import func
+import locale
+from opensipkd.hitung import (
+    hitung_denda,
+    round_up,
+    )
+from . import get_db_session 
+
+
+locale.setlocale(locale.LC_ALL, 'id_ID.utf8')
+
+
+def thousand(n):
+    return locale.format('%0.f', n, True)
+
+
+class Query:
+    def __init__(
+            self, Sppt, Pembayaran, Kelurahan=None, Kecamatan=None,
+            Propinsi=None):
+        self.Sppt = Sppt
+        self.Pembayaran = Pembayaran
+        self.Kelurahan = Kelurahan
+        self.Kecamatan = Kecamatan
+        self.Propinsi = Propinsi
+        self.DBSession = get_db_session()
+
+    def query_invoice(
+            self, propinsi, kabupaten, kecamatan, kelurahan, blok, urut, jenis,
+            tahun):
+        return self.DBSession.query(self.Sppt).filter_by(
+                kd_propinsi=propinsi, kd_dati2=kabupaten,
+                kd_kecamatan=kecamatan, kd_kelurahan=kelurahan, kd_blok=blok,
+                no_urut=urut, kd_jns_op=jenis, thn_pajak_sppt=tahun)
+
+    def query_payment(
+            self, propinsi, kabupaten, kecamatan, kelurahan, blok, urut, jenis,
+            tahun):
+        return self.DBSession.query(self.Pembayaran).filter_by(
+                kd_propinsi=propinsi, kd_dati2=kabupaten,
+                kd_kecamatan=kecamatan, kd_kelurahan=kelurahan, kd_blok=blok,
+                no_urut=urut, kd_jns_op=jenis, thn_pajak_sppt=tahun)
+
+    def invoice2payment(self, inv):
+        q = self.query_payment(
+                inv.kd_propinsi, inv.kd_dati2, inv.kd_kecamatan,
+                inv.kd_kelurahan, inv.kd_blok, inv.no_urut, inv.kd_jns_op,
+                inv.thn_pajak_sppt)
+        q = q.order_by(self.Pembayaran.pembayaran_sppt_ke.desc())
+        return q.first()
+
+    def nama_kelurahan(self, propinsi, kabupaten, kecamatan, kelurahan):
+        q = self.DBSession.query(self.Kelurahan).filter_by(
+                kd_propinsi=propinsi, kd_dati2=kabupaten,
+                kd_kecamatan=kecamatan, kd_kelurahan=kelurahan)
+        r = q.first()
+        return r and r.nm_kelurahan or ''
+
+    def nama_kecamatan(self, propinsi, kabupaten, kecamatan):
+        q = self.DBSession.query(self.Kecamatan).filter_by(
+                kd_propinsi=propinsi, kd_dati2=kabupaten,
+                kd_kecamatan=kecamatan)
+        r = q.first()
+        return r and r.nm_kecamatan or ''
+
+    def nama_propinsi(self, propinsi):
+        q = self.DBSession.query(self.Propinsi).\
+                filter_by(kd_propinsi=propinsi)
+        r = q.first()
+        return r and r.nm_propinsi or ''
+
+    def is_available(self):
+        return self.invoice.status_pembayaran_sppt == '1'
+
+    def is_paid(self):
+        return self.is_available()
+
+
+
+def get_id(row):
+    return ''.join(
+                [row.kd_propinsi, row.kd_dati2, row.kd_kecamatan,
+                 row.kd_kelurahan, row.kd_blok, row.no_urut, row.kd_jns_op,
+                 row.thn_pajak_sppt])
+
+
+class CalculateInvoice(Query):
+    def __init__(
+            self, Sppt, Pembayaran, persen_denda, propinsi, kabupaten,
+            kecamatan, kelurahan, blok, urut, jenis, tahun, Kelurahan=None,
+            Kecamatan=None, Propinsi=None):
+        Query.__init__(self, Sppt, Pembayaran, Kelurahan, Kecamatan, Propinsi)
+        self.persen_denda = persen_denda
+        self.propinsi = propinsi
+        self.kabupaten = kabupaten
+        self.kecamatan = kecamatan
+        self.kelurahan = kelurahan
+        self.blok = blok
+        self.urut = urut
+        self.jenis = jenis
+        self.tahun = tahun
+        self.invoice = self.invoice_tahun(tahun)
+        if self.invoice:
+            self.hitung()
+
+    def nama_kelurahan(self):
+        inv = self.invoice
+        return Query.nama_kelurahan(
+                self, inv.kd_propinsi, inv.kd_dati2, inv.kd_kecamatan,
+                inv.kd_kelurahan)
+
+    def nama_kecamatan(self):
+        inv = self.invoice
+        return Query.nama_kecamatan(
+                self, inv.kd_propinsi, inv.kd_dati2, inv.kd_kecamatan)
+
+    def nama_propinsi(self):
+        return Query.nama_propinsi(self, self.invoice.kd_propinsi)
+
+    def is_paid(self):
+        return self.total < 1
+
+    def is_available(self):
+        return not self.is_paid() and \
+            self.invoice.status_pembayaran_sppt in ('0', '1')
+
+    def invoice_tahun(self, tahun):
+        q = self.query_invoice(
+                self.propinsi, self.kabupaten, self.kecamatan, self.kelurahan,
+                self.blok, self.urut, self.jenis, tahun)
+        return q.first()
+
+    def hitung_invoice(self, invoice):
+        q = self.DBSession.query(
+                    func.sum(self.Pembayaran.jml_sppt_yg_dibayar).
+                    label('jml_sppt_yg_dibayar'),
+                    func.sum(self.Pembayaran.denda_sppt).
+                    label('denda_sppt')).\
+                    filter_by(kd_propinsi=invoice.kd_propinsi,
+                              kd_dati2=invoice.kd_dati2,
+                              kd_kecamatan=invoice.kd_kecamatan,
+                              kd_kelurahan=invoice.kd_kelurahan,
+                              kd_blok=invoice.kd_blok,
+                              no_urut=invoice.no_urut,
+                              kd_jns_op=invoice.kd_jns_op,
+                              thn_pajak_sppt=invoice.thn_pajak_sppt)
+        bayar = q.first()
+        jml_bayar = bayar.jml_sppt_yg_dibayar or 0
+        denda_lalu = bayar.denda_sppt or 0
+        sisa = float(jml_bayar - denda_lalu)
+        tagihan = round_up(invoice.pbb_yg_harus_dibayar_sppt - sisa)
+        kini = date.today()
+        bln_tunggakan, denda = hitung_denda(
+            tagihan, invoice.tgl_jatuh_tempo_sppt, self.persen_denda, kini)
+        denda = round_up(denda)
+        return tagihan, denda, bln_tunggakan, kini
+
+    def hitung(self):
+        self.tagihan, self.denda, self.bln_tunggakan, self.kini = \
+            self.hitung_invoice(self.invoice)
+        self.total = self.tagihan + self.denda
+
+    def set_paid(self):
+        self.invoice.status_pembayaran_sppt = '1'  # Lunas
+
+    def create_payment(self, denda, tgl_bayar, bank_fields, nip_pencatat):
+        bayar = self.invoice2payment()
+        if bayar:
+            ke = bayar.pembayaran_sppt_ke + 1
+        else:
+            ke = 1
+        bayar = self.Pembayaran()
+        bayar.kd_propinsi = self.invoice.kd_propinsi
+        bayar.kd_dati2 = self.invoice.kd_dati2
+        bayar.kd_kecamatan = self.invoice.kd_kecamatan
+        bayar.kd_kelurahan = self.invoice.kd_kelurahan
+        bayar.kd_blok = self.invoice.kd_blok
+        bayar.no_urut = self.invoice.no_urut
+        bayar.kd_jns_op = self.invoice.kd_jns_op
+        bayar.thn_pajak_sppt = self.invoice.thn_pajak_sppt
+        bayar.pembayaran_sppt_ke = ke
+        bayar.tgl_rekam_byr_sppt = datetime.now()
+        bayar.tgl_pembayaran_sppt = tgl_bayar
+        bayar.jml_sppt_yg_dibayar = self.total
+        bayar.denda_sppt = denda
+        bayar.nip_rekam_byr_sppt = nip_pencatat
+        bayar.from_dict(bank_fields)
+        self.set_paid()
+        self.before_save(bayar)
+        self.DBSession.add(self.invoice)
+        self.DBSession.add(bayar)
+        self.DBSession.flush()
+        return bayar, ke
+
+    def before_save(self, bayar):
+        pass
+
+    # Override
+    def invoice2payment(self):
+        return Query.invoice2payment(self, self.invoice)
+
+    def get_id(self):
+        return get_id(self.invoice)
+
+
+class AvailableInvoice:
+    def __init__(self, Sppt, Pembayaran, persen_denda=2, count=10):
+        self.count = count
+        self.Sppt = Sppt
+        self.Pembayaran = Pembayaran
+        self.persen_denda = persen_denda
+
+    def show(self):
+        Sppt = self.Sppt
+        offset = -1
+        no = 0
+        db_session = get_db_session()
+        awal = time()
+        while True:
+            durasi = time() - awal
+            if durasi > 10:
+                break
+            offset += 1
+            q = db_session.query(Sppt).filter_by(status_pembayaran_sppt='0')
+            q = q.order_by(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)
+            q = q.offset(offset).limit(1)
+            row = q.first()
+            if not row:
+                continue
+            calc = CalculateInvoice(
+                    self.Sppt, self.Pembayaran, self.persen_denda,
+                    row.kd_propinsi, row.kd_dati2, row.kd_kecamatan,
+                    row.kd_kelurahan, row.kd_blok, row.no_urut, row.kd_jns_op,
+                    row.thn_pajak_sppt)
+            if calc.is_paid():
+                continue
+            invoice_id = calc.get_id()
+            no += 1
+            msg = '#{} {} Pokok Rp {} + Denda Rp {} = Rp {}'.format(
+                    str(no).zfill(2), invoice_id, thousand(calc.tagihan),
+                    thousand(calc.denda), thousand(calc.total))
+            print(msg)
+            if no == self.count:
+                break