Skip to content

aa.gusti / tangsel-base

Go to a project
Commit 2709ab62 by aa.gustiana@gmail.com
Options

upload

1 parent b95d0001
Expand all
Inline Side-by-side
Showing 69 changed files with 3913 additions and 3 deletions
.gitignore
......@@ -92,6 +92,7 @@ celerybeat-schedule
# virtualenv
.venv
venv/
venv*/
ENV/
# Spyder project settings
......@@ -120,3 +121,5 @@ alembic_local.ini
.vs*
activate
development.ini
production.ini
development.ini
......@@ -43,7 +43,7 @@ temp_files = C:\tmp
captcha_files = C:\tmp\captcha
partner_doc = C:\\tmp\\docs\\partner\\
;home_tpl = tangsel.samsat.jabar.views:templates/login.pt
;login_tpl = tangsel.samsat.jabar.views:templates/login.pt
login_tpl = tangsel.base.views:templates/login.pt
login_captcha = 0
# Registrasi User
......@@ -95,6 +95,8 @@ map_center =
menus = login:Login
/pbb/esppt:ESPPT
/pbbm:PBB-MONITORING
/bphtb:BPHTB
/esptpd:e-SPTPD
;app_name = GAJI ASN
;change_unit = False
......
pyproject.toml
......@@ -13,8 +13,8 @@ exclude = [
show_error_codes = true
[project]
name = 'tangsel_base'
version = '0.1'
name = 'tangsel_apps'
version = '2025-0.1'
dependencies = [
'deform',
'colander',
......@@ -36,6 +36,7 @@ dependencies = [
'wheezy.captcha',
'ziggurat-foundations',
'zope.sqlalchemy',
'opensipkd-tools'
]
requires-python = '>= 3.8'
authors = [
......
tangsel/base/scripts/data/routes.csv
......@@ -8,6 +8,7 @@ base-password-request,/password/{code}/request,base,user_login,ViewPassword,chan
base-profile,/profile,base,register,,view_profile,,,,Profile,1,0,,0,form8.pt,
base-register,/register,base,register,,view_register,,,,Register,1,0,,0,form8.pt,
base-recreate-api-key,/recreate-api-key,base,register,ViewPassword,recreate-api-key,,,,Get Api Key,1,0,,0,recreate-api-key.pt,
base-upload-logo,/upload/logo,base,,,,,,,Upload Logo,1,0,,0,,
base-admin,#,base,,,,,view,,Administrator,1,0,,1,,
base-user,/user,base,user,,view_list,,user-view,base-admin,User,1,0,,1,form.pt,
base-user-act,/user/{act}/act,base,user,,,,user-view,base-user,User Action,1,0,,,json,
......
tangsel/base/views/templates/upload.pt 0 → 100644
<html metal:use-macro="load: main.pt">
<!-- content -->
<div metal:fill-slot="content">
<div class="row">
<div class="panel panel-default">
<div class="panel-body">
<div class="col-md-10 col-md-offset-1">
<div tal:content="structure form"/>
</div>
</div>
</div>
</div>
</div>
<!-- end content -->
</html>
\ No newline at end of file
tangsel/base/views/upload.py 0 → 100644
import os
import colander
from deform import (Form, widget, FileData, )
from deform.interfaces import FileUploadTempStore
from pyramid.httpexceptions import HTTPFound
from pyramid.view import view_config
from opensipkd.tools import (get_ext, dict_to_str, )
from .base_views import CSRFSchema
def route_list(request, p={}):
q = dict_to_str(p)
return HTTPFound(location=request.route_url('upload-logo', _query=q))
##########
# Unggah #
##########
# class UploadLogo(SaveFile):
# def save(self, fs):
# input_file = fs.file
# ext = get_ext(fs.filename)
# fullpath = self.create_fullpath(ext)
# output_file = open(fullpath, 'wb')
# input_file.seek(0)
# while True:
# data = input_file.read(2 << 16)
# if not data:
# break
# output_file.write(data)
# output_file.close()
# return fullpath
tmpstore = FileUploadTempStore()
class AddSchema(CSRFSchema):
upload = colander.SchemaNode(
FileData(),
widget=widget.FileUploadWidget(tmpstore),
title='Unggah')
image_for = colander.SchemaNode(
colander.String(),
widget=widget.SelectWidget(values=(('oth', "Other"), ('logo', "Logo"),
('bg', "Background"))),
title='Peruntukan')
def get_form(request, schema_cls):
schema = schema_cls()
schema = schema.bind(request=request)
return Form(schema, buttons=('simpan', 'batal'))
@view_config(route_name='base-upload-logo',
renderer='templates/upload.pt',
permission='upload-logo', require_csrf=True)
def view_file(request):
form = get_form(request, AddSchema)
if request.POST:
if 'simpan' in request.POST:
input_file = request.POST['upload'].file
filename = request.POST['upload'].filename.lower()
ext = get_ext(filename).lower()
if ext.lower() not in ['.png', '.ico']:
request.session.flash("File harus format 'png' atau 'ico'", 'error')
return dict(form=form.render())
_here = os.path.dirname(__file__)
static_path = os.path.join(os.path.dirname(_here), 'static')
fname = filename
if request.POST["image_for"] == "logo":
fname = f"logo{ext}"
elif request.POST["image_for"] == "bg":
fname = f"background{ext}"
typ = ext == '.png' and "img" or 'icon'
folder = os.path.join(static_path, typ)
if not os.path.exists(folder):
os.makedirs(folder)
fullpath = os.path.join(folder, fname)
output_file = open(fullpath, 'wb')
input_file.seek(0)
while True:
data = input_file.read(2 << 16)
if not data:
break
output_file.write(data)
request.session.flash(f"Sukses upload {fname}")
return route_list(request)
return dict(form=form.render())
tangsel/pdl/models/__init__.py 0 → 100644
from sqlalchemy.orm import relationship, backref
from sqlalchemy import Column, String, Integer, Text, ForeignKey
from opensipkd.models import (
DBSession, Base, CommonModel, DefaultModel, NamaModel, StandarModel)
import logging
PAD_TABLE_ARGS = {"schema": "pad"}
PUBLIC_TABLE_ARGS = {"schema": "public"}
_logging = logging.getLogger(__name__)
def includeme(config):
_logging.info('include pjdl.models')
from .rekening import PjdlRekening
from .kecamatan import *
from .kelurahan import PjdlKelurahan
from .usaha import PjdlUsaha
from .pajak import PjdlPajak, PjdlPajakTarif
from .spt_type import PjdlSptType
from .tblpemda import PjdlPemda
from .tp import PjdlTp
from .airtanah import *
from .reklame import *
from .pejabat import PjdlPejabat
from .customer import PjdlWp
from .customer_usaha import PjdlOp, PjdlOpHotel
from .registrasi import *
from .spt_invoice import PjdlInvoice
from .sspd_payment import PjdlPayment
from .stpd import PjdlStpd
from .kohir import *
from .reklame_hitung import PjdlReklameHitung
from .reports import PjdlReports, PjdlReportItems, REPORT_CATEGORY, REPORT_DICT
from .spt_tegur import PjdlSptTegur
from .uptd import *
from .spt_air import *
from .spt_reklame import *
tangsel/pdl/models/airtanah.py 0 → 100644
from sqlalchemy import (
Column,
Integer,
String,
Float,
)
from sqlalchemy.orm import column_property
from sqlalchemy.ext.hybrid import hybrid_property
from opensipkd.models import Base, DefaultModel, NamaModel
schema = 'pad'
class KodeModel(DefaultModel):
@classmethod
def query_kode(cls, kode):
return cls.query().filter(cls.kode == kode)
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.nama.ilike(f"{nama}%"))
class PjdlAirtanahJenisManfaat(Base, KodeModel):
__tablename__ = 'pad_at_jenis_manfaat'
id = Column(Integer, primary_key=True)
kode = Column(String(3))
nm_jenis_pemanfaatan = Column(String(255))
bobot = Column(Float)
__table_args__ = dict(schema=schema)
@hybrid_property
def nama(cls):
return cls.nm_jenis_pemanfaatan
@classmethod
def query_register(cls, order_field="id"):
return cls.query_from(columns =[cls.kode.label('Kode'),
cls.nm_jenis_pemanfaatan.label('Nama'),
cls.bobot.label('Bobot')])
class PjdlAirtanahJenisSumber(Base, KodeModel):
__tablename__ = 'pad_at_jenis_sumber'
id = Column(Integer, primary_key=True)
kode = Column(String(3))
nm_jenis_sumber_air = Column(String(255))
nilai_indeks = Column(Float)
harga_air_baku = Column(Integer)
__table_args__ = dict(schema=schema)
@hybrid_property
def nama(cls):
return cls.nm_jenis_sumber_air
@classmethod
def get_nilai(cls, values):
row = cls.query().filter(
cls.id == values["air_jenis_sumber_id"],
).first()
return row
@classmethod
def query_register(cls, order_field="id"):
return cls.query_from(columns =[cls.kode.label('Kode'),
cls.nm_jenis_sumber_air.label('Nama'),
cls.nilai_indeks.label('Nilai Indeks'),
cls.harga_air_baku.label('Kualitas')])
class PjdlAirtanahKomponenPemulihan(Base, KodeModel):
__tablename__ = 'pad_at_komponen_pemulihan'
id = Column(Integer, primary_key=True)
jenis_manfaat_id = Column(Integer)
volume_id = Column(Integer)
nilai_indeks = Column(Float)
bobot = Column(Float)
nilai_komponen = Column(Float)
__table_args__ = dict(schema=schema)
@classmethod
def get_nilai(cls, values):
return cls.query_from(columns=[cls.id, cls.jenis_manfaat_id, cls.volume_id,
cls.nilai_indeks, cls.bobot, cls.nilai_komponen,
PjdlAirtanahVolume.nm_volume,
PjdlAirtanahVolume.batas_min,
PjdlAirtanahVolume.batas_max]). \
join(PjdlAirtanahVolume, PjdlAirtanahVolume.id == cls.volume_id). \
filter(cls.jenis_manfaat_id == values["air_manfaat_id"]).\
order_by(PjdlAirtanahVolume.batas_min)
@classmethod
def query_register(cls, order_field="id"):
return cls.query_from(columns =[PjdlAirtanahJenisManfaat.nm_jenis_pemanfaatan.label('Jenis Manfaat'),
PjdlAirtanahVolume.nm_volume.label('Volume'),
cls.nilai_indeks.label('Nilai Indeks'),
cls.bobot.label('Bobot'),
cls.nilai_komponen.label('Nilai Komponen')]). \
outerjoin(PjdlAirtanahJenisManfaat, PjdlAirtanahJenisManfaat.id ==
PjdlAirtanahKomponenPemulihan.jenis_manfaat_id).\
outerjoin(PjdlAirtanahVolume, PjdlAirtanahVolume.id ==
PjdlAirtanahKomponenPemulihan.volume_id). \
order_by(getattr(cls, order_field))
class PjdlAirtanahKualitas(Base, KodeModel):
__tablename__ = 'pad_at_kualitas'
id = Column(Integer, primary_key=True)
kode = Column(String(3))
nm_kualitas = Column(String(255))
nilai_indeks = Column(Float)
kualitas = Column(Integer)
alternatif = Column(Integer)
bobot = Column(Float)
komponen_sda = Column(Float)
__table_args__ = dict(schema=schema)
@hybrid_property
def nama(cls):
return cls.nm_kualitas
@classmethod
def get_nilai(cls, values):
row = cls.query().filter(
cls.id == values["air_kualitas_id"],
).first()
return row
@classmethod
def query_register(cls, order_field="id"):
return cls.query_from(columns =[cls.kode.label('Kode'),
cls.nm_kualitas.label('Nama'),
cls.nilai_indeks.label('Nilai Indeks'),
cls.kualitas.label('Kualitas'),
cls.alternatif.label('Alternatif'),
cls.bobot.label('Bobot'),
cls.komponen_sda.label('Komponen SDA')])
class PjdlAirtanahSumberAlternatif(Base, KodeModel):
__tablename__ = 'pad_at_sumber_alternatif'
id = Column(Integer, primary_key=True)
kode = Column(String(3))
nm_sumber_alternatif = Column(String(255))
nilai_indeks = Column(Float)
__table_args__ = dict(schema=schema)
@hybrid_property
def nama(cls):
return cls.nm_sumber_alternatif
@classmethod
def get_nilai(cls, values):
row = cls.query().filter(
cls.id == values["air_sumber_id"],
).first()
return row
@classmethod
def query_register(cls, order_field="id"):
return cls.query_from(columns =[cls.kode.label('Kode'),
cls.nm_sumber_alternatif.label('Nama'),
cls.nilai_indeks.label('Nilai Indeks')])
class PjdlAirtanahVolume(Base, KodeModel):
__tablename__ = 'pad_at_volume'
id = Column(Integer, primary_key=True)
kode = Column(String(3))
nm_volume = Column(String(255))
batas_max = Column(Integer)
batas_min = Column(Integer)
__table_args__ = dict(schema=schema)
@hybrid_property
def nama(cls):
return cls.nm_volume
@classmethod
def query_register(cls, order_field="id"):
return cls.query_from(columns =[cls.kode.label('Kode'),
cls.nm_volume.label('Nama'),
cls.batas_min.label('Batas Min'),
cls.batas_max.label('Batas Max')])
class PjdlAirtanahZona(Base, KodeModel):
__tablename__ = 'pad_at_zona'
id = Column(Integer, primary_key=True)
kode = Column(String(3))
nm_zona = Column(String(255))
nilai_indeks = Column(Float)
nilai_komponen_sda = Column(Float)
nilai_kompensasi_pemulihan = Column(Float)
__table_args__ = dict(schema=schema)
@hybrid_property
def nama(cls):
return cls.nm_zona
@classmethod
def get_nilai(cls, values):
row = cls.query().filter(
cls.id == values["air_zona_id"],
).first()
return row
@classmethod
def query_register(cls, order_field="id"):
return cls.query_from(columns =[cls.kode.label('Kode'),
cls.nm_zona.label('Nama'),
cls.nilai_indeks.label('Nilai Indeks'),
cls.nilai_komponen_sda.label('Komponen SDA'),
cls.nilai_kompensasi_pemulihan.label('Nilai Kompensasi Pemulihan')])
tangsel/pdl/models/airtanah_lama.py 0 → 100644
from sqlalchemy import (
Column, DateTime, ForeignKey, Integer, String, Float,)
from opensipkd.models import Base, DefaultModel
schema = 'pad'
class PadAirZona(Base, DefaultModel):
__tablename__ = 'pad_air_zona'
id = Column(Integer, primary_key=True)
zonanm = Column(String(50))
nindex = Column(Float)
__table_args__ = dict(schema=schema)
@classmethod
def query_nama(cls, nama):
return cls.query().filter_by(zonanm=nama)
@classmethod
def query_register(cls, order_field="id"):
return cls.query_from(columns =[cls.zonanm.label('Kode'),
cls.nindex.label('Nilai Indeks')])
class PadAirManfaat(Base, DefaultModel):
__tablename__ = 'pad_air_manfaat'
id = Column(Integer, primary_key=True)
manfaatnm = Column(String(108))
__table_args__ = dict(schema=schema)
@classmethod
def query_nama(cls, nama):
return cls.query().filter_by(manfaatnm=nama)
@classmethod
def query_register(cls, order_field="id"):
return cls.query_from(columns =[cls.manfaatnm.label('Nama')])
class PadAirVolume(Base, DefaultModel):
__tablename__ = 'pad_air_volume'
id = Column(Integer, primary_key=True)
volume = Column(Integer)
tmt = Column(DateTime)
__table_args__ = dict(schema=schema)
@classmethod
def query_nama(cls, nama):
return cls.query().filter_by(volume=nama)
class PadAirHda(Base, DefaultModel):
__tablename__ = 'pad_air_hda'
id = Column(Integer, primary_key=True)
zona_id = Column(Integer, ForeignKey(f'{schema}.pad_air_zona.id'))
manfaat_id = Column(Integer, ForeignKey(f'{schema}.pad_air_manfaat.id'))
volume_id = Column(Integer)
hda = Column(Float)
__table_args__ = dict(schema=schema)
@classmethod
def query_register(cls, order_field="id"):
return cls.query_from(columns =[PadAirZona.zonanm.label('Zona'),
PadAirManfaat.manfaatnm.label('Manfaat'),
cls.volume_id.label('Volume'),
cls.hda.label('Hda')]). \
outerjoin(PadAirManfaat, PadAirManfaat.id == cls.manfaat_id). \
outerjoin(PadAirVolume, PadAirVolume.id == cls.volume_id). \
order_by(getattr(cls, order_field))
tangsel/pdl/models/alembic/README 0 → 100644
Generic single-database configuration.
\ No newline at end of file
tangsel/pdl/models/alembic/env.py 0 → 100644
"""Pyramid bootstrap environment. """
import logging
import os
import importlib.machinery
from alembic import context
from pyramid.paster import (
get_appsettings,
setup_logging,
)
from sqlalchemy import engine_from_config
from opensipkd.models.meta import Base
config = context.config
setup_logging(config.config_file_name)
settings = get_appsettings(config.config_file_name)
logging.info(settings)
target_metadata = Base.metadata
current_dir = os.path.split(__file__)[0]
helper_file = os.path.join(current_dir, 'helpers.py')
loader = importlib.machinery.SourceFileLoader('alembic_helpers', helper_file)
helpers = loader.load_module()
version_table = 'alembic_migrasi'
version_table_schema = 'public'
def run_migrations_offline():
"""Run migrations in 'offline' mode.
This configures the context with just a URL
and not an Engine, though an Engine is acceptable
here as well. By skipping the Engine creation
we don't even need a DBAPI to be available.
Calls to context.execute() here emit the given string to the
script output.
"""
context.configure(url=settings['sqlalchemy.url'],
version_table=version_table)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online():
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
engine = engine_from_config(settings, prefix='sqlalchemy.')
connection = engine.connect()
context.configure(
connection=connection,
target_metadata=target_metadata,
helpers=helpers,
version_table=version_table,
version_table_schema=version_table_schema
)
try:
with context.begin_transaction():
context.run_migrations()
finally:
connection.close()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
\ No newline at end of file
tangsel/pdl/models/alembic/helpers.py 0 → 100644
# http://www.derstappen-it.de/tech-blog/sqlalchemie-alembic-check-if-table-has-column
import sqlalchemy as sa
from alembic import op
from sqlalchemy.engine import reflection
def has_table(table, schema=None, insp=None):
if not insp:
engine = op.get_bind()
insp = reflection.Inspector.from_engine(engine)
return insp.has_table(table, schema=schema)
def table_has_column(table, column, schema=None):
engine = op.get_bind()
insp = reflection.Inspector.from_engine(engine)
has_column = False
if has_table(table, schema, insp):
for col in insp.get_columns(table, schema=schema):
if column != col['name']:
continue
has_column = True
else:
has_column = True
return has_column
def table_has_seq(table, name, schema=None):
engine = op.get_bind()
insp = reflection.Inspector.from_engine(engine)
has_seq = False
if has_table(table, schema, insp):
for seq in insp.get_sequence_names(schema=schema):
if name != seq:
continue
has_seq = True
else:
has_seq = True
return has_seq
def fields_update(table, field, typ, schema="pad", **kw):
context = op.get_context()
helpers = context.opts['helpers']
if not helpers.table_has_column(table, field, schema):
op.add_column(table, sa.Column(field, typ), schema=schema)
nullable = kw.get("nullable", None)
if nullable != None and nullable == False:
default = kw.get("default")
if default != None:
op.execute(
f"UPDATE {schema}.{table} SET {field} = {default}")
op.alter_column(table, field, nullable=False, schema=schema)
tangsel/pdl/models/alembic/script.py.mako 0 → 100644
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
# revision identifiers, used by Alembic.
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}
branch_labels = ${repr(branch_labels)}
depends_on = ${repr(depends_on)}
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
def upgrade():
${upgrades if upgrades else "pass"}
def downgrade():
${downgrades if downgrades else "pass"}
tangsel/pdl/models/alembic/versions/06337a1905a5_upgrade_customer_usaha.py 0 → 100644
"""upgrade customer usaha
Revision ID: 06337a1905a5
Revises: cc2e4a0aad1e
Create Date: 2024-11-15 16:35:40.192189
"""
# revision identifiers, used by Alembic.
from opensipkd.pjdl.models import PjdlWp, PjdlKecamatan, PjdlKelurahan, DBSession, Base
revision = '06337a1905a5'
down_revision = 'cc2e4a0aad1e'
branch_labels = None
depends_on = None
import sqlalchemy as sa
from alembic import op
def upgrade():
context = op.get_context()
helpers = context.opts['helpers']
schema="pad"
helpers.fields_update("pad_customer_usaha", "jatuhtempo", sa.DateTime(timezone=False), schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin1", sa.String(100), schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin1no", sa.String(100), schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin1tgl", sa.DateTime, schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin1tglakhir", sa.DateTime, schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin2", sa.String(100), schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin2no", sa.String(100), schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin2tgl", sa.DateTime, schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin2tglakhir", sa.DateTime, schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin3", sa.String(100), schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin3no", sa.String(100), schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin3tgl", sa.DateTime, schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin3tglakhir", sa.DateTime, schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin4", sa.String(100), schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin4no", sa.String(100), schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin4tgl", sa.DateTime, schema=schema)
helpers.fields_update("pad_customer_usaha", "ijin4tglakhir", sa.DateTime, schema=schema)
helpers.fields_update("pad_customer", "kd_restojmlmeja", sa.Integer, schema=schema)
helpers.fields_update(
"pad_customer", "kd_restojmlkursi", sa.Integer, schema=schema)
engine = op.get_bind()
DBSession.configure(bind=engine)
Base.metadata.bind = engine
query = PjdlWp.query().filter(PjdlWp.npwpd == None)
for row in query.all():
formno = row.formno
kecamatan = PjdlKecamatan.query_id(row.kecamatan_id).first()
kelurahan = PjdlKelurahan.query_id(row.kelurahan_id).first()
row.npwpd = "".join(
[str(row.rp), str(row.pb), str(formno).zfill(6), kecamatan.kode, kelurahan.kode])
print(row.npwpd)
DBSession.add(row)
DBSession.flush()
if helpers.table_has_column("users", "userid", schema="public"):
user_table = sa.Table(
'users', sa.MetaData(),
sa.Column('id', sa.Integer, primary_key=True),
sa.Column('userid', sa.String(50)),
)
query = engine.execute(
sa.select(user_table.c.id, user_table.c.userid).filter(user_table.c.userid != None))
for row in query.all():
wps = PjdlWp.query().filter(PjdlWp.npwpd == row.userid)
for wp in wps:
if not wp.user_id:
wp.user_id = row.id
DBSession.add(wp)
DBSession.flush()
def downgrade():
pass
\ No newline at end of file
tangsel/pdl/models/alembic/versions/180ade8e2494_penambahan_field_rincian_objek.py 0 → 100644
"""Penambahan field rincian objek
Revision ID: 180ade8e2494
Revises: a52365776f0c
Create Date: 2023-03-13 17:41:59.001147
"""
# revision identifiers, used by Alembic.
import sqlalchemy as sa
from alembic import op
revision = '180ade8e2494'
down_revision = 'a52365776f0c'
branch_labels = None
depends_on = None
def upgrade():
schema = 'pad'
context = op.get_context()
helpers = context.opts['helpers']
# kd_restojmlmeja | integer | | |
# kd_restojmlkursi | integer | | |
# kd_restojmltamu | integer | | |
# kd_filmkursi | integer | | |
# kd_filmpertunjukan | integer | | |
# kd_filmtarif | double precision | | |
# kd_bilyarmeja | integer | | |
# kd_bilyartarif | double precision | | |
# kd_bilyarkegiatan | integer | | |
# kd_diskopengunjung | integer | | |
# kd_diskotarif | double precision | | |
# kd_waletvolume | integer
if not helpers.table_has_column('pad_customer_usaha', 'kd_restojmlmeja', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_restojmlmeja', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_restojmlkursi', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_restojmlkursi', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_restojmltamu', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_restojmltamu', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'jml_pegawai', schema):
op.add_column('pad_customer_usaha',
sa.Column('jml_pegawai', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_filmkursi', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_filmkursi', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_filmpertunjukan', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_filmpertunjukan', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_filmtarif', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_filmtarif', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_bilyarmeja', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_bilyarmeja', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_bilyartarif', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_bilyartarif', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_bilyarkegiatan', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_bilyarkegiatan', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_diskopengunjung', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_diskopengunjung', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_diskotarif', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_diskotarif', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_waletvolume', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_waletvolume', sa.Integer), schema=schema)
def downgrade():
pass
tangsel/pdl/models/alembic/versions/30177a0d2c18_upgrade_spt_field.py 0 → 100644
"""upgrade spt field
Revision ID: 30177a0d2c18
Revises: 6fb950081135
Create Date: 2025-02-18 13:10:21.857387
"""
# revision identifiers, used by Alembic.
from opensipkd.models.alembic import helpers
import sqlalchemy as sa
from deform import schema
from alembic import op
revision = '30177a0d2c18'
down_revision = '6fb950081135'
branch_labels = None
depends_on = None
def upgrade():
table_name = "pad_spt"
schema = 'pad'
helpers.fields_update(table_name, "air_jenis_sumber_id", sa.Integer, default=0,
nullable=False, schema=schema)
helpers.fields_update(table_name, "air_kualitas_id", sa.Integer, default=0,
nullable=False, schema=schema)
def downgrade():
pass
tangsel/pdl/models/alembic/versions/64ae5cad07e0_upgrade_customer_daftar.py 0 → 100644
"""upgrade customer daftar
Revision ID: 64ae5cad07e0
Revises: f7b069984d27
Create Date: 2024-11-13 16:39:14.718177
"""
# revision identifiers, used by Alembic.
revision = '64ae5cad07e0'
down_revision = 'f7b069984d27'
branch_labels = None
depends_on = None
import sqlalchemy as sa
from alembic import op
def upgrade():
context = op.get_context()
helpers = context.opts['helpers']
helpers.fields_update("pad_customer", "nik", sa.String(20))
helpers.fields_update("pad_customer", "pnik", sa.String(20))
helpers.fields_update("pad_customer", "wpnik", sa.String(20))
helpers.fields_update("pad_customer", "email", sa.String(256))
helpers.fields_update("pad_customer", "user_id", sa.Integer())
helpers.fields_update("pad_customer_usaha", "daftar_id", sa.Integer)
helpers.fields_update("pad_daftar", "status_id", sa.Integer)
helpers.fields_update("pad_daftar", "cu_id", sa.Integer)
helpers.fields_update("pad_daftar", "nik", sa.String(20))
helpers.fields_update("pad_daftar", "pnik", sa.String(20))
helpers.fields_update("pad_daftar", "wpnik", sa.String(20))
statement = \
"""update pad.pad_daftar set status_id = (select max(status_id) from pad.pad_daftar_hist where daftar_id=pad.pad_daftar.id)"""
op.execute(statement)
statement = """update pad.pad_daftar set cu_id =(select id from pad.pad_customer_usaha where daftar_id=pad.pad_daftar.id)"""
op.execute(statement)
def downgrade():
pass
\ No newline at end of file
tangsel/pdl/models/alembic/versions/6584ec93814b_upgrade_master.py 0 → 100644
"""upgrade master
Revision ID: 6584ec93814b
Revises: 06337a1905a5
Create Date: 2024-11-16 14:07:54.987941
"""
# revision identifiers, used by Alembic.
revision = '6584ec93814b'
down_revision = '06337a1905a5'
branch_labels = None
depends_on = None
import sqlalchemy as sa
from alembic import op
def upgrade():
schema = "pad"
context = op.get_context()
helpers = context.opts['helpers']
helpers.fields_update("pad_pajak", "status_reklame_id", sa.Integer)
helpers.fields_update("pad_pajak", "status_reklame_id", sa.Integer)
helpers.fields_update("pad_pajak", "bahan_komponen", sa.String(255))
helpers.fields_update("pad_pajak", "satuan_ukuran", sa.String(50))
helpers.fields_update("pad_pajak", "biaya_pembuatan", sa.Float(53))
helpers.fields_update("pad_pajak", "batas_min_masa_pajak", sa.String(50))
helpers.fields_update("pad_spt_type", "typenm_skt", sa.String(20))
helpers.fields_update("pad_customer_usaha", "pnama", sa.String(50))
helpers.fields_update("pad_customer_usaha", "palamat", sa.String(255))
helpers.fields_update("pad_customer_usaha", "pkelurahan", sa.String(25))
helpers.fields_update("pad_customer_usaha", "pkecamatan", sa.String(25))
helpers.fields_update("pad_customer_usaha", "pkabupaten", sa.String(25))
helpers.fields_update("pad_customer_usaha", "ptelp", sa.String(20))
helpers.fields_update("pad_customer_usaha", "pkodepos", sa.String(5))
helpers.fields_update("tblrekening", "insidentil", sa.SmallInteger)
# statement = f"alter table {schema}.pad_spt_type alter column id SET DEFAULT nextval('pad_spt_type_id_seq')"
# op.execute(statement)
# statement = f"SELECT setval('users_id_seq', (SELECT MAX(id) FROM users))"
# op.execute(statement)
seq_name = "pad_spt_type_id_seq"
table_nm = "pad_spt_type"
if not helpers.table_has_seq(table_nm, seq_name, schema):
statement = f"CREATE SEQUENCE {schema}.{seq_name} START WITH 1"
op.execute(statement)
statement = f"SELECT setval('{schema}.{seq_name}', (SELECT MAX(id) FROM {schema}.{table_nm}))"
op.execute(statement)
statement = f"alter table {schema}.{table_nm} alter column id set default nextval('{schema}.{seq_name}')"
op.execute(statement)
def downgrade():
pass
\ No newline at end of file
tangsel/pdl/models/alembic/versions/6fb950081135_upgrade_reklame_v1.py 0 → 100644
"""upgrade reklame v1
Revision ID: 6fb950081135
Revises: 7813ffa5eba8
Create Date: 2025-02-10 15:09:17.461632
"""
# revision identifiers, used by Alembic.
from opensipkd.models.alembic import helpers
import sqlalchemy as sa
from alembic import op
revision = '6fb950081135'
down_revision = '7813ffa5eba8'
branch_labels = None
depends_on = None
def upgrade():
# context = op.get_context()
# helpers = context.opts['helpers']
table_name = 'pad_customer_usaha'
schema = "pad"
helpers.fields_update(table_name, "r_panjang", sa.Float, schema=schema)
helpers.fields_update(table_name, "r_lebar", sa.Float, schema=schema)
helpers.fields_update(table_name, "r_luas", sa.Float, schema=schema)
helpers.fields_update(table_name, "r_tinggi", sa.Float, schema=schema)
helpers.fields_update(table_name, "r_muka", sa.Integer, schema=schema)
helpers.fields_update(table_name, "r_banyak", sa.Integer, schema=schema)
helpers.fields_update(table_name, "r_nsr_id", sa.Integer, schema=schema)
helpers.fields_update(table_name, "r_jalanklas_id",
sa.Integer, schema=schema)
helpers.fields_update(table_name, "r_jalan_id", sa.Integer, schema=schema)
helpers.fields_update(table_name, "r_lokasi_pasang_id",
sa.Integer, schema=schema)
helpers.fields_update(table_name, "r_sudut_pandang_id",
sa.Integer, schema=schema)
helpers.fields_update(table_name, "r_judul", sa.String(254), schema=schema)
helpers.fields_update(
table_name, "r_jenis_produk_reklame_id", sa.Integer, schema=schema)
helpers.fields_update(
table_name, "r_letak_reklame_id", sa.Integer, schema=schema)
table_name = "pad_spt"
helpers.fields_update(table_name, "r_judul", sa.String(254), schema=schema)
def downgrade():
pass
tangsel/pdl/models/alembic/versions/7813ffa5eba8_upgrade_reklame.py 0 → 100644
"""upgrade reklame
Revision ID: 7813ffa5eba8
Revises: f950bfaaead1
Create Date: 2025-01-22 16:10:48.197670
"""
# revision identifiers, used by Alembic.
import sqlalchemy as sa
from alembic import op
revision = '7813ffa5eba8'
down_revision = 'f950bfaaead1'
branch_labels = None
depends_on = None
def upgrade():
context = op.get_context()
helpers = context.opts['helpers']
schema = "pad"
table = "pad_rk_nilai_kelas_jalan"
helpers.fields_update(table, "nilai", sa.Float, schema=schema)
table = "pad_rk_satuan_nilai_strategis"
helpers.fields_update(table, "pajak_id", sa.Integer, schema=schema)
helpers.fields_update(table, "lokasi_id", sa.Integer, schema=schema)
helpers.fields_update(table, "kelas_jalan_id", sa.Integer, schema=schema)
helpers.fields_update(table, "nilai", sa.Float, schema=schema)
table = "pad_spt"
helpers.fields_update(table, "r_iprno", sa.String(128), schema=schema)
helpers.fields_update(table, "r_iprtgl", sa.DateTime(
timezone=False), schema=schema)
helpers.fields_update(table, "r_iprid", sa.Integer, schema=schema)
table = "pad_rk_jenis_produk_reklame"
helpers.fields_update(table, "tarif", sa.Float, schema=schema)
table = "pad_rk_letak_reklame"
helpers.fields_update(table, "tarif", sa.Float, schema=schema)
table = "pad_spt_rk_det"
helpers.fields_update(table, "titik_reklame_id", sa.Text, schema=schema)
def downgrade():
pass
tangsel/pdl/models/alembic/versions/9f9e131f2dd5_upgrade_pad_spt.py 0 → 100644
"""upgrade pad_spt
Revision ID: 9f9e131f2dd5
Revises: fae86fcfd306
Create Date: 2023-04-17 11:29:14.390861
"""
# revision identifiers, used by Alembic.
from alembic import op
import sqlalchemy as sa
revision = '9f9e131f2dd5'
down_revision = 'fae86fcfd306'
branch_labels = None
depends_on = None
def upgrade():
schema = 'pad'
context = op.get_context()
helpers = context.opts['helpers']
helpers.fields_update("pad_spt", "nama_wp", sa.String(256), schema=schema)
helpers.fields_update("pad_spt", "nama_op", sa.String(256), schema=schema)
helpers.fields_update("pad_spt", "spt_no", sa.String(64), schema=schema)
helpers.fields_update("pad_spt", "dasar_yg_blm_dibayar",
sa.BigInteger, schema=schema)
helpers.fields_update("pad_spt", "dasar_yg_sdh_dibayar",
sa.BigInteger, schema=schema)
helpers.fields_update(
"pad_spt", "r_jenis_produk_reklame_id", sa.Integer, schema=schema)
helpers.fields_update("pad_spt", "rek_no_paneng",
sa.String(50), schema=schema)
helpers.fields_update("pad_spt", "sptno_lengkap",
sa.String(20), schema=schema)
helpers.fields_update("pad_spt", "sptno_lama", sa.Integer, schema=schema)
helpers.fields_update("pad_spt", "masa_bln", sa.Integer,
default="date_part('month',masasd)",
nullable=False, schema=schema)
helpers.fields_update("pad_spt", "masa_thn", sa.Integer,
default="date_part('year',masasd)",
nullable=False, schema=schema)
helpers.fields_update("pad_spt", "setorankd", sa.Integer)
helpers.fields_update("pad_spt", "setorannm", sa.String(30), schema=schema)
helpers.fields_update("pad_spt", "tp_id", sa.Integer, schema=schema)
helpers.fields_update("pad_spt", "status_dok", sa.Integer, schema=schema)
helpers.fields_update("pad_spt", "m_tonase", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update("pad_spt", "m_njop", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update("pad_spt", "m_tonase_sdh_byr", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update("pad_spt", "m_karcis_sdh_byr", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update("pad_spt", "m_dasar_sdh_byr", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update("pad_spt", "abt_tarif", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update("pad_spt", "abt_calculated", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update("pad_spt", "r_kecamatan_id",
sa.Integer, schema=schema)
helpers.fields_update("pad_spt", "r_letak_reklame_id",
sa.Integer, schema=schema)
def downgrade():
pass
tangsel/pdl/models/alembic/versions/a01dc09faec0_upgrade_user.py 0 → 100644
"""upgrade user
Revision ID: a01dc09faec0
Revises:
Create Date: 2023-03-06 20:23:58.698148
"""
# revision identifiers, used by Alembic.
revision = 'a01dc09faec0'
down_revision = None
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade():
src_schema = 'app'
tables = ['apps', 'app_status',
'users', 'groups', "modules", "group_modules", "user_groups",
'user_uptd']
context = op.get_context()
helpers = context.opts['helpers']
for t in tables:
if helpers.has_table(t, src_schema):
context.execute(f'alter table {src_schema}.{t} set schema public')
schema = 'public'
if not helpers.table_has_column('users', 'user_name', schema):
op.add_column('users',
sa.Column('user_name', sa.String(128)), schema=schema)
if not helpers.table_has_column('users', 'user_password', schema):
op.add_column('users',
sa.Column('user_password', sa.String(256)), schema=schema)
if not helpers.table_has_column('users', 'email', schema):
op.add_column('users',
sa.Column('email', sa.String(100)), schema=schema)
if not helpers.table_has_column('users', 'status', schema):
op.add_column('users',
sa.Column('status', sa.SmallInteger), schema=schema)
if not helpers.table_has_column('users', 'security_code', schema):
op.add_column('users',
sa.Column('security_code', sa.String(256)), schema=schema)
if not helpers.table_has_column('users', 'last_login_date', schema):
op.add_column('users',
sa.Column('last_login_date', sa.TIMESTAMP(timezone=True)), schema=schema)
if not helpers.table_has_column('users', 'registered_date', schema):
op.add_column('users',
sa.Column('registered_date', sa.TIMESTAMP(timezone=True)), schema=schema)
if not helpers.table_has_column('users', 'security_code_date', schema):
op.add_column('users',
sa.Column('security_code_date',
sa.TIMESTAMP(timezone=True)),
schema=schema)
if not helpers.table_has_column('users', 'api_key', schema):
op.add_column(
'users', sa.Column('api_key', sa.String(256)), schema=schema)
if not helpers.table_has_column('users', 'partner_id', schema):
op.add_column(
'users', sa.Column('partner_id', sa.Integer), schema=schema)
if not helpers.table_has_column('users', 'company_id', schema):
op.add_column(
'users', sa.Column('company_id', sa.Integer), schema=schema)
if not helpers.has_table("alembic_ziggurat_foundations_version", "public"):
table = op.create_table(
"alembic_ziggurat_foundations_version", sa.Column(
"version_num", sa.String(64)),
schema="public")
else:
table = sa.sql.table(
"alembic_ziggurat_foundations_version", sa.sql.column("version_num", sa.String(64)))
op.bulk_insert(table, [{"version_num": "613e7c11dead"}])
def downgrade():
pass
\ No newline at end of file
tangsel/pdl/models/alembic/versions/a52365776f0c_upgrade_all.py 0 → 100644
"""upgrade_all
Revision ID: a52365776f0c
Revises: a01dc09faec0
Create Date: 2023-03-06 20:29:10.252018
"""
# revision identifiers, used by Alembic.
revision = 'a52365776f0c'
down_revision = 'a01dc09faec0'
branch_labels = None
depends_on = None
import sqlalchemy as sa
from alembic import op
def upgrade():
schema = 'public'
context = op.get_context()
helpers = context.opts['helpers']
if not helpers.table_has_column('groups', 'group_name', schema):
op.add_column('groups',
sa.Column('group_name', sa.String(50)), schema=schema)
if not helpers.table_has_column('groups', 'description', schema):
op.add_column('groups',
sa.Column('description', sa.TEXT), schema=schema)
if not helpers.table_has_column('groups', 'member_count', schema):
op.add_column('groups',
sa.Column('member_count', sa.Integer), schema=schema)
# table = sa.sql.table(
# "users", sa.sql.column("userid", sa.String(25)),
# sa.sql.column("user_name", sa.String(64))
# )
if helpers.table_has_column("users", "userid", schema=schema):
op.execute("update users set user_name=userid, status=disabled+1 where user_name is null")
op.execute("update users set status=0 where status>1")
op.execute(
"""update groups set group_name=kode, description=nama, member_count=0
where kode is not null and nama is not null
""")
op.execute(
"""update groups set group_name='Superuser' where kode='sa'""")
from opensipkd.models import User, Base, DBSession, init_model
engine = op.get_bind()
DBSession.configure(bind=engine)
Base.metadata.bind = engine
init_model()
user_table = sa.Table(
'users', sa.MetaData(schema="public"),
autoload_with=engine,
autoload_replace=True
)
result = engine.execute(sa.select(user_table))
keys = user_table.columns.keys()
rows = [dict(zip(keys, r)) for r in result]
for row in rows:
user = User.query_id(row["id"]).first()
if not user.user_password:
if "is_encrypt" in row and row["is_encrypt"]:
user.password = row["userid"]
else:
user.password = row["passwd"]
DBSession.add(user)
DBSession.flush()
def downgrade():
pass
\ No newline at end of file
tangsel/pdl/models/alembic/versions/b8b271617f7c_upgrade_stpd.py 0 → 100644
"""upgrade stpd
Revision ID: b8b271617f7c
Revises: d45090cbb003
Create Date: 2025-01-07 17:21:55.053505
"""
# revision identifiers, used by Alembic.
import sqlalchemy as sa
from alembic import op
revision = 'b8b271617f7c'
down_revision = 'd45090cbb003'
branch_labels = None
depends_on = None
def upgrade():
schema = 'pad'
context = op.get_context()
helpers = context.opts['helpers']
helpers.fields_update("pad_stpd", "opsen_bunga", sa.Float, schema=schema)
def downgrade():
pass
tangsel/pdl/models/alembic/versions/cc1cac32d25f_create_spt_item.py 0 → 100644
"""create spt_item
Revision ID: cc1cac32d25f
Revises: e8a60199b6a3
Create Date: 2023-03-17 10:23:07.943788
"""
# revision identifiers, used by Alembic.
import sqlalchemy as sa
from alembic import op
from sqlalchemy.engine import reflection
revision = 'cc1cac32d25f'
down_revision = 'e8a60199b6a3'
branch_labels = None
depends_on = None
def upgrade():
schema = 'pad'
context = op.get_context()
helpers = context.opts['helpers']
engine = op.get_bind()
insp = reflection.Inspector.from_engine(engine)
if not helpers.has_table("pad_spt_item", schema, insp):
op.create_table(
'pad_spt_item',
sa.Column('id', sa.Integer, primary_key=True),
sa.Column('spt_id', sa.Integer, sa.ForeignKey('pad.pad_spt.id', onupdate='CASCADE')),
sa.Column('rekening_id', sa.Integer,
sa.ForeignKey('pad.tblrekening.id', onupdate='CASCADE')),
# type_id = Column(ForeignKey(PjdlSptType.id, onupdate='CASCADE'))
# so = Column(String(1), nullable=False, index=True)
# masadari = Column(DateTime, nullable=False)
# masasd = Column(DateTime, nullable=False)
# jatuhtempotgl = Column(DateTime)
# r_bayarid = Column(SmallInteger)
# minomset = Column(Float(53), server_default=FetchedValue())
sa.Column('dasar', sa.Float(), nullable=False),
sa.Column('tarif', sa.Float(), nullable=False),
sa.Column('denda', sa.Float(), ),
sa.Column('bunga', sa.Float(),),
sa.Column('setoran', sa.Float(),),
sa.Column('kenaikan', sa.Float(), nullable=False),
sa.Column('kompensasi', sa.Float(53)),
sa.Column('lain2', sa.Float(53), nullable=False),
sa.Column('pajak_terhutang', sa.BigInteger, nullable=False),
schema=schema
)
def downgrade():
schema = 'pad'
op.drop_table('pad_spt_item', schema=schema)
tangsel/pdl/models/alembic/versions/cc2e4a0aad1e_upgrade_sspd.py 0 → 100644
"""upgrade sspd
Revision ID: cc2e4a0aad1e
Revises: 64ae5cad07e0
Create Date: 2024-11-15 16:09:33.392335
"""
# revision identifiers, used by Alembic.
revision = 'cc2e4a0aad1e'
down_revision = '64ae5cad07e0'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade():
schema = 'pad'
context = op.get_context()
helpers = context.opts['helpers']
if not helpers.table_has_column('pad_sspd', 'posted', schema):
op.add_column('pad_sspd',
sa.Column('posted', sa.SmallInteger), schema=schema)
if not helpers.table_has_column('pad_sspd', 'posting_simda_penetapan', schema):
op.add_column('pad_sspd',
sa.Column('posting_simda_penetapan', sa.SmallInteger), schema=schema)
if not helpers.table_has_column('pad_sspd', 'posting_simda_non_penetapan', schema):
op.add_column('pad_sspd',
sa.Column('posting_simda_non_penetapan', sa.SmallInteger), schema=schema)
def downgrade():
pass
\ No newline at end of file
tangsel/pdl/models/alembic/versions/d0105ef47fd1_pjdl_daftar.py 0 → 100644
"""pjdl daftar
Revision ID: d0105ef47fd1
Revises: 6584ec93814b
Create Date: 2024-11-22 19:06:50.336660
"""
# revision identifiers, used by Alembic.
revision = 'd0105ef47fd1'
down_revision = '6584ec93814b'
branch_labels = None
depends_on = None
import sqlalchemy as sa
from alembic import op
def upgrade():
context = op.get_context()
helpers = context.opts['helpers']
helpers.fields_update("pad_daftar", "kd_park_roda2_luas", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_roda2_jumlah", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_roda2_tarif1", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_roda2_tarif2", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_roda2_tarif3", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_roda4_luas", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_roda4_jumlah", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_roda4_tarif1", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_roda4_tarif2", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_roda4_tarif3", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_rodax_luas", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_rodax_jumlah", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_rodax_tarif1", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_rodax_tarif2", sa.Integer)
helpers.fields_update("pad_daftar", "kd_park_rodax_tarif3", sa.Integer)
helpers.fields_update("pad_daftar", "ijin1file", sa.String(50))
helpers.fields_update("pad_daftar", "ijin2file", sa.String(50))
helpers.fields_update("pad_daftar", "ijin3file", sa.String(50))
helpers.fields_update("pad_daftar", "ijin4file", sa.String(50))
helpers.fields_update("pad_daftar", "status_id", sa.Integer)
# ,)
# sa.ForeignKey(f"{schema}.pad_daftar.id", ondelete="RESTRICT"))
helpers.fields_update("pad_daftar", "cu_id", sa.Integer)
helpers.fields_update("pad_daftar", "ijin1", sa.String(100))
helpers.fields_update("pad_daftar", "ijin1no", sa.String(100))
helpers.fields_update("pad_daftar", "ijin1tgl", sa.DateTime)
helpers.fields_update("pad_daftar", "ijin1tglakhir", sa.DateTime)
helpers.fields_update("pad_daftar", "ijin2", sa.String(100))
helpers.fields_update("pad_daftar", "ijin2no", sa.String(100))
helpers.fields_update("pad_daftar", "ijin2tgl", sa.DateTime)
helpers.fields_update("pad_daftar", "ijin2tglakhir", sa.DateTime)
helpers.fields_update("pad_daftar", "ijin3", sa.String(100))
helpers.fields_update("pad_daftar", "ijin3no", sa.String(100))
helpers.fields_update("pad_daftar", "ijin3tgl", sa.DateTime)
helpers.fields_update("pad_daftar", "ijin3tglakhir", sa.DateTime)
helpers.fields_update("pad_daftar", "ijin4", sa.String(100))
helpers.fields_update("pad_daftar", "ijin4no", sa.String(100))
helpers.fields_update("pad_daftar", "ijin4tgl", sa.DateTime)
helpers.fields_update("pad_daftar", "ijin4tglakhir", sa.DateTime)
helpers.fields_update("pad_daftar", "kd_restojmlmeja", sa.Integer)
helpers.fields_update("pad_daftar", "kd_restojmlkursi", sa.Integer)
helpers.fields_update("pad_daftar", "kd_restojmltamu", sa.Integer)
helpers.fields_update("pad_daftar", "kd_filmkursi", sa.Integer)
helpers.fields_update("pad_daftar", "kd_filmpertunjukan", sa.Integer)
helpers.fields_update("pad_daftar", "kd_filmtarif", sa.Float(53))
helpers.fields_update("pad_daftar", "kd_bilyarmeja", sa.Integer)
helpers.fields_update("pad_daftar", "kd_bilyartarif", sa.Float(53))
helpers.fields_update("pad_daftar", "kd_bilyarkegiatan", sa.Integer)
helpers.fields_update("pad_daftar", "kd_diskopengunjung", sa.Integer)
helpers.fields_update("pad_daftar", "kd_diskotarif", sa.Float(53))
helpers.fields_update("pad_daftar", "kd_waletvolume", sa.Integer)
statement = "alter table pad.pad_daftar alter column cu_id type bigint"
op.execute(statement)
def downgrade():
pass
\ No newline at end of file
tangsel/pdl/models/alembic/versions/d45090cbb003_upgrade_opsen.py 0 → 100644
"""upgrade opsen
Revision ID: d45090cbb003
Revises: d0105ef47fd1
Create Date: 2024-12-31 10:37:14.204146
"""
# revision identifiers, used by Alembic.
import sqlalchemy as sa
from alembic import op
revision = 'd45090cbb003'
down_revision = 'd0105ef47fd1'
branch_labels = None
depends_on = None
def upgrade():
context = op.get_context()
helpers = context.opts['helpers']
schema = "pad"
helpers.fields_update("pad_pajak_tarif", "opsen_tarif", sa.Float, default=0,
nullable=False, schema=schema)
table = "pad_spt"
helpers.fields_update(table, "pokok", sa.Float,
default='dasar*tarif', nullable=False, schema=schema)
helpers.fields_update(table, "pokok_pajak", sa.Float,
default='pokok+denda+kenaikan+lain2-kompensasi-setoran',
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_tarif", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_pokok", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_denda", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_setoran", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_pokok_pajak", sa.Float,
default="opsen_pokok+opsen_denda-opsen_setoran",
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_bunga", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_terhutang", sa.Float,
default="opsen_pokok_pajak+opsen_bunga",
nullable=False, schema=schema)
helpers.fields_update(table, "pajak_yg_hrs_dibayar", sa.Float,
default="pajak_terhutang+opsen_terhutang",
nullable=False, schema=schema)
table = "pad_sptpd"
helpers.fields_update(table, "opsen_tarif", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_pokok", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_denda", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_pokok_pajak", sa.Float,
default="opsen_pokok+opsen_denda",
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_bunga", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_terhutang", sa.Float,
default="opsen_pokok_pajak+opsen_bunga",
nullable=False, schema=schema)
helpers.fields_update(table, "pajak_yg_hrs_dibayar", sa.Float,
default="pajak_terhutang+opsen_terhutang",
nullable=False, schema=schema)
table = "pad_sspd"
helpers.fields_update(table, "opsen_bayar", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_denda", sa.Float, default=0,
nullable=False, schema=schema)
helpers.fields_update(table, "opsen_bunga", sa.Float, default=0,
nullable=False, schema=schema)
table = "pad_spt_type"
helpers.fields_update(table, "persen_denda", sa.Float,
default=0, nullable=False)
helpers.fields_update(table, "is_hari_kerja",
sa.Boolean, default=False, nullable=False)
helpers.fields_update(table, "denda", sa.BigInteger,
default=0, nullable=False)
helpers.fields_update(table, "denda_badan", sa.BigInteger,
default=0, nullable=False)
helpers.fields_update(table, "max_day", sa.Integer,
default=0, nullable=False)
helpers.fields_update(table, "max_denda", sa.Integer,
default=0, nullable=False)
def downgrade():
pass
tangsel/pdl/models/alembic/versions/db5fafdd9835_penambahan_field_kohir.py 0 → 100644
"""penambahan field kohir
Revision ID: db5fafdd9835
Revises: ec4a35aa58ec
Create Date: 2023-10-17 11:24:50.283094
"""
# revision identifiers, used by Alembic.
import sqlalchemy as sa
from alembic import op
revision = 'db5fafdd9835'
down_revision = 'ec4a35aa58ec'
branch_labels = None
depends_on = None
def upgrade():
schema = 'pad'
context = op.get_context()
helpers = context.opts['helpers']
if not helpers.table_has_column('pad_kohir', 'spt_id', schema):
op.add_column('pad_kohir',
sa.Column('spt_id', sa.Integer), schema=schema)
stmt = "alter table pad.pad_kohir alter column sptpd_id drop not null"
op.execute(stmt)
def downgrade():
pass
tangsel/pdl/models/alembic/versions/e8a60199b6a3_penambahan_field_parkir.py 0 → 100644
"""Penambahan field parkir
Revision ID: e8a60199b6a3
Revises: 180ade8e2494
Create Date: 2023-03-13 20:12:37.208370
"""
# revision identifiers, used by Alembic.
revision = 'e8a60199b6a3'
down_revision = '180ade8e2494'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade():
schema = 'pad'
context = op.get_context()
helpers = context.opts['helpers']
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_roda2_luas', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_roda2_luas', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_roda2_jumlah', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_roda2_jumlah', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_roda2_tarif1', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_roda2_tarif1', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_roda2_tarif2', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_roda2_tarif2', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_roda2_tarif3', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_roda2_tarif3', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_roda4_luas', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_roda4_luas', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_roda4_jumlah', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_roda4_jumlah', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_roda4_tarif1', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_roda4_tarif1', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_roda4_tarif2', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_roda4_tarif2', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_roda4_tarif3', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_roda4_tarif3', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_rodax_luas', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_rodax_luas', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_rodax_jumlah', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_rodax_jumlah', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_rodax_tarif1', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_rodax_tarif1', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_rodax_tarif2', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_rodax_tarif2', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kd_park_rodax_tarif3', schema):
op.add_column('pad_customer_usaha',
sa.Column('kd_park_rodax_tarif3', sa.Integer), schema=schema)
def downgrade():
pass
tangsel/pdl/models/alembic/versions/ec4a35aa58ec_airtanah.py 0 → 100644
"""airtanah
Revision ID: ec4a35aa58ec
Revises: 9f9e131f2dd5
Create Date: 2023-05-19 16:42:39.550791
"""
# revision identifiers, used by Alembic.
revision = 'ec4a35aa58ec'
down_revision = '9f9e131f2dd5'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade():
schema = 'pad'
context = op.get_context()
helpers = context.opts['helpers']
if not helpers.table_has_column('pad_customer_usaha', 'air_kualitas_id', schema):
op.add_column('pad_customer_usaha',
sa.Column('air_kualitas_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'air_sumber_id', schema):
op.add_column('pad_customer_usaha',
sa.Column('air_sumber_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'air_jenis_sumber_id', schema):
op.add_column('pad_customer_usaha',
sa.Column('air_jenis_sumber_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'volume', schema):
op.add_column('pad_customer_usaha',
sa.Column('volume', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'volume_progresif', schema):
op.add_column('pad_customer_usaha',
sa.Column('volume_progresif', sa.String(50)), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'volume_progresif_val', schema):
op.add_column('pad_customer_usaha',
sa.Column('volume_progresif_val', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'indeks_kp', schema):
op.add_column('pad_customer_usaha',
sa.Column('indeks_kp', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kp', schema):
op.add_column('pad_customer_usaha',
sa.Column('kp', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'fna', schema):
op.add_column('pad_customer_usaha',
sa.Column('fna', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'hab', schema):
op.add_column('pad_customer_usaha',
sa.Column('hab', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'hda', schema):
op.add_column('pad_customer_usaha',
sa.Column('hda', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'npa', schema):
op.add_column('pad_customer_usaha',
sa.Column('npa', sa.Float), schema=schema)
def downgrade():
pass
tangsel/pdl/models/alembic/versions/f7b069984d27_penambahan_field_airtanah.py 0 → 100644
"""penambahan field airtanah
Revision ID: f7b069984d27
Revises: db5fafdd9835
Create Date: 2023-11-28 11:12:37.568577
"""
# revision identifiers, used by Alembic.
revision = 'f7b069984d27'
down_revision = 'db5fafdd9835'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade():
schema = 'pad'
context = op.get_context()
helpers = context.opts['helpers']
if not helpers.table_has_column('pad_at_jenis_manfaat', 'bobot', schema):
op.add_column('pad_at_jenis_manfaat',
sa.Column('bobot', sa.Float), schema=schema)
if not helpers.table_has_column('pad_at_komponen_pemulihan', 'bobot', schema):
op.add_column('pad_at_komponen_pemulihan',
sa.Column('bobot', sa.Float), schema=schema)
if not helpers.table_has_column('pad_at_komponen_pemulihan', 'nilai_komponen', schema):
op.add_column('pad_at_komponen_pemulihan',
sa.Column('nilai_komponen', sa.Float), schema=schema)
if not helpers.table_has_column('pad_at_kualitas', 'kualitas', schema):
op.add_column('pad_at_kualitas',
sa.Column('kualitas', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_at_kualitas', 'alternatif', schema):
op.add_column('pad_at_kualitas',
sa.Column('alternatif', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_at_kualitas', 'bobot', schema):
op.add_column('pad_at_kualitas',
sa.Column('bobot', sa.Float), schema=schema)
if not helpers.table_has_column('pad_at_kualitas', 'komponen_sda', schema):
op.add_column('pad_at_kualitas',
sa.Column('komponen_sda', sa.Float), schema=schema)
def downgrade():
pass
tangsel/pdl/models/alembic/versions/f950bfaaead1_upgrade_kohir.py 0 → 100644
"""upgrade kohir
Revision ID: f950bfaaead1
Revises: b8b271617f7c
Create Date: 2025-01-15 23:15:04.426337
"""
# revision identifiers, used by Alembic.
import sqlalchemy as sa
from alembic import op
revision = 'f950bfaaead1'
down_revision = 'b8b271617f7c'
branch_labels = None
depends_on = None
def upgrade():
schema = 'pad'
context = op.get_context()
helpers = context.opts['helpers']
helpers.fields_update("pad_kohir", "spt_id", sa.Integer, schema=schema)
helpers.fields_update("pad_kohir", "sptpd_id", sa.Integer, schema=schema)
helpers.fields_update("pad_kohir", "is_cancel",
sa.Integer, default="0", schema=schema)
helpers.fields_update("pad_kohir", "bap_no",
sa.String(256), schema=schema)
helpers.fields_update("pad_kohir", "bap_date",
sa.DateTime, schema=schema)
helpers.fields_update("pad_kohir", "cancel_no",
sa.BigInteger, schema=schema)
helpers.fields_update("pad_kohir", "cancel_date",
sa.DateTime, schema=schema)
helpers.fields_update("pad_kohir", "cancel_thn",
sa.Integer, schema=schema)
helpers.fields_update("pad_kohir", "cancel_uid",
sa.Integer, schema=schema)
def downgrade():
pass
tangsel/pdl/models/alembic/versions/fae86fcfd306_upgrade_table_reklame.py 0 → 100644
"""upgrade table reklame
Revision ID: fae86fcfd306
Revises: cc1cac32d25f
Create Date: 2023-03-31 14:50:41.452509
"""
# revision identifiers, used by Alembic.
revision = 'fae86fcfd306'
down_revision = 'cc1cac32d25f'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade():
schema = 'pad'
context = op.get_context()
helpers = context.opts['helpers']
# if not helpers.table_has_column('pad_rk_nilai_lokasi', 'status_id', schema):
# op.add_column('pad_rk_nilai_lokasi',
# sa.Column('status_id', sa.Integer), schema=schema)
# if not helpers.table_has_column('pad_rk_nilai_lokasi', 'other_score', schema):
# op.add_column('pad_rk_nilai_lokasi',
# sa.Column('other_score', sa.Integer), schema=schema)
# if not helpers.table_has_column('pad_rk_nilai_kelas_jalan', 'status_id', schema):
# op.add_column('pad_rk_nilai_kelas_jalan',
# sa.Column('status_id', sa.Integer), schema=schema)
# if not helpers.table_has_column('pad_rk_nilai_kelas_jalan', 'other_score', schema):
# op.add_column('pad_rk_nilai_kelas_jalan',
# sa.Column('other_score', sa.Integer), schema=schema)
# if not helpers.table_has_column('pad_rk_nilai_sudut_pandang', 'status_id', schema):
# op.add_column('pad_rk_nilai_sudut_pandang',
# sa.Column('status_id', sa.Integer), schema=schema)
# if not helpers.table_has_column('pad_rk_nilai_sudut_pandang', 'other_score', schema):
# op.add_column('pad_rk_nilai_sudut_pandang',
# sa.Column('other_score', sa.Integer), schema=schema)
# if not helpers.table_has_column('pad_rk_ketinggian', 'status_id', schema):
# op.add_column('pad_rk_ketinggian',
# sa.Column('status_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'status_id', schema):
op.add_column('pad_customer_usaha',
sa.Column('status_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'pajak_id', schema):
op.add_column('pad_customer_usaha',
sa.Column('pajak_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'cahaya_id', schema):
op.add_column('pad_customer_usaha',
sa.Column('cahaya_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'pasang_id', schema):
op.add_column('pad_customer_usaha',
sa.Column('pasang_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'bahan', schema):
op.add_column('pad_customer_usaha',
sa.Column('bahan', sa.String(256)), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'letak_reklame_id', schema):
op.add_column('pad_customer_usaha',
sa.Column('letak_reklame_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'produk_reklame_id', schema):
op.add_column('pad_customer_usaha',
sa.Column('produk_reklame_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'sudut_pandang_id', schema):
op.add_column('pad_customer_usaha',
sa.Column('sudut_pandang_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'lokasi_id', schema):
op.add_column('pad_customer_usaha',
sa.Column('lokasi_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'kelas_jalan_id', schema):
op.add_column('pad_customer_usaha',
sa.Column('kelas_jalan_id', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'panjang', schema):
op.add_column('pad_customer_usaha',
sa.Column('panjang', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'lebar', schema):
op.add_column('pad_customer_usaha',
sa.Column('lebar', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'luas', schema):
op.add_column('pad_customer_usaha',
sa.Column('luas', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'tinggi', schema):
op.add_column('pad_customer_usaha',
sa.Column('tinggi', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'muka', schema):
op.add_column('pad_customer_usaha',
sa.Column('muka', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'banyak', schema):
op.add_column('pad_customer_usaha',
sa.Column('banyak', sa.Integer), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'njopr', schema):
op.add_column('pad_customer_usaha',
sa.Column('njopr', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'nspr', schema):
op.add_column('pad_customer_usaha',
sa.Column('nspr', sa.Float), schema=schema)
if not helpers.table_has_column('pad_customer_usaha', 'nsr', schema):
op.add_column('pad_customer_usaha',
sa.Column('nsr', sa.Float), schema=schema)
if not helpers.table_has_column('pad_rek_lokasi_pasang', 'lahan', schema):
op.add_column('pad_rek_lokasi_pasang',
sa.Column('lahan', sa.String(50)), schema=schema)
def downgrade():
pass
tangsel/pdl/models/customer.py 0 → 100644
from datetime import datetime
from sqlalchemy import (
Column, Integer, DateTime, ForeignKey, UniqueConstraint, String,
SmallInteger, Index, BigInteger, func, case
)
from sqlalchemy.orm import (relationship)
from . import PAD_TABLE_ARGS, DefaultModel, Base
from . import PjdlKecamatan, PjdlKelurahan, PjdlPejabat, DBSession
class WpMaster(DefaultModel):
id = Column(BigInteger, primary_key=True)
npwpd = Column(String(17))
rp = Column(String(1))
pb = Column(SmallInteger)
formno = Column(Integer, nullable=False)
reg_date = Column(DateTime)
customernm = Column(String(50))
kecamatan_id = Column(ForeignKey(PjdlKecamatan.id, onupdate='CASCADE'))
kelurahan_id = Column(ForeignKey(PjdlKelurahan.id, onupdate='CASCADE'))
kabupaten = Column(String(25))
alamat = Column(String(255))
kodepos = Column(String(5))
telphone = Column(String(20))
wpnama = Column(String(50))
wpalamat = Column(String(255))
wpkelurahan = Column(String(25))
wpkecamatan = Column(String(25))
wpkabupaten = Column(String(25))
wptelp = Column(String(20))
wpkodepos = Column(String(5))
pnama = Column(String(50))
palamat = Column(String(255))
pkelurahan = Column(String(25))
pkecamatan = Column(String(25))
pkabupaten = Column(String(25))
ptelp = Column(String(20))
pkodepos = Column(String(5))
enabled = Column(SmallInteger)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
nik = Column(String(20))
wpnik = Column(String(20))
pnik = Column(String(20))
email = Column(String(50))
class PjdlWp(Base, WpMaster):
__tablename__ = 'pad_customer'
__table_args__ = (
UniqueConstraint('rp', 'pb', 'formno', 'kecamatan_id', 'kelurahan_id'),
Index('pad_customer_id_formno_customernm_idx',
'id', 'formno', 'customernm'),
PAD_TABLE_ARGS
)
parent = Column(BigInteger)
kukuhno = Column(String(30))
kukuhnip = Column(BigInteger)
kukuhtgl = Column(DateTime)
kukuh_jabat_id = Column(ForeignKey(PjdlPejabat.id, onupdate='CASCADE'))
kukuhprinted = Column(SmallInteger)
tmt = Column(DateTime)
customer_status_id = Column(Integer)
kembalitgl = Column(DateTime)
kembalioleh = Column(String(30))
kembalinip = Column(BigInteger)
kartuprinted = Column(SmallInteger)
penerimanm = Column(String(50))
penerimaalamat = Column(String(50))
penerimatgl = Column(DateTime)
catatnip = Column(BigInteger)
kirimtgl = Column(DateTime)
batastgl = Column(DateTime)
petugas_jabat_id = Column(Integer)
pencatat_jabat_id = Column(Integer)
user_id = Column(Integer)
# tambahan atas permintaan Pak Bambang
# wajib_pajak
# no_identitas_wp = Column(String)
# rt_wp = Column(String(3))
# rw_wp = Column(String(3))
# penanggung jawab
# p_no_identitas = Column(String)
# p_rt = Column(String(3))
# p_rw = Column(String(3))
kecamatan = relationship('PjdlKecamatan',
primaryjoin='PjdlWp.kecamatan_id == PjdlKecamatan.id',
backref='pad_customers')
kelurahan = relationship('PjdlKelurahan',
primaryjoin='PjdlWp.kelurahan_id == PjdlKelurahan.id',
backref='pad_customers')
pejabat = relationship('PjdlPejabat', primaryjoin='PjdlWp.kukuh_jabat_id == PjdlPejabat.id',
backref='pad_customers')
@classmethod
def query_form(cls, no):
return cls.query().filter_by(formno=no)
@classmethod
def query_register(cls, order_field="customernm"):
return cls.query_from(
columns=[case([(cls.pb == 1, "P")], else_="B").label('P/B'),
cls.formno.label('form'),
func.concat(PjdlKecamatan.kecamatankd, '.',
PjdlKelurahan.kelurahankd).label('wilayah'),
cls.customernm.label('Usaha'),
cls.wpnama.label('Pemilik'), cls.reg_date.label(
'Registrasi'),
PjdlKecamatan.kecamatannm.label('Kecamatan'),
PjdlKelurahan.kelurahannm.label('Kelurahan'),
cls.enabled.label('Status')]). \
outerjoin(PjdlKecamatan, PjdlKecamatan.id == cls.kecamatan_id). \
outerjoin(PjdlKelurahan, PjdlKelurahan.id == cls.kelurahan_id). \
order_by(getattr(cls, order_field))
@classmethod
def get_draft_no(cls):
result = DBSession.query(func.min(cls.formno)).scalar()
result = result and result < 0 and result - 1 or -1
return result
@classmethod
def get_form_no(cls):
result = DBSession.query(func.max(cls.formno)).scalar()
result = result and result > 0 and result + 1 or 1
return result
@classmethod
def get_kukuh_no(cls):
now = datetime.now()
result = DBSession.query(func.max(cls.kukuhno)).scalar()
if result:
if result[len(result)-1] == str(now.year):
return f"{result[0]+1}/{now.year}"
return f"1/{now.year}"
@classmethod
def get_npwpd(self):
npwpd = func.get_npwpd(self.id, True)
return npwpd
tangsel/pdl/models/kecamatan.py 0 → 100644
from . import PAD_TABLE_ARGS, DefaultModel, Base, DBSession
from sqlalchemy import (
Column,
Integer,
DateTime,
String,
SmallInteger
)
from sqlalchemy.ext.hybrid import hybrid_property
class PjdlKecamatan(Base, DefaultModel):
__tablename__ = 'tblkecamatan'
__table_args__ = PAD_TABLE_ARGS
id = Column(Integer, primary_key=True)
kecamatankd = Column(String(2), nullable=False, unique=True)
kecamatannm = Column(String(50))
tmt = Column(DateTime)
enabled = Column(SmallInteger)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
@hybrid_property
def kode(self):
return self.kecamatankd
@kode.setter
def kode(self, kode):
self.kecamatankd = kode
@hybrid_property
def nama(self):
return self.kecamatannm
@nama.setter
def nama(self, kode):
self.kecamatannm = kode
@classmethod
def get_kecamatannama(cls):
q = DBSession.query(
cls.kecamatannm
)
return q.all
@classmethod
def query_kode(cls, kode):
return cls.query().filter(cls.kecamatankd == kode)
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.kecamatannm == nama)
@classmethod
def query_register(cls, order_field="kecamatannm"):
return cls.query_from(columns =[cls.kecamatankd.label('Kode Kecamatan'),
cls.kecamatannm.label('Kecamatan'),
cls.enabled.label('Aktif')]).\
order_by(getattr(cls, order_field))
@classmethod
def get_list(cls):
r = []
q = cls.query().order_by(cls.kecamatannm)
for row in q:
g = (str(row.id), f"{row.kode}/ {row.nama}")
r.append(g)
return r
\ No newline at end of file
tangsel/pdl/models/kelurahan.py 0 → 100644
from sqlalchemy import (
Column,
Integer,
DateTime,
ForeignKey,
UniqueConstraint,
String,
SmallInteger
)
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy.orm import (
relationship
)
from . import PAD_TABLE_ARGS, DefaultModel, Base, PjdlKecamatan
class PjdlKelurahan(Base, DefaultModel):
__tablename__ = 'tblkelurahan'
__table_args__ = (
UniqueConstraint('kecamatan_id', 'kelurahankd'),
PAD_TABLE_ARGS
)
id = Column(Integer, primary_key=True)
kecamatan_id = Column(ForeignKey(PjdlKecamatan.id,
ondelete='CASCADE', onupdate='CASCADE'),
nullable=False
)
kelurahankd = Column(String(3), nullable=False)
kelurahannm = Column(String(25))
tmt = Column(DateTime)
enabled = Column(SmallInteger)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
kecamatan = relationship('PjdlKecamatan',
primaryjoin='PjdlKelurahan.kecamatan_id == PjdlKecamatan.id',
backref='kelurahan')
@hybrid_property
def kode(self):
return self.kelurahankd
@kode.setter
def kode(self, kode):
self.kelurahankd = kode
@hybrid_property
def nama(self):
return self.kelurahannm
@nama.setter
def nama(self, kode):
self.kelurahannm = kode
@classmethod
def query_kode(cls, kode):
return cls.query().filter(cls.kelurahankd == kode)
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.kelurahannm == nama)
@classmethod
def query_register(cls, order_field="kelurahannm"):
return cls.query_from(columns =[PjdlKelurahan.kelurahankd.label('Kode Kelurahan'),
cls.kelurahannm.label('Kelurahan'),
PjdlKecamatan.kecamatannm.label('Kecamatan'),
cls.enabled.label('Aktif')]). \
outerjoin(PjdlKecamatan, PjdlKecamatan.id == cls.kecamatan_id). \
order_by(getattr(cls, order_field))
@classmethod
def get_list(cls, kecamatan_id=None):
r = []
q = cls.query(cls).order_by(cls.kelurahannm)
if kecamatan_id:
q.filter(cls.kecamatan_id == kecamatan_id)
for row in q:
g = (str(row.id), f"{row.kode}/ {row.nama}")
r.append(g)
return r
tangsel/pdl/models/kohir.py 0 → 100644
from sqlalchemy import (
Column,
Integer,
DateTime,
UniqueConstraint,
String,
SmallInteger,
Index,
BigInteger,
text,
func
)
from datetime import datetime
from dateutil.relativedelta import relativedelta
from opensipkd.pjdl.models.spt_invoice import PjdlInvoice
from . import DBSession
from . import PAD_TABLE_ARGS, DefaultModel, Base
class PjdlKohir(Base, DefaultModel):
__tablename__ = 'pad_kohir'
__table_args__ = (
UniqueConstraint('tahun', 'kohirno', 'usaha_id'),
Index('pad_kohir_tahun_usaha_id_kohirno_idx',
'tahun', 'usaha_id', 'kohirno'),
PAD_TABLE_ARGS
)
id = Column(BigInteger, primary_key=True)
tahun = Column(Integer, nullable=False, index=True)
usaha_id = Column(Integer)
kohirno = Column(Integer, nullable=False, index=True)
kohirtgl = Column(DateTime, nullable=False, index=True)
sptpd_id = Column(BigInteger, nullable=False, index=True)
spt_id = Column(BigInteger, nullable=False, index=True)
enabled = Column(SmallInteger)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
is_cancel = Column(Integer, server_default=text("0"))
bap_no = Column(String)
bap_date = Column(DateTime)
cancel_no = Column(BigInteger)
cancel_date = Column(DateTime)
cancel_thn = Column(Integer)
cancel_uid = Column(Integer)
@classmethod
def get_kohir_no(cls, row=None):
if not row:
tahun = datetime.now().year
else:
tahun = row.tahun
result = DBSession.query(func.max(cls.kohirno)).\
filter_by(tahun=tahun).scalar()
result = result and result > 0 and result+1 or 1
return result
@classmethod
def generate_cancelno(cls, row=None):
if not row:
tahun = datetime.now().year
else:
tahun = row.tahun
result = DBSession.query(func.max(cls.cancel_no)).\
filter_by(cancel_thn=tahun).scalar()
result = result and result > 0 and result+1 or 1
return result
@classmethod
def query_spt_id(cls, spt_id=None):
q = DBSession.query(cls).\
filter_by(spt_id=spt_id)
return q
@classmethod
def get_spt_kohirno(self):
kohirno = func.get_spt_kohirno(self.spt_id)
return kohirno
@classmethod
def get_spt_kohirno2(self):
kohirno = func.get_spt_kohirno(self.id)
return kohirno
@classmethod
def proses(cls, row, user):
now = datetime.now()
kohir = PjdlKohir.query().filter(PjdlKohir.spt_id == row.id).first()
if kohir:
return ("error", "Data sudah ditetapkan")
if row.sptno < 0:
row.sptno = PjdlInvoice.get_spt_no(row)
no_urut = str(row.sptno).zfill(5)
no_urut6 = str(row.sptno).zfill(6)
from opensipkd.pjdl.apps import MODULE_CLASS
spt_no_tpl = MODULE_CLASS.spt_no_tpl
row.spt_no = spt_no_tpl.format(kd_pemda=MODULE_CLASS.kd_pemda,
tahun=row.tahun, no_urut=no_urut,
no_urut6=no_urut6)
row.terimatgl = now.date()
row.jatuhtempotgl = now+relativedelta(days=row.spt_typ.max_day)
row.status_pembayaran = 0
DBSession.add(row)
kohir = PjdlKohir()
kohir.spt_id = row.id
kohir.kohirtgl = now.date()
kohir.tahun = now.year
kohir.enabled = 1
kohir.create_date = now
kohir.create_uid = user.id
kohir.kohirno = PjdlKohir.get_kohir_no(row=kohir)
kohir.usaha_id = row.op.usaha_id
DBSession.add(kohir)
DBSession.flush()
return ("success", "Data sudah ditetapkan")
tangsel/pdl/models/pajak.py 0 → 100644
from sqlalchemy import (
Column, Integer, DateTime, ForeignKey, UniqueConstraint, String, SmallInteger,
Index, Float, func)
from sqlalchemy.orm import (
relationship
)
from sqlalchemy.schema import FetchedValue
from . import PAD_TABLE_ARGS, DefaultModel, Base
from . import (PjdlUsaha, PjdlRekening)
from . import (DBSession)
class PjdlPajak(Base, DefaultModel):
__tablename__ = 'pad_pajak'
__table_args__ = (
UniqueConstraint('rekening_id', 'rekeningkdsub'),
Index('pad_pajak_rekening_id_usaha_id_rekdenda_id_idx', 'rekening_id', 'usaha_id',
'rekdenda_id'),
PAD_TABLE_ARGS
)
id = Column(Integer, primary_key=True)
usaha_id = Column(ForeignKey(PjdlUsaha.id, onupdate='CASCADE'), nullable=False,
server_default=FetchedValue())
pajaknm = Column(String(100))
rekening_id = Column(ForeignKey(
PjdlRekening.id, onupdate='CASCADE'), nullable=False)
rekeningkdsub = Column(String(5), server_default=FetchedValue())
rekdenda_id = Column(Integer)
masapajak = Column(SmallInteger, nullable=False,
server_default=FetchedValue())
jatuhtempo = Column(SmallInteger, server_default=FetchedValue())
multiple = Column(SmallInteger, server_default=FetchedValue())
jalan_klas_id = Column(Integer)
tmt = Column(DateTime)
enabled = Column(SmallInteger)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
status_reklame_id = Column(Integer)
bahan_komponen = Column(String(255))
satuan_ukuran = Column(String(50))
biaya_pembuatan = Column(Float(53))
batas_min_masa_pajak = Column(String(50))
rekening = relationship('PjdlRekening', primaryjoin='PjdlPajak.rekening_id == PjdlRekening.id',
backref='pad_pajaks')
usaha = relationship('PjdlUsaha', primaryjoin='PjdlPajak.usaha_id == PjdlUsaha.id',
backref='pad_pajaks')
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.pajaknm == nama)
@classmethod
def query_register(cls, order_field="pajaknm"):
return cls.query_from(columns=[cls.pajaknm.label('Nama Pajak'),
PjdlUsaha.usahanm.label('Nama Usaha'),
cls.enabled.label('Aktif')]). \
outerjoin(PjdlUsaha, PjdlUsaha.id == cls.usaha_id). \
order_by(getattr(cls, order_field))
@classmethod
def get_list(cls):
r = []
q = cls.query().order_by(cls.pajaknm)
for row in q:
g = (str(row.id), f"{row.pajaknm}")
r.append(g)
return r
@classmethod
def query_id(cls, id):
return cls.query().filter(cls.id == id)
@classmethod
def get_jatuhtempo(cls, usaha_id=None):
result = DBSession.query(func.max(cls.jatuhtempo)).\
filter_by(enabled=1).\
filter_by(usaha_id=usaha_id).scalar()
return result
class PjdlPajakTarif(Base, DefaultModel):
__tablename__ = 'pad_pajak_tarif'
__table_args__ = PAD_TABLE_ARGS
id = Column(Integer, primary_key=True)
pajak_id = Column(ForeignKey(PjdlPajak.id, ondelete=u'CASCADE', onupdate=u'CASCADE'),
nullable=False)
tarif = Column(Float(53))
opsen_tarif = Column(Float(53))
reklame = Column(Float(53), nullable=False, server_default=FetchedValue())
minomset = Column(Float(53), server_default=FetchedValue())
tmt = Column(DateTime)
enabled = Column(SmallInteger)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
pajak = relationship('PjdlPajak', primaryjoin='PjdlPajakTarif.pajak_id == PjdlPajak.id',
backref='padpajak_pad_pajak_tarifs')
@classmethod
def query_register(cls, order_field="pajak_id"):
return cls.query_from(columns=[PjdlPajak.pajaknm.label('Nama Pajak'),
cls.tarif, cls.minomset, cls.tmt,
cls.enabled.label('Status')]). \
outerjoin(PjdlPajak, PjdlPajak.id == cls.pajak_id). \
order_by(getattr(cls, order_field))
@classmethod
def get_list(cls, kecamatan_id=None):
r = []
q = cls.query(cls).order_by(cls.kelurahannm)
if kecamatan_id:
q.filter(cls.kecamatan_id == kecamatan_id)
for row in q:
g = (str(row.id), f"{row.kode}/ {row.nama}")
r.append(g)
return r
tangsel/pdl/models/pejabat.py 0 → 100644
from sqlalchemy import (
Column,
Integer,
DateTime,
String,
SmallInteger
)
from sqlalchemy.ext.hybrid import hybrid_property
from . import PAD_TABLE_ARGS, DefaultModel, Base
class PjdlPejabat(Base, DefaultModel):
__tablename__ = 'tblpejabat'
__table_args__ = PAD_TABLE_ARGS
id = Column(Integer, primary_key=True)
nip = Column(String(30))
pejabatnm = Column(String(30))
jabatan = Column(String(50))
golongan = Column(String(5))
pangkat = Column(String(30))
tmt = Column(DateTime)
enabled = Column(SmallInteger)
@hybrid_property
def kode(self):
return self.nip
@kode.setter
def kode(self, kode):
self.nip = kode
@hybrid_property
def nama(self):
return self.pejabatnm
@nama.setter
def nama(self, nama):
self.pejabatnm = nama
@classmethod
def query_kode(cls, kode):
return cls.query().filter(cls.kode == kode)
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.nama == nama)
@classmethod
def query_register(cls, order_field="id"):
return cls.query_from(columns =[cls.nip, cls.nama, cls.jabatan, cls.golongan,
cls.pangkat, cls.tmt, cls.enabled.label('Status')]). \
order_by(getattr(cls, order_field))
@classmethod
def get_list(cls):
r = []
q = cls.query().order_by(cls.pejabatnm)
for row in q:
g = (str(row.id), f"{row.kode}/ {row.nama}")
r.append(g)
return r
\ No newline at end of file
tangsel/pdl/models/registrasi.py 0 → 100644
import logging
from opensipkd.models import DBSession
from sqlalchemy import (
Column, Integer, String, Float, ForeignKey, UniqueConstraint, func, DateTime)
from sqlalchemy.orm import relationship
from . import DefaultModel, Base, PjdlKelurahan, PjdlKecamatan, PAD_TABLE_ARGS
from .customer import WpMaster
_logging = logging.getLogger(__name__)
class PjdlDaftarStatus(Base, DefaultModel):
__tablename__ = "pad_daftar_status"
kode = Column(String(2))
uraian = Column(String(50))
__table_args__ = (
PAD_TABLE_ARGS
)
@classmethod
def query_kode(cls, kode):
return cls.query().filter_by(kode=kode)
@classmethod
def get_list(cls):
query = PjdlDaftarStatus.query().order_by(cls.kode)
result = [(row.id, f"{row.kode} {row.uraian}") for row in query]
result.insert(0, ("", "Pilih Status Pendaftaran"))
return result
@classmethod
def query_min_status(cls):
kode = DBSession.query(func.min(cls.kode)).scalar()
return DBSession.query(cls.id).filter_by(kode=kode).scalar()
@classmethod
def query_max_status(cls):
kode = DBSession.query(func.max(cls.kode)).scalar()
return DBSession.query(cls.id).filter_by(kode=kode).scalar()
@classmethod
def query_next_status(cls, status_id, max_kode="03"):
query_kode = DBSession.query(func.min(cls.kode))
if status_id:
row = cls.query_id(status_id).first()
query_kode = query_kode.filter(cls.kode > row.kode,
cls.kode <= max_kode)
kode = query_kode.scalar()
if not kode:
return
return DBSession.query(cls.id).filter_by(kode=kode).scalar()
class PjdlDaftar(Base, WpMaster):
__tablename__ = "pad_daftar"
op_nm = Column(String(100))
op_alamat = Column(String(100))
op_usaha_id = Column(Integer)
op_so = Column(String(1))
op_kecamatan_id = Column(Integer, ForeignKey(PjdlKecamatan.id))
op_kelurahan_id = Column(Integer, ForeignKey(PjdlKelurahan.id))
op_latitude = Column(Float)
op_longitude = Column(Float)
op_pajak_id = Column(Integer)
passwd = Column(String(50))
kd_park_roda2_luas = Column(Integer)
kd_park_roda2_jumlah = Column(Integer)
kd_park_roda2_tarif1 = Column(Integer)
kd_park_roda2_tarif2 = Column(Integer)
kd_park_roda2_tarif3 = Column(Integer)
kd_park_roda4_luas = Column(Integer)
kd_park_roda4_jumlah = Column(Integer)
kd_park_roda4_tarif1 = Column(Integer)
kd_park_roda4_tarif2 = Column(Integer)
kd_park_roda4_tarif3 = Column(Integer)
kd_park_rodax_luas = Column(Integer)
kd_park_rodax_jumlah = Column(Integer)
kd_park_rodax_tarif1 = Column(Integer)
kd_park_rodax_tarif2 = Column(Integer)
kd_park_rodax_tarif3 = Column(Integer)
ijin1file = Column(String(50))
ijin2file = Column(String(50))
ijin3file = Column(String(50))
ijin4file = Column(String(50))
status_id = Column(Integer, ForeignKey(
PjdlDaftarStatus.id, ondelete="RESTRICT"))
cu_id = Column(Integer)
ijin1 = Column(String(100))
ijin1no = Column(String(100))
ijin1tgl = Column(DateTime)
ijin1tglakhir = Column(DateTime)
ijin2 = Column(String(100))
ijin2no = Column(String(100))
ijin2tgl = Column(DateTime)
ijin2tglakhir = Column(DateTime)
ijin3 = Column(String(100))
ijin3no = Column(String(100))
ijin3tgl = Column(DateTime)
ijin3tglakhir = Column(DateTime)
ijin4 = Column(String(100))
ijin4no = Column(String(100))
ijin4tgl = Column(DateTime)
ijin4tglakhir = Column(DateTime)
kd_restojmlmeja = Column(Integer)
kd_restojmlkursi = Column(Integer)
kd_restojmltamu = Column(Integer)
kd_filmkursi = Column(Integer)
kd_filmpertunjukan = Column(Integer)
kd_filmtarif = Column(Float())
kd_bilyarmeja = Column(Integer)
kd_bilyartarif = Column(Float())
kd_bilyarkegiatan = Column(Integer)
kd_diskopengunjung = Column(Integer)
kd_diskotarif = Column(Float())
kd_waletvolume = Column(Integer)
status = relationship('PjdlDaftarStatus',
primaryjoin='PjdlDaftar.status_id == PjdlDaftarStatus.id',
backref='pad_daftar')
__table_args__ = (
UniqueConstraint('rp', 'pb', 'formno', 'kecamatan_id', 'kelurahan_id'),
PAD_TABLE_ARGS
)
@classmethod
def get_formno(cls):
formno = DBSession.query(func.max(cls.formno)).scalar()
formno = formno and formno + 1 or 1
return formno
class PjdlDaftarHist(Base, DefaultModel):
__tablename__ = "pad_daftar_hist"
daftar_id = Column(Integer, ForeignKey(PjdlDaftar.id, ondelete="CASCADE"))
status_id = Column(Integer, ForeignKey(
PjdlDaftarStatus.id, ondelete="CASCADE"))
create_date = Column(DateTime(timezone=False))
create_uid = Column(Integer)
keterangan = Column(String(255))
__table_args__ = (
PAD_TABLE_ARGS
)
class PadDaftarKdDet(Base, DefaultModel):
__tablename__ = "pad_daftar_kd_det"
daftar_id = Column(ForeignKey(PjdlDaftar.id, onupdate='CASCADE'))
nourut = Column(Integer)
notes = Column(String(50))
tarif = Column(Float)
kamar = Column(Integer)
volume = Column(Integer)
__table_args__ = (
PAD_TABLE_ARGS
)
tangsel/pdl/models/rekening.py 0 → 100644
from sqlalchemy import (
Column,
Integer,
DateTime,
String,
SmallInteger
)
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy.schema import FetchedValue
from . import PAD_TABLE_ARGS, DefaultModel, Base
class PjdlRekening(Base, DefaultModel):
__tablename__ = 'tblrekening'
__table_args__ = PAD_TABLE_ARGS
id = Column(Integer, primary_key=True)
rekeningkd = Column(String(15), nullable=False, unique=True)
rekeningnm = Column(String(150))
levelid = Column(Integer)
issummary = Column(SmallInteger, nullable=False)
defsign = Column(SmallInteger, nullable=True)
isppkd = Column(SmallInteger, nullable=False, server_default=FetchedValue())
tmt = Column(DateTime)
enabled = Column(SmallInteger)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
insidentil = Column(SmallInteger, server_default=FetchedValue())
# reksts_id = Column(BigInteger)
# rek_akrual_id = Column(BigInteger)
@hybrid_property
def kode(self):
return self.rekeningkd
@kode.setter
def kode(self, kode):
self.rekeningkd = kode
@hybrid_property
def nama(self):
return self.rekeningnm
@nama.setter
def nama(self, kode):
self.rekeningnm = kode
@classmethod
def query_kode(cls, kode):
return cls.query().filter(cls.rekeningkd == kode)
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.rekeningnm == nama)
@classmethod
def query_register(cls, order_field="rekeningnm"):
return cls.query_from(columns =[cls.rekeningkd.label('Kode Rekening'),
cls.rekeningnm.label('Nama Rekening'),
cls.issummary.label('Summary'),
cls.tmt, cls.enabled.label('aktif')]). \
order_by(getattr(cls, order_field))
@classmethod
def get_list(cls):
r = []
q = cls.query().order_by(cls.rekeningnm)
for row in q:
g = (str(row.id), f"{row.kode}/ {row.nama}")
r.append(g)
return r
\ No newline at end of file
tangsel/pdl/models/reklame_hitung.py 0 → 100644
from sqlalchemy import (
Column, ForeignKey, Integer, String, SmallInteger, func)
from opensipkd.pjdl.models import PjdlPajak
from opensipkd.pjdl.models import PjdlReklameCahaya, PjdlReklamePasang
from . import PAD_TABLE_ARGS, StandarModel, Base, DBSession
from opensipkd.pjdl.models.reklame import (
PjdlReklameCahaya, PjdlReklameNilaiSudutPandang, PjdlReklamePasang,
PjdlReklameStatus, PjdlReklameNilaiSudutPandang)
class PjdlReklameHitung(Base, StandarModel):
__tablename__ = 'pad_rk_hitung'
__table_args__ = PAD_TABLE_ARGS
id = Column(Integer, primary_key=True)
pajak_id = Column(Integer(), ForeignKey(PjdlPajak.id), nullable=False, )
bahan = Column(String(128))
satuan = Column(String(32))
biaya = Column(Integer())
# masapajak = Column(SmallInteger(), nullable=False)
# jatuhtempo = Column(SmallInteger())
# multiple = Column(SmallInteger())
cahaya_id = Column(Integer(), ForeignKey(
PjdlReklameCahaya.id), nullable=False,)
# Cara Pemasangan ditempel ditanam menyebar
pasang_id = Column(SmallInteger(), ForeignKey(
PjdlReklamePasang.id), nullable=False,)
status_id = Column(Integer()) # Status Permanen
@classmethod
def get_bahan(cls, db_session=DBSession):
return db_session.query(func.distinct(cls.bahan).label("bahan"))
@classmethod
def get_nilai(cls, values, db_session=DBSession):
row = cls.query().filter_by(
pajak_id=int(values["pajak_id"]),
bahan=values["bahan"],
cahaya_id=int(values["cahaya_id"]),
status_id=int(values["status_id"]),
pasang_id=int(values["pasang_id"])).first()
return row and row.biaya or None
@classmethod
def query_register(cls, order_field="id"):
return cls.query_from(columns =[PjdlPajak.pajaknm.label('Pajak'),
PjdlReklameCahaya.nama.label('Cahaya'),
PjdlReklamePasang.nama.label('Cara Pasang'),
cls.bahan.label('Bahan'),
cls.biaya.label('Biaya'),
cls.status.label('Status'),
PjdlReklameStatus.nama.label('Permanen')]). \
outerjoin(PjdlPajak, PjdlPajak.id == cls.pajak_id).\
outerjoin(PjdlReklameStatus, PjdlReklameStatus.id == cls.status_id).\
outerjoin(PjdlReklameCahaya, PjdlReklameCahaya.id == cls.cahaya_id).\
outerjoin(PjdlReklamePasang, PjdlReklamePasang.id == cls.pasang_id).\
order_by(getattr(cls, order_field))
tangsel/pdl/models/reklame_lama.py 0 → 100644
from sqlalchemy import Column, DateTime, Float, ForeignKey, Integer, String
from . import Base, DefaultModel
from . import PAD_TABLE_ARGS
class PadRekNsr(Base, DefaultModel):
__tablename__ = 'pad_rek_nsr'
id = Column(Integer, primary_key=True)
nsrnm = Column(String(150))
nilai = Column(Float)
__table_args__ = PAD_TABLE_ARGS
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.nsrnm.ilike(f'{nama}%'))
class PadRekJalanKlas(Base, DefaultModel):
__tablename__ = 'pad_rek_jalan_klas'
id = Column(Integer, primary_key=True)
kelasnm = Column(String(254))
nilai = Column(Float)
__table_args__ = PAD_TABLE_ARGS
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.kelasnm.ilike(f'{nama}%'))
class PadRekJalan(Base, DefaultModel):
__tablename__ = 'pad_rek_jalan'
id = Column(Integer, primary_key=True)
jalan_klas_id = Column(Integer, ForeignKey('pad.pad_rek_jalan_klas.id'))
jalankd = Column(String(3), nullable=False)
jalannm = Column(String(108))
tmt = Column(DateTime)
enabled = Column(Integer)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
__table_args__ = PAD_TABLE_ARGS
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.jalannm.ilike(f'{nama}%'))
@classmethod
def query_kode(cls, kode):
return cls.query().filter(cls.jalankd.ilike(f'{kode}%'))
class PadRekLokasiPasang(Base, DefaultModel):
"""Tabel Ini berlaku di versi 1 untuk kompatibilatas harus tersedia juga
di versi 2
Args:
Base (_type_): _description_
DefaultModel (_type_): _description_
Returns:
_type_: _description_
"""
__tablename__ = 'pad_rek_lokasi_pasang'
id = Column(Integer, primary_key=True)
lokasinm = Column(String(50))
nilai = Column(Float)
lahan = Column(String(10))
__table_args__ = PAD_TABLE_ARGS
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.lokasinm.ilike(f'{nama}%'))
class PadRekSudutPandang(Base, DefaultModel):
__tablename__ = 'pad_rek_sudut_pandang'
id = Column(Integer, primary_key=True)
sudutnm = Column(String(50))
nilai = Column(Float)
__table_args__ = PAD_TABLE_ARGS
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.sudutnm.ilike(f'{nama}%'))
tangsel/pdl/models/reports.py 0 → 100644
from collections import OrderedDict
from sqlalchemy import (
Column,
DateTime,
ForeignKey,
Integer,
String,
SmallInteger,
JSON
)
from . import PAD_TABLE_ARGS, Base, NamaModel, DefaultModel
REPORT_DICT = OrderedDict ({"1": "Master",
"2": "Pendataan",
"3": "Self",
"4": "Official",
"5": "Penerimaan",
"6" : "Penagihan",
"99": "Lain-Lain"}) # untuk cetakan yang bukan laporan - per ID
REPORT_CATEGORY = ((int(k), REPORT_DICT[k])for k in REPORT_DICT)
class PjdlReports(Base, NamaModel):
__tablename__ = 'pad_reports'
__table_args__ = PAD_TABLE_ARGS
id = Column(Integer, primary_key=True)
category_id = Column(Integer())
report_id = Column(Integer()) # Susunan Dalam Tampilan
kode = Column(String(50), nullable=False)
nama = Column(String(50), nullable=False)
params = Column(JSON())
status = Column(SmallInteger())
@classmethod
def get_list(cls, category_id=None):
r = []
q = cls.query().order_by(cls.report_id)
if category_id:
q = q.filter_by(category_id=category_id)
for row in q:
g = (str(row.kode), f"{row.nama}")
r.append(g)
return r
class PjdlReportItems(Base, DefaultModel):
__tablename__ = 'pad_report_items'
__table_args__ = PAD_TABLE_ARGS
id = Column(Integer, primary_key=True)
report_id = Column(Integer(), ForeignKey(PjdlReports.id)) # Susunan Dalam Tampilan
# kecamatan_id = Column(Integer())
# kelurahan_id = Column(Integer())
# op_id = Column(Integer())
# wp_id = Column(Integer())
# start_date = Column(DateTime())
# end_date = Column(DateTime())
params = Column(JSON())
file_name = Column(String())
tangsel/pdl/models/scripts/data/nilai_strategis.csv 0 → 100644
id,status_id/pad.pad_rk_status_reklame.nm_status_reklame,luas_min,luas_max,nilai,nilai_other
1,REKLAME PERMANEN,0,2,10000,50000
2,REKLAME PERMANEN,2.01,4,100000,150000
3,REKLAME PERMANEN,4.01,8,250000,300000
4,REKLAME PERMANEN,8.01,17.99,400000,500000
5,REKLAME PERMANEN,18,31.99,600000,800000
6,REKLAME PERMANEN,32,49.99,1000000,1200000
7,REKLAME PERMANEN,50,74.99,1600000,1800000
8,REKLAME PERMANEN,75,99.99,1800000,2200000
9,REKLAME PERMANEN,100,0,3200000,3500000
10,REKLAME INSIDENTIL,0,1,4000,6000
11,REKLAME INSIDENTIL,1.01,2,10000,15000
12,REKLAME INSIDENTIL,2.01,4,20000,25000
13,REKLAME INSIDENTIL,4.01,6,30000,40000
14,REKLAME INSIDENTIL,6.01,8,45000,50000
15,REKLAME INSIDENTIL,8.01,10,55000,60000
16,REKLAME INSIDENTIL,10.01,12,65000,80000
17,REKLAME INSIDENTIL,12.01,0,90000,100000
\ No newline at end of file
tangsel/pdl/models/scripts/data/rk_cahaya.csv 0 → 100644
id,status,kode,nama,nilai
-1,1,na,N/A,0
1,1,chy,Disinari,0
2,1,nch,Tidak Disinari,0
\ No newline at end of file
tangsel/pdl/models/scripts/data/rk_kelas_jalan.csv 0 → 100644
id,kode,nm_kelas_jalan
-1,-01,N/A
1,001,Jalan Nasional
2,002,Jalan Propinsi
3,003,Jalan Kota
4,004,Jalan Desa/Lingkungan
tangsel/pdl/models/scripts/data/rk_lokasi.csv 0 → 100644
id,kode,nm_lokasi
-1,N/A,N/A
1,001,Kawasan Khusus
2,002,Kawasan Kota
3,003,Kawasan Perkantoran dan Pendidikan
4,004,Kawasan Perumahan
5,005,Berjalan
7,007,Dalam Ruangan
8,008,Udara
6,006,Megatron/Bando
\ No newline at end of file
tangsel/pdl/models/scripts/data/rk_nilai_kj.csv 0 → 100644
id,pajak_id/pad.pad_pajak.pajaknm,status_id,kelas_jalan_id,letak_reklame_id,bobot,skor,other_score
1 ,N/A , 1, 1, 2, 0.25, 10, 2
2 ,N/A , 1, 2, 2, 0.25, 9, 2
3 ,N/A , 1, 3, 2, 0.25, 8, 2
4 ,N/A , 1, 4, 2, 0.25, 5, 2
5 ,Kendaraan / Berjalan , 1, -1, 2, 0.25, 5, 2
6 ,Megatron , 1, -1, 2, 0.25, 10, 2
7 ,Bando , 1, -1, 2, 0.25, 10, 2
8 ,N/A , 1, -1, 1, 0.25, 0, 0
9 ,N/A , 2, -1, 2, 0.25, 10, 2
10,N/A , 2, -1, 1, 0.25, 0, 0
11,Udara , 2, -1, 2, 0.25, 10, 2
\ No newline at end of file
tangsel/pdl/models/scripts/data/rk_pasang.csv 0 → 100644
id,status,kode,nama,nilai
-1,1,na,N/A,0
1,1,01,DTEMPEL,0
2,1,02,DITANAM,0
3,1,03,TERSEBAR,0
4,1,04,MELINTANG,0
tangsel/pdl/models/scripts/data/rk_sp.csv 0 → 100644
id,kode,jumlah_sudut_pandang
1,001,1
2,002,2
3,003,3
4,004,4
5,005,>4
-1,-01,N/A
\ No newline at end of file
tangsel/pdl/models/scripts/data/rk_status.csv 0 → 100644
id,kode,nm_status_reklame
1,001,REKLAME PERMANEN
2,002,REKLAME INSIDENTIL
tangsel/pdl/models/scripts/data/rk_tinggi.csv 0 → 100644
id,status_id,tinggi_min,tinggi_max,bobot,pajak_id
1,1,0,4,0.25,1,-1
2,1,4.01,7.99,0.25,-1
3,1,8,1000,0.65,-1
4,2,0,1000,0.25,1413
5,2,0,1000,0.1,1426
6,2,0,1000,0.1,1416
7,2,0,1000,0.05,1417
8,2,0,1000,0.5,1419
9,2,0,100,0.1,1420
10,2,0,1000,0,1421
\ No newline at end of file
tangsel/pdl/models/scripts/initializedb.py 0 → 100644
import os
import sys
import transaction
from opensipkd.base import Base
from opensipkd.base.scripts.initializedb import alembic_run, restore_csv
from opensipkd.models import DBSession
from opensipkd.base.scripts.initializedb import create_schema
from pyramid.paster import (
get_appsettings,
setup_logging,
)
from sqlalchemy import engine_from_config
from .. import (
PjdlReklameNilaiStrategis, PjdlReklamePasang, PjdlReklameLokasi,
PjdlReklameStatus, PjdlReklameSudutPandang, PjdlReklameKelasJalan,
PjdlReklameNilaiKelasJalan, PjdlReklameCahaya)
def get_file(filename):
base_dir = os.path.split(__file__)[0]
fullpath = os.path.join(base_dir, 'data', filename)
return open(fullpath)
def usage(argv):
pass
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
bin_path = os.path.split(sys.executable)[0]
# pjdl_engine = engine_from_config(settings, 'sqlalchemy.')
# ModuleDBSession.configure(bind=pjdl_engine)
# ModuleBase.metadata.bind = pjdl_engine
# ModuleBase.metadata.create_all()
# init_model()
# reset_sequences()
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.bind = engine
create_schema(engine, "pad")
Base.metadata.create_all(bind=engine)
# ModuleBase.metadata.create_all()
alembic_run(config_uri, 'alembic_pjdl')
print('>>Append Table')
# restore_csv(PjdlReklameStatus,
# 'rk_status.csv', get_file, DBSession)
# restore_csv(PjdlReklameKelasJalan,
# 'rk_kelas_jalan.csv', get_file, DBSession)
# restore_csv(PjdlReklameNilaiStrategis,
# 'nilai_strategis.csv', get_file, DBSession)
# restore_csv(PjdlReklameCahaya,
# 'rk_cahaya.csv', get_file, DBSession)
# restore_csv(PjdlReklamePasang,
# 'rk_pasang.csv', get_file, DBSession)
# restore_csv(PjdlReklameLokasi,
# 'rk_lokasi.csv', get_file, DBSession)
# restore_csv(PjdlReklameSudutPandang,
# 'rk_sp.csv', get_file, DBSession)
# restore_csv(PjdlReklameNilaiKelasJalan,
# 'rk_nilai_kj.csv', get_file, DBSession)
transaction.commit()
print('>>Appended')
print('****PJDL Models CREATED****')
def migrate(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
alembic_run(config_uri, 'alembic_pjdl')
transaction.commit()
print('>>Migrated')
print('****PJDL Models Migrated****')
main(argv)
\ No newline at end of file
tangsel/pdl/models/spt_air.py 0 → 100644
from sqlalchemy import (Column, Integer, DateTime, ForeignKey, String,
SmallInteger, BigInteger, Float)
from sqlalchemy.orm import (relationship)
# from opensipkd.pjdl.models.bak.air import AtSumberAlternatif
from . import PAD_TABLE_ARGS, Base, DBSession, DefaultModel
from . import (
PjdlOp, PjdlKecamatan, PjdlKelurahan, PjdlAirtanahZona,
PjdlAirtanahKualitas, PjdlAirtanahSumberAlternatif,
PjdlAirtanahJenisSumber, PjdlAirtanahJenisManfaat)
class PjdlSptAir(Base, DefaultModel):
__tablename__ = 'pad_spt_at_det'
__table_args__ = PAD_TABLE_ARGS
id = Column(BigInteger, primary_key=True)
spt_id = Column(ForeignKey('pad.pad_spt.id'))
customer_usaha_id = Column(ForeignKey(
PjdlOp.id, ondelete='CASCADE', onupdate='CASCADE'))
alamat = Column(String(255))
kecamatan_id = Column(ForeignKey(PjdlKecamatan.id, onupdate='CASCADE'))
kelurahan_id = Column(ForeignKey(PjdlKelurahan.id, onupdate='CASCADE'))
titik_ke = Column(Integer)
zona_id = Column(ForeignKey(PjdlAirtanahZona.id, onupdate='CASCADE'))
kualitas_id = Column(ForeignKey(
PjdlAirtanahKualitas.id, onupdate='CASCADE'))
sumber_alternatif_id = Column(ForeignKey(
PjdlAirtanahSumberAlternatif.id, onupdate='CASCADE'))
jenis_sumber_id = Column(ForeignKey(
PjdlAirtanahJenisSumber.id, onupdate='CASCADE'))
manfaat_id = Column(ForeignKey(
PjdlAirtanahJenisManfaat.id, onupdate='CASCADE'))
volume = Column(Integer)
ksda = Column(Float(53))
volume_progresif = Column(String(50))
volume_progresif_val = Column(Integer)
indeks_kp = Column(Float(53))
kp = Column(Float(53))
fna = Column(Float(53))
hab = Column(Float(53))
hda = Column(BigInteger)
npa = Column(BigInteger)
# penggunaan_id = Column(ForeignKey('pad.pad_at_penggunaan.id'))
volume_id = Column(ForeignKey('pad.pad_at_volume.id'))
no_izin = Column(String(255))
tanggal_izin = Column(DateTime)
status = Column(SmallInteger)
tanggal_pencatatan = Column(DateTime)
volume_diizinkan = Column(Integer)
meteran_awal = Column(Integer)
meteran_akhir = Column(Integer)
volume_pemakaian = Column(Integer)
volume_kelebihan_pemakaian = Column(Integer)
npa_normal = Column(BigInteger)
npa_kelebihan = Column(BigInteger)
npa_kelebihan_sanksi = Column(BigInteger)
uraian = Column(String(256))
customer_usaha = relationship('PjdlOp', backref='pad_spt_at_dets')
sumber_alternatif = relationship(
'PjdlAirtanahSumberAlternatif', backref='pad_spt_at_dets')
zona = relationship('PjdlAirtanahZona', backref='pad_spt_at_dets')
jenis_sumber = relationship(
'PjdlAirtanahJenisSumber', backref='pad_spt_at_dets')
kecamatan = relationship('PjdlKecamatan', backref='pad_spt_at_dets')
kelurahan = relationship('PjdlKelurahan', backref='pad_spt_at_dets')
kualitas = relationship('PjdlAirtanahKualitas', backref='pad_spt_at_dets')
manfaat = relationship('PjdlAirtanahJenisManfaat',
backref='pad_spt_at_dets')
spt = relationship('PjdlInvoice', backref='pad_spt_at_dets')
sumber_alternatif = relationship(
'PjdlAirtanahSumberAlternatif', backref='pad_spt_at_dets')
zona = relationship('PjdlAirtanahZona', backref='pad_spt_at_dets')
# at_penggunaan = relationship('AtPenggunaan')
# at_volume = relationship('AtVolume')
@classmethod
def get_sda(cls, atid):
result = DBSession.query(
cls.id,
PjdlAirtanahZona.nilai_komponen_sda.label('zonasda'),
PjdlAirtanahZona.nilai_indeks.label('zonaidx'),
PjdlAirtanahKualitas.nilai_indeks.label('kualitasidx'),
PjdlAirtanahSumberAlternatif.nilai_indeks.label('alternatifidx'),
PjdlAirtanahJenisSumber.nilai_indeks.label('sumberidx')
).\
join(PjdlAirtanahZona, PjdlAirtanahZona.id == cls.zona_id).\
join(PjdlAirtanahKualitas, PjdlAirtanahKualitas.id == cls.kualitas_id).\
join(PjdlAirtanahSumberAlternatif, PjdlAirtanahSumberAlternatif.id == cls.sumber_alternatif_id).\
join(PjdlAirtanahJenisSumber,
PjdlAirtanahJenisSumber.id == cls.jenis_sumber_id)
result = result.filter(cls.id == atid)
result = result.first()
if result:
rzonasda = result.zonasda
rzonaidx = result.zonaidx
rkualitasidx = result.kualitasidx
ralternatifidx = result.alternatifidx
rsumberidx = result.sumberidx
sda = rzonasda * (rzonaidx + rkualitasidx +
ralternatifidx + rsumberidx)
else:
sda = 0.0
return sda
tangsel/pdl/models/spt_reklame.py 0 → 100644
import math
from sqlalchemy import (
Column, ForeignKey, Integer, String, Float, Text, between, desc,)
from opensipkd.pjdl.models.pajak import relationship
from dateutil.relativedelta import relativedelta
from . import (
PAD_TABLE_ARGS, Base, DefaultModel, PjdlPajakTarif,
PjdlReklameKelasJalan, PjdlReklameLetak, PjdlReklameLokasi,
PjdlReklameNilaiKelasJalan, PjdlReklameNilaiLokasi, PjdlReklameProduk, PjdlReklameSatuanNilaiStrategis, PjdlReklameSudutPandang,
PjdlKecamatan, PjdlKelurahan, PjdlInvoice, PjdlPajak)
def get_lama(masapajak=1, masadari=None, masasd=None):
lama = 0
if masapajak == 1:
# tahunan
lama = 1
elif masapajak == 2:
# smesteran
diff = relativedelta(dt1=masasd, dt2=masadari)
lama = math.ceil(diff.months/6)
if masasd >= masadari+relativedelta(months=lama*6):
lama += 1
elif masapajak == 3:
# triwulanan
diff = relativedelta(dt1=masasd, dt2=masadari)
lama = math.ceil(diff.months/3)
if masasd >= masadari+relativedelta(months=lama*3):
lama += 1
elif masapajak == 4:
# bulanan
diff = relativedelta(dt1=masasd, dt2=masadari)
lama = math.ceil(diff.months)
if masasd >= masadari+relativedelta(months=lama):
lama += 1
elif masapajak == 5:
# Mingguan
diff = relativedelta(dt1=masasd, dt2=masadari)
lama = math.ceil(diff.days/7)
if masasd >= masadari+relativedelta(days=lama*7):
lama += 1
elif masapajak == 6:
# harian
diff = relativedelta(dt1=masasd, dt2=masadari)
lama = diff.days+1
return lama
class PjdlSptRkDet(Base, DefaultModel):
__tablename__ = 'pad_spt_rk_det'
id = Column(Integer, primary_key=True)
spt_id = Column(Integer, ForeignKey(PjdlInvoice.id))
reklame_ke = Column(Integer)
alamat = Column(String(255))
kecamatan_id = Column(Integer, ForeignKey(PjdlKecamatan.id))
kelurahan_id = Column(Integer, ForeignKey(PjdlKelurahan.id))
pajak_id = Column(Integer, ForeignKey(PjdlPajak.id))
letak_reklame_id = Column(Integer, ForeignKey(PjdlReklameLetak.id))
lokasi_id = Column(Integer, ForeignKey(PjdlReklameLokasi.id))
kelas_jalan_id = Column(Integer, ForeignKey(PjdlReklameKelasJalan.id))
sudut_pandang_id = Column(Integer, ForeignKey(PjdlReklameSudutPandang.id))
jenis_produk_reklame_id = Column(
Integer, ForeignKey(PjdlReklameProduk.id))
lokasi_nilai = Column(Float)
kelas_jalan_nilai = Column(Float)
sudut_pandang_nilai = Column(Float)
satuan_nilai_strategis = Column(Float)
panjang = Column(Float)
lebar = Column(Float)
tinggi = Column(Float)
muka = Column(Float)
banyak = Column(Float)
luas = Column(Float)
njopr = Column(Integer)
nspr = Column(Integer)
nsr = Column(Integer)
tinggi_nilai = Column(Float)
r_nsr = Column(Integer)
titik_reklame_id = Column(Text)
nopol = Column(Text)
__table_args__ = PAD_TABLE_ARGS
kecamatan = relationship('PjdlKecamatan', backref='pad_spt_rek_dets')
kelurahan = relationship('PjdlKelurahan', backref='pad_spt_rek_dets')
letak_reklame = relationship(
'PjdlReklameLetak', backref='pad_spt_rek_dets')
lokasi = relationship('PjdlReklameLokasi', backref='pad_spt_rek_dets')
kelas_jalan = relationship(
'PjdlReklameKelasJalan', backref='pad_spt_rek_dets')
sudut_pandang = relationship(
'PjdlReklameSudutPandang', backref='pad_spt_rek_dets')
spt = relationship(
'PjdlInvoice', backref='pad_spt_rek_dets')
def get_tarif(self):
masadari = self.spt.masadari
return PjdlPajakTarif.query_from(
columns=[
PjdlPajakTarif.tarif,
PjdlPajakTarif.minomset,
PjdlPajakTarif.reklame,
PjdlPajak.jatuhtempo,
PjdlPajak.multiple,
PjdlPajak.masapajak,
PjdlPajak.rekening_id])\
.filter(PjdlPajakTarif.pajak_id == self.pajak_id,
PjdlPajakTarif.tmt < masadari)\
.outerjoin(PjdlPajak, PjdlPajak.id == PjdlPajakTarif.pajak_id)\
.order_by(desc(PjdlPajakTarif.tmt)).first()
def get_nilai_lokasi(self):
nilai_lokasi = PjdlReklameNilaiLokasi.query()\
.filter(PjdlReklameNilaiLokasi.lokasi_id == self.lokasi_id,
PjdlReklameNilaiLokasi.pajak_id == self.pajak_id).first()
return nilai_lokasi and nilai_lokasi.nilai or 0
def get_nilai_kelas_jalan(self):
sudut_pandang_id = self.sudut_pandang_id and self.sudut_pandang_id or 0
nilai_kelas_jalan = PjdlReklameNilaiKelasJalan.query()\
.filter(PjdlReklameNilaiKelasJalan.kelas_jalan_id == self.kelas_jalan_id,
PjdlReklameNilaiKelasJalan.pajak_id == self.pajak_id).first()
return nilai_kelas_jalan and nilai_kelas_jalan.nilai or 0
def get_satuan_nilai_strategis(self):
satuan_nilai_strategis = PjdlReklameSatuanNilaiStrategis.query()\
.filter(PjdlReklameSatuanNilaiStrategis.pajak_id == self.pajak_id,
PjdlReklameSatuanNilaiStrategis.kelas_jalan_id == self.kelas_jalan_id
).first()
return satuan_nilai_strategis and satuan_nilai_strategis.nilai or 0
def get_tarif_letak(self):
letak = PjdlReklameLetak.query_id(self.spt.r_letak_reklame_id).first()
return letak and letak.tarif or 0
def get_tarif_produk(self):
produk = PjdlReklameProduk.query_id(
self.spt.r_jenis_produk_reklame_id).first()
return produk and produk.tarif or 0
def calculate(self):
masadari = self.spt.masadari
masasd = self.spt.masasd
pajak_tarif = self.get_tarif()
tarif = pajak_tarif.tarif
multiple = pajak_tarif.multiple
masa_pajak = pajak_tarif.masapajak # r_bayar_id
self.njopr = pajak_tarif.reklame
tinggi_nilai = 0
sudut_pandang_nilai = 0
self.lokasi_nilai = self.get_nilai_lokasi()
self.kelas_jalan_nilai = self.get_nilai_kelas_jalan()
self.r_nsr = self.get_satuan_nilai_strategis()
self.nspr = self.lokasi_nilai + self.kelas_jalan_nilai + self.njopr
self.sudut_pandang_nilai = 0
self.tinggi_nilai = 0
self.luas = self.panjang * self.lebar
self.r_lama = get_lama(masa_pajak, masadari, masasd)
self.nsr = (self.r_nsr * self.luas *
self.muka * self.banyak * self.r_lama) / tarif # 0.25
def get_satuan_nilai_strategis_v3(self):
pajak = PjdlPajak.query_id(self.spt.pajak_id).first()
satuan_nilai_strategis = PjdlReklameSatuanNilaiStrategis.query()\
.filter(PjdlReklameSatuanNilaiStrategis.status_reklame_id == pajak.status_reklame_id,
PjdlReklameSatuanNilaiStrategis.jenis_produk_reklame_id == self.spt.r_jenis_produk_reklame_id,
between(self.tinggi,
PjdlReklameSatuanNilaiStrategis.luas_min, PjdlReklameSatuanNilaiStrategis.luas_max)
).first()
return satuan_nilai_strategis and satuan_nilai_strategis.satuan_nilai_strategis or 0
def get_skor_kelas_jalan_v3(self):
nilai_kelas_jalan = PjdlReklameNilaiKelasJalan.query()\
.filter(PjdlReklameNilaiKelasJalan.kelas_jalan_id == self.kelas_jalan_id,
PjdlReklameNilaiKelasJalan.sudut_pandang_id == self.sudut_pandang_id).first()
return nilai_kelas_jalan and nilai_kelas_jalan.skor or 0
def calculatev3(self):
self.luas = self.panjang*self.lebar*self.muka
self.tinggi_nilai = 0
self.lokasi_nilai = self.get_nilai_lokasi()
self.sudut_pandang_nilai = self.get_skor_kelas_jalan_v3()
self.tinggi_nilai = self.get_satuan_nilai_strategis_v3()
pajak_tarif = self.get_tarif()
tarif = pajak_tarif.tarif
self.kelas_jalan_nilai = self.lokasi_nilai
self.satuan_nilai_strategis = 0
masa_pajak = pajak_tarif.masapajak
masa_pemasangan = get_lama(
masa_pajak, self.spt.masadari, self.spt.masasd)
hdur = pajak_tarif.reklame * masa_pemasangan
self.njopr = (self.luas * hdur) + (self.tinggi * self.tinggi_nilai)
self.nspr = self.sudut_pandang_nilai * self.lokasi_nilai
self.nsr = self.njopr + self.nspr
self.pajak = tarif * self.nsr
tarif_produk = self.get_tarif_produk()
if tarif_produk:
self.pajak = (1+tarif_produk)*self.pajak
tarif_letak = self.get_tarif_letak()
if tarif_letak:
self.pajak = (1+tarif_letak)*self.pajak
self.pajak_dibayar = self.pajak * self.banyak
tangsel/pdl/models/spt_tegur.py 0 → 100644
from datetime import datetime
from sqlalchemy import (Column, Integer, DateTime, ForeignKey,
UniqueConstraint, BigInteger, func)
from sqlalchemy.orm import (relationship)
from . import PAD_TABLE_ARGS, DefaultModel, Base
from . import (PjdlWp, PjdlOp, PjdlPajak,)
class PjdlSptTegur(Base, DefaultModel):
__tablename__ = 'pad_spt_tegur'
__table_args__ = (
UniqueConstraint('tahun', 'tegurno'),
PAD_TABLE_ARGS
)
id = Column(BigInteger, primary_key=True, index=True)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
tahun = Column(Integer, nullable=False, index=True)
tegurno = Column(Integer, nullable=False, index=True)
tegurtgl = Column(DateTime, nullable=False, index=True)
masa_bln = Column(Integer, nullable=False, index=True)
masa_thn = Column(Integer, nullable=False, index=True)
masa_dari = Column(DateTime, nullable=False, index=True)
masa_sd = Column(DateTime, nullable=False, index=True)
jatuhtempotgl = Column(DateTime, nullable=False, index=True)
ke = Column(Integer, nullable=False, index=True)
customer_id = Column(ForeignKey(
PjdlWp.id, onupdate='CASCADE'), nullable=False, index=True)
customer_usaha_id = Column(
ForeignKey(PjdlOp.id, ondelete='CASCADE', onupdate='CASCADE'),
nullable=False, index=True)
pajak_id = Column(ForeignKey(PjdlPajak.id, onupdate='CASCADE'),
nullable=False)
wp = relationship('PjdlWp', backref='pad_spt_tegur')
op = relationship('PjdlOp', backref='pad_spt_tegur')
pajak = relationship('PjdlPajak', backref='pad_spt_tegur')
@classmethod
def get_tegurno(cls, tahun=None):
if not tahun:
tahun = datetime.now().year
no = cls.query_from([func.max(cls.tegurno)])\
.filter_by(tahun=tahun).scalar()
return no and no + 1 or 1
@classmethod
def get_ke(cls, value):
customer_usaha_id = value["customer_usaha_id"]
ke = cls.query_from([func.max(cls.ke)])\
.filter_by(customer_usaha_id=customer_usaha_id,
masa_thn=value["masa_thn"],
masa_bln=value["masa_bln"],
).scalar()
ke = ke and ke + 1 or 1
if ke>3:
raise Exception("Teguran hanya 3 kali silahkan tetapkan dengan SKPD Jabatan")
return ke
@classmethod
def get_prev(cls, value):
customer_usaha_id = value["customer_usaha_id"]
jth_tempo = cls.query_from([func.max(cls.jatuhtempotgl)])\
.filter_by(customer_usaha_id=customer_usaha_id,
masa_thn=value["masa_thn"],
masa_bln=value["masa_bln"],
).scalar()
if jth_tempo and jth_tempo > value["tegurtgl"]:
raise Exception("Teguran sebelumnya belum jatuh tempo")
tangsel/pdl/models/spt_type.py 0 → 100644
from sqlalchemy import (
BigInteger,
Boolean,
Column,
Float,
Integer,
DateTime,
String,
SmallInteger
)
from sqlalchemy.ext.hybrid import hybrid_property
from . import PAD_TABLE_ARGS, DefaultModel, Base
class PjdlSptType(Base, DefaultModel):
__tablename__ = 'pad_spt_type'
__table_args__ = PAD_TABLE_ARGS
id = Column(SmallInteger, primary_key=True)
typenm = Column(String(20), nullable=False)
tmt = Column(DateTime)
enabled = Column(SmallInteger)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
typenm_skt = Column(String(20))
persen_denda = Column(Float, default=0, nullable=False)
is_hari_kerja = Column(Boolean, default=False)
denda = Column(BigInteger, default=0, nullable=False)
denda_badan = Column(BigInteger, default=0, nullable=False)
max_day = Column(Integer, default=0, nullable=False)
max_denda = Column(Integer, default=0, nullable=False)
@hybrid_property
def nama(self):
return self.typenm
@nama.setter
def nama(self, nama):
self.typenm = nama
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.typenm == nama)
@classmethod
def query_register(cls, order_field="typenm"):
return cls.query_from(columns=[cls.typenm.label('nama'),
cls.typenm_skt.label('singkat'),
cls.enabled.label('Aktif')]).\
order_by(getattr(cls, order_field))
@classmethod
def get_list(cls):
r = []
q = cls.query().order_by(cls.kecamatannm)
for row in q:
g = (str(row.id), f"{row.typenm_skt}/ {row.typenm}")
r.append(g)
return r
tangsel/pdl/models/sspd_payment.py 0 → 100644
from datetime import datetime
from sqlalchemy import (
Column, Integer, DateTime, ForeignKey, UniqueConstraint,
String, SmallInteger, BigInteger, Float, cast, func, Time)
from sqlalchemy.schema import FetchedValue
from sqlalchemy.orm import (relationship, backref)
from . import PAD_TABLE_ARGS, DefaultModel, Base
from . import (PjdlInvoice, DBSession)
class PjdlPayment(Base, DefaultModel):
__tablename__ = 'pad_sspd'
__table_args__ = (
UniqueConstraint('tahun', 'sspdno'),
PAD_TABLE_ARGS
)
id = Column(BigInteger, primary_key=True, index=True)
tahun = Column(Integer, nullable=False, index=True)
sspdno = Column(Integer, nullable=False, index=True)
sspdtgl = Column(DateTime, nullable=False, index=True)
spt_id = Column(ForeignKey(PjdlInvoice.id), nullable=False, index=True)
bunga = Column(Float(53), server_default=FetchedValue())
bulan_telat = Column(Integer, server_default=FetchedValue())
hitung_bunga = Column(SmallInteger, server_default=FetchedValue())
printed = Column(SmallInteger, server_default=FetchedValue())
enabled = Column(SmallInteger, server_default=FetchedValue())
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
sspdjam = Column(Time)
tp_id = Column(Integer, server_default=FetchedValue())
is_validated = Column(Integer, server_default=FetchedValue())
keterangan = Column(String(255))
denda = Column(BigInteger, server_default=FetchedValue())
jml_bayar = Column(BigInteger, server_default=FetchedValue())
is_valid = Column(Integer, server_default=FetchedValue())
cancel_bunga = Column(BigInteger)
cancel_denda = Column(BigInteger)
cancel_date = Column(DateTime)
cancel_jml_bayar = Column(BigInteger)
cancel_uid = Column(Integer)
opsen_denda = Column(BigInteger)
opsen_bayar = Column(BigInteger)
opsen_bunga = Column(BigInteger)
posted = Column(SmallInteger, nullable=False,
server_default=FetchedValue())
posting_simda_penetapan = Column(
SmallInteger, nullable=False, server_default=FetchedValue())
posting_simda_non_penetapan = Column(
SmallInteger, nullable=False, server_default=FetchedValue())
spt = relationship(
'PjdlInvoice', primaryjoin='PjdlPayment.spt_id == PjdlInvoice.id', backref='pad_sspds')
@classmethod
def get_no_bayar(cls):
strid = cast(cls.id, String)
strid = func.lpad(strid, 6, '0')
hasil = func.concat(cls.tahun, '-')
hasil = func.concat(hasil, strid)
return hasil
@classmethod
def get_bayarno(cls):
strTahun = cast(cls.tahun, String)
strSspdno = cast(cls.sspdno, String)
fixSspdno = func.lpad(strSspdno, 6, '0')
result = strTahun + '-' + fixSspdno
return result
@classmethod
def get_sspd_no(cls, row=None):
if not row:
tahun = datetime.now().year
else:
tahun = row.tahun
result = DBSession.query(func.max(cls.sspdno)).\
filter_by(tahun=tahun).scalar()
result = result and result > 0 and result+1 or 1
return result
tangsel/pdl/models/stpd.py 0 → 100644
from sqlalchemy import (
Column,
Integer,
DateTime,
ForeignKey,
UniqueConstraint,
Float,
func,
Time)
from sqlalchemy.schema import FetchedValue
from sqlalchemy.orm import (relationship, backref)
from datetime import datetime
from opensipkd.pjdl.models.spt_invoice import PjdlInvoice
from . import PAD_TABLE_ARGS, DefaultModel, Base
from . import (DBSession)
from opensipkd.tools import date_from_str, ymd
class PjdlStpd(Base, DefaultModel):
__tablename__ = 'pad_stpd'
__table_args__ = (
UniqueConstraint('tahun', 'stpdno'),
PAD_TABLE_ARGS
)
id = Column(Integer, primary_key=True)
tahun = Column(Integer, nullable=False)
stpdno = Column(Integer, nullable=False)
stpdtgl = Column(DateTime, nullable=False)
spt_id = Column(Integer, ForeignKey(PjdlInvoice.id), nullable=False, )
jatuhtempotgl = Column(DateTime)
printed = Column(Integer, nullable=False)
stpdcount = Column(Integer, nullable=False)
bunga = Column(Float)
opsen_bunga = Column(Float)
enabled = Column(Integer)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
invoice = relationship(
'PjdlInvoice', primaryjoin='PjdlInvoice.id == PjdlStpd.spt_id', backref='stpd')
@classmethod
def get_join(cls):
result = DBSession.query(cls.spt_id, func.max(cls.id).label('id'),
func.max(cls.stpdno).label('stpdno'),
func.max(cls.stpdcount).label('stpdcount'),
func.max(cls.stpdtgl).label('stpdtgl'),
func.max(cls.jatuhtempotgl).label(
'jatuhtempotgl'),
func.max(cls.bunga).label('bunga')).\
group_by(cls.spt_id).subquery()
return result
@classmethod
def generate_stpdno(cls, tahun=None):
if not tahun:
tahun = datetime.now().year
result = DBSession.query(func.max(cls.stpdno)).\
filter_by(tahun=tahun).scalar()
result = result and result > 0 and result+1 or 1
return result
@classmethod
def get_stpno(self, id=None):
stpno = func.get_stpno(id)
return stpno
tangsel/pdl/models/tblpemda.py 0 → 100644
from sqlalchemy import (
Column,
Integer,
DateTime,
String,
SmallInteger,
BigInteger,
Float
)
from . import PAD_TABLE_ARGS, CommonModel, Base, DefaultModel
class PjdlPemda(Base, DefaultModel):
__tablename__ = 'tblpemda'
__table_args__ = PAD_TABLE_ARGS
id = Column(Integer, primary_key=True)
type = Column(String(100))
kepalanm = Column(String(100))
alamat = Column(String(255))
telp = Column(String(100))
pemdanm = Column(String(255))
ibukota = Column(String(100))
tmt = Column(DateTime)
enabled = Column(SmallInteger)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
jabatan = Column(String(20))
ppkd_id = Column(BigInteger)
sptyearly = Column(SmallInteger)
sspdyearly = Column(SmallInteger)
skpdyearly = Column(SmallInteger)
kasiryearly = Column(SmallInteger)
reklame_id = Column(SmallInteger)
pendapatan_id = Column(Integer)
pemdanmskt = Column(String(50))
hda = Column(Float(53))
airtanah_id = Column(SmallInteger)
self_dok_id = Column(Integer)
office_dok_id = Column(Integer)
tgl_jatuhtempo_self = Column(Integer)
spt_denda = Column(Float(53))
tgl_spt = Column(Integer)
pad_bunga = Column(Float(53))
mineral_id = Column(Integer)
fax = Column(String(100))
website = Column(String(255))
email = Column(String(100))
daerah = Column(String(255))
alamat_lengkap = Column(String(255))
tangsel/pdl/models/tp.py 0 → 100644
from sqlalchemy import (
Column,
Integer,
String
)
from sqlalchemy.ext.hybrid import hybrid_property
from . import PUBLIC_TABLE_ARGS, DefaultModel, Base
class PjdlTp(Base, DefaultModel):
__tablename__ = 'pad_tp'
__table_args__ = PUBLIC_TABLE_ARGS
id = Column(Integer, primary_key=True)
singkatan = Column(String, nullable=False, unique=True)
nama = Column(String, nullable=False, unique=True)
@hybrid_property
def kode(self):
return self.singkatan
@kode.setter
def kode(self, kode):
self.singkatan = kode
@classmethod
def query_kode(cls, kode):
return cls.query().filter(cls.singkatan == kode)
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.nama == nama)
@classmethod
def query_register(cls, order_field="nama"):
return cls.query_from(columns =[cls.singkatan, cls.nama]).\
order_by(getattr(cls, order_field))
@classmethod
def get_list(cls):
r = []
q = cls.query().order_by(cls.kecamatannm)
for row in q:
g = (str(row.id), f"{row.kode}/ {row.nama}")
r.append(g)
return r
\ No newline at end of file
tangsel/pdl/models/uptd.py 0 → 100644
from sqlalchemy import Column, ForeignKey, Integer, String
from opensipkd.pjdl.models import PAD_TABLE_ARGS
from opensipkd.models import User
from opensipkd.pjdl.models.kecamatan import PjdlKecamatan
from . import Base, DefaultModel
from sqlalchemy import (
Column,
String
)
from sqlalchemy.ext.hybrid import hybrid_property
class PjdlUptd(Base, DefaultModel):
__tablename__ = 'uptd'
__table_args__ = PAD_TABLE_ARGS
kode = Column(String(20), nullable=False, unique=True)
nama = Column(String(50), nullable=False, unique=True)
@classmethod
def query_kode(cls, kode):
return cls.query().filter_by(kode=kode)
@classmethod
def query_nama(cls, nama):
return cls.query().filter_by(nama=nama)
@classmethod
def query_register(cls, order_field="nama"):
return cls.query_from(columns=[cls.singkatan, cls.nama]).\
order_by(getattr(cls, order_field))
@classmethod
def get_list(cls):
r = []
q = cls.query().order_by(cls.nama)
for row in q:
g = (str(row.id), f"{row.kode}: {row.nama}")
r.append(g)
return r
class PjdlUptdWilayah(Base, DefaultModel):
__tablename__ = 'uptd_wilayah'
__table_args__ = PAD_TABLE_ARGS
uptd_id = Column(Integer, ForeignKey(PjdlUptd.id))
kecamatan_id = Column(Integer, ForeignKey(PjdlKecamatan.id))
class PjdlUserUptd(Base, DefaultModel):
__tablename__ = 'user_uptd'
__table_args__ = PAD_TABLE_ARGS
uptd_id = Column(Integer, ForeignKey(PjdlUptd.id))
user_id = Column(Integer, ForeignKey(User.id))
tangsel/pdl/models/usaha.py 0 → 100644
import colander
from sqlalchemy import (
Column,
Integer,
DateTime,
String,
SmallInteger
)
from sqlalchemy.ext.hybrid import hybrid_property
from . import PAD_TABLE_ARGS, DefaultModel, Base
class PjdlUsaha(Base, DefaultModel):
__tablename__ = 'pad_usaha'
__table_args__ = PAD_TABLE_ARGS
id = Column(Integer, primary_key=True)
usahanm = Column(String(50), nullable=False)
so = Column(String(1))
tmt = Column(DateTime)
enabled = Column(SmallInteger)
create_date = Column(DateTime)
create_uid = Column(Integer)
write_date = Column(DateTime)
write_uid = Column(Integer)
@hybrid_property
def nama(self):
return self.usahanm
@nama.setter
def nama(self, kode):
self.usahanm = kode
@classmethod
def query_nama(cls, nama):
return cls.query().filter(cls.usahanm == nama)
@classmethod
def query_register(cls, order_field="usahanm"):
return cls.query_from(columns =[cls.usahanm.label('Nama'),
cls.so.label('Self/Official'),
cls.tmt.label('tmt'), cls.enabled.label('Status')]). \
order_by(getattr(cls, order_field))
@classmethod
def get_list(cls):
r = [("","Pilih Usaha")]
q = cls.query().order_by(cls.usahanm)
for row in q:
g = (str(row.id), f"{row.nama}")
r.append(g)
return r
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!