perbaikan route callback

.vs/ProjectSettings.json

+{
+  "CurrentProjectSetting": null
+}
\ No newline at end of file

.vs/PythonSettings.json

+{
+  "Interpreter": "Global|VisualStudio|Scripts"
+}
\ No newline at end of file

.vs/VSWorkspaceState.json

+{
+  "ExpandedNodes": [
+    "",
+    "\\base",
+    "\\developers",
+    "\\opensipkd",
+    "\\opensipkd\\base"
+  ],
+  "SelectedNode": "\\opensipkd\\base\\handlers.py",
+  "PreviewInSolutionExplorer": false
+}
\ No newline at end of file

opensipkd/base/scripts/initializedb.py

@@ -28,6 +28,55 @@ log = logging.getLogger(__name__)
 # from .tools import mkdir
 
 
+def routes_callback(typ, **kwargs):
+    if typ == "mapping":
+        return kwargs.get("value")
+    if typ == "value":
+        data = kwargs.get("data")
+        field = kwargs.get("field")
+        splited = data["kode"].split("-")
+        value = None
+        splited_last = splited[len(splited) - 1]
+        if field == "module":
+            value = splited[0]
+        elif field == "def_func":
+            if data["def_func"]:
+                return data["def_func"]
+            elif splited_last == 'menu':
+                return None
+            value = splited_last
+        elif field == "class_view":
+            if data["def_func"] == "list" and not data["class_view"]:
+                return "_".join(splited[1:])
+
+            if splited_last == "menu":
+                return None
+            value = "_".join(splited[1:-1])
+
+        elif field == "path":
+            if splited_last == "menu":
+                return "-".join(splited)
+            elif splited_last in ["act", "report"]:
+                return "/" + "/".join(splited[:-1]) + "/{act}/" + splited_last
+            elif splited_last == "report":
+                return "/" + "/".join(splited[:-1]) + "/{act}/act"
+            elif splited_last in ["edit", "view", "delete"]:
+                return "/" + "/".join(splited[:-1]) + "/{id}/" + splited_last
+            else:
+                return "/" + "/".join(splited)
+        elif field == "template":
+            if splited_last == "act":
+                return "json"
+            elif data["template"]:
+                return data["template"]
+
+            elif data["def_func"] == "list":
+                return "list.pt"
+            else:
+                return "form.pt"
+
+        return value
+
 def usage(argv):
     cmd = os.path.basename(argv[0])
     print('usage: %s <config_uri>\n'
@@ -81,7 +130,7 @@ def restore_csv(table, filename, get_file_func=get_file, db_session=DBSession):
                     try:
                         t = fieldname.split('/')
                     except Exception as e:
-                        print(fieldname, cf.keys())
+                        # print(fieldname, cf.keys())
                         raise e
 
                     fname_orig = t[0]
@@ -156,17 +205,17 @@ def append_csv(table, filename, keys, get_file_func=get_file,
     callback = args.get("callback")
     delimiter = args.get("delimiter")
     ext = get_ext(filename).lower()
-    log.debug(f"Extension: {ext.strip()}")
-    log.debug(f"Extension: {ext.strip() == '.tsv'}")
+    # log.debug(f"Extension: {ext.strip()}")
+    # log.debug(f"Extension: {ext.strip() == '.tsv'}")
     if not delimiter:
         delimiter = ","
         if ext.strip() == '.tsv':
             delimiter = "\t"
 
-    log.debug(f"Delimiter: {delimiter}")
+    # log.debug(f"Delimiter: {delimiter}")
     insp = inspect(DBSession.connection())
-    print(dir(table.__table__))
-    print("____")
+    # print(dir(table.__table__))
+    # print("____")
     schema = hasattr(table.__table__, "schema") and table.__table__.schema or "public"
     columns_table = insp.get_columns(table.__tablename__, schema)
     fields = {}
@@ -181,7 +230,7 @@ def append_csv(table, filename, keys, get_file_func=get_file,
         is_first = True
         fmap = dict()
         for cf in reader:
-            log.debug(f"Column Field: {cf}")
+            # log.debug(f"Column Field: {cf}")
             if is_first:
                 is_first = False
                 for fname in cf.keys():
@@ -190,7 +239,7 @@ def append_csv(table, filename, keys, get_file_func=get_file,
                     try:
                         t = fname.split('/')
                     except Exception as e:
-                        log.debug(fname, cf.keys())
+                        # log.debug(fname, cf.keys())
                         raise e
 
                     fname_orig = t[0]
@@ -229,7 +278,7 @@ def append_csv(table, filename, keys, get_file_func=get_file,
                     # merubah v1.4 ke v.2
                     # sql = select([foreign_table]).where(foreign_field == value)
                     sql = select(foreign_table).where(foreign_field == value)
-                    log.debug(f"Query Foreignkey: {str(sql)}")
+                    # log.debug(f"Query Foreignkey: {str(sql)}")
                     # merubah v1.4 ke v.2
                     # q = Base.metadata.bind.execute(sql)
                     with eng.connect() as conn:
@@ -250,7 +299,6 @@ def append_csv(table, filename, keys, get_file_func=get_file,
                 if key not in data or not data[key]:
                     raise Exception(f"Key Field '{key}' wajib ada")
                 filter_[key] = data[key]
-
             q = db_session.query(table).filter_by(**filter_)
             row = q.first()
             if row:
@@ -281,13 +329,15 @@ def append_csv(table, filename, keys, get_file_func=get_file,
                     # update: tambah periksa nilai default.
                     # Jika default=None berarti wajib ada nilainya
                     # by tatang 2024-10-12
-                    log.debug(data)
+                    # log.debug(data)
                     raise Exception(
                         f"Table {str(table.__name__)} Field '{c['name']}' wajib ada {c['type']} ")
 
             db_session.add(row)
             db_session.flush()
             if user:
+                print("Table: ", table.__name__, filter_)
+
                 row = db_session.query(User).filter_by(id=row.id).first()
                 init_model()
                 UserService.set_password(row, password)

opensipkd/base/views/routes.py

@@ -28,6 +28,9 @@ def route_widget_form():
 class EditSchema(colander.Schema):
     id = colander.SchemaNode(
         colander.Integer(), widget=widget.HiddenWidget())
+    kode = colander.SchemaNode(
+        colander.String(),)
+
     path = colander.SchemaNode(
         colander.String(), title='Path')
     nama = colander.SchemaNode(

opensipkd/models/base.py

@@ -220,4 +220,4 @@ class NamaModel(KodeModel):
 
     @classmethod
     def get_list(cls):
-        return cls.query_list().all()
+        return cls.query_list().all()
\ No newline at end of file

opensipkd/models/users.py

@@ -178,8 +178,9 @@ class User(UserMixin, BaseModel, DefaultModel, Base):
 
 
 class ExternalIdentity(ExternalIdentityMixin, CommonModel, Base):
-    user = relationship(User, backref=backref("external"),
-                        overlaps="external_identities,owner")
+    user = relationship(User, backref=backref("external"))
+    # ,
+    # overlaps = "external_identities,owner"
 
     @classmethod
     def query(cls):
@@ -190,7 +191,6 @@ class ExternalIdentity(ExternalIdentityMixin, CommonModel, Base):
         return cls.query().filter_by(local_user_id=user.id)
 
     @classmethod
-    @classmethod
     def external(cls, user):
         return cls.query_user(user).count() > 0
 

opensipkd/models/views/__init__.py

-from sqlalchemy import func
-from sqlalchemy.sql import sqltypes
-
-from .. import Base
-from opensipkd.tools import round_up
-from opensipkd.tools.api import JsonRpcDataNotFoundError
-from opensipkd.tools.pbb import FixNop, FixKelurahan, FixBlok
-
-
-class BaseApiTableFilter(object):
-    """Function untuk standarisasi filtering table"""
-
-    def __init__(self, orm, data):
-        self.orm = orm
-        self.data = data
-
-    def filter_nop(self, qry, val):
-        kode = FixNop(val)
-        return qry.filter_by(kd_propinsi=kode["kd_propinsi"],
-                             kd_dati2=kode["kd_dati2"],
-                             kd_kecamatan=kode["kd_kecamatan"],
-                             kd_kelurahan=kode["kd_kelurahan"],
-                             kd_blok=kode["kd_blok"],
-                             no_urut=kode["no_urut"],
-                             kd_jns_op=kode["kd_jns_op"])
-
-    def filter_desa(self, qry, val):
-        kode = FixKelurahan(val)
-        return qry.filter_by(kd_propinsi=kode["kd_propinsi"],
-                             kd_dati2=kode["kd_dati2"],
-                             kd_kecamatan=kode["kd_kecamatan"],
-                             kd_kelurahan=kode["kd_kelurahan"]
-                             )
-
-    def filter_blok(self, qry, val):
-        kode = FixBlok(val)
-        return qry.filter_by(kd_propinsi=kode["kd_propinsi"],
-                             kd_dati2=kode["kd_dati2"],
-                             kd_kecamatan=kode["kd_kecamatan"],
-                             kd_kelurahan=kode["kd_kelurahan"],
-                             kd_blok=kode["kd_blok"])
-
-    def get_data(self):
-        data = self.data
-        orm = self.orm
-        qry = self.orm.query()
-        if "where" in data:
-            for w in data["where"]:
-                if hasattr(orm, w['key']):
-                    key = w["key"]
-                    val = w["val"]
-                    if key == "nop":
-                        qry = self.filter_nop(qry, val)
-                    elif key == "desa":
-                        qry = self.filter_desa(qry, val)
-                    elif key == "blok":
-                        qry = self.filter_blok(qry, val)
-                    else:
-                        key = getattr(orm, key)
-                        if isinstance(key.type, sqltypes.String):
-                            qry = qry.filter(func.trim(key) == val)
-                        else:
-                            qry = qry.filter(key == val)
-
-        if "order" in data:
-            for o in data["order"]:
-                key = getattr(orm, o)
-                qry = qry.order_by(key)
-
-        page_size = "page_size" in data and int(data["page_size"]) or 20
-        page = "page" in data and int(data["page"]) or 1
-        total_page = round_up(qry.count() / page_size)
-        if total_page and page > total_page:
-            page = int(total_page)
-
-        offset = (page - 1) * page_size
-        qry = qry.offset(offset).limit(page_size)
-        return qry, page, page_size, total_page
-
-
-    def get_filter(self):
-        qry, page, page_size, total_page = self.get_data()
-        row = qry.first()
-        if not row:
-            raise JsonRpcDataNotFoundError
-        result = []
-        for row in qry.all():
-            result.append(row.to_dict())
-
-        return dict(record=result,
-                    total_page=total_page,
-                    page=page,
-                    page_size=page_size)