SimpleDomControl 0.58.5__tar.gz → 0.158.0__tar.gz

{simpledomcontrol-0.58.5 → simpledomcontrol-0.158.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: SimpleDomControl
-Version: 0.58.5
+Version: 0.158.0
 Summary: Simple DOM control -> a django MVC framework
 License: Apache-2.0
 Keywords: django,MVC
@@ -12,6 +12,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: attrs (>=25.4.0,<26.0.0)
@@ -24,6 +25,7 @@ Requires-Dist: inquirerpy (>=0.3.4,<0.4.0)
 Requires-Dist: poetry-core (>=2.3.1,<3.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)
 Requires-Dist: pyjwt (>=2.11.0,<3.0.0)
+Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
 Requires-Dist: regex (>=2026.1.15,<2027.0.0)
 Project-URL: Homepage, https://github.com/StarmanMartin/sdc
 Description-Content-Type: text/markdown

{simpledomcontrol-0.58.5 → simpledomcontrol-0.158.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "SimpleDomControl"
-version = "0.58.5"
+version = "0.158.0"
 authors = [ "Martin Starman <private@martin-starman.com>", ]
 description = "Simple DOM control -> a django MVC framework"
 readme = "README.md"
@@ -30,6 +30,7 @@ click = ">=8.1.0"
 pyjwt = "^2.11.0"
 inquirerpy = "^0.3.4"
 poetry-core = "^2.3.1"
+pyyaml = "^6.0.3"
 
 [tool.pytest.ini_options]
 pythonpath = [

{simpledomcontrol-0.58.5 → simpledomcontrol-0.158.0}/sdc_core/consumers.py

@@ -3,11 +3,13 @@ import os
 import types
 import traceback
 
+from django.apps import apps
 from django.conf import settings
 from django.core.exceptions import PermissionDenied
 from django.core.files.uploadhandler import TemporaryFileUploadHandler
 
 from django.utils.datastructures import MultiValueDict
+from django.utils.html import escape
 from django.utils.translation import gettext as _f
 from django.contrib.auth import get_user_model
 from channels.generic.websocket import WebsocketConsumer, AsyncWebsocketConsumer
@@ -16,10 +18,11 @@ from asgiref.sync import async_to_sync
 import importlib
 import json
 
-from sdc_core.sdc_extentions.models import SdcModel, SDCSerializer, all_models
+from sdc_core.sdc_extentions.models import SdcModel, SDCSerializer, all_models, sanitize_filter_query
 from sdc_core.sdc_extentions.response import sdc_link_factory, sdc_link_obj_factory
 from sdc_core.sdc_extentions.import_manager import import_function
-from sdc_core.sdc_extentions.views import SdcAccessMixin
+from sdc_core.sdc_extentions.search import handle_search_form
+from sdc_core.sdc_extentions.views import SdcAccessMixin, is_valid_server_call
 
 import logging
 
@@ -126,13 +129,19 @@ class SDCConsumer(AsyncWebsocketConsumer):
         try:
             json_data = json.loads(text_data)
             if json_data['event'] == 'sdc_call':
+                app_name = json_data['app']
+                func_name = json_data['function']
+                # Reject client-controlled imports of non-installed apps and any
+                # private/framework method name before resolving the controller.
+                if not apps.is_installed(app_name) or not is_valid_server_call(func_name):
+                    raise PermissionDenied()
                 controller_name = self.to_camel_case(json_data['controller'])
-                controller = import_function("%s.sdc_views.%s" % (json_data['app'], controller_name))
+                controller = import_function("%s.sdc_views.%s" % (app_name, controller_name))
                 c_instance = controller()
                 if isinstance(c_instance, SdcAccessMixin):
                     if not await c_instance.async_check_requirements(self.scope['user']):
                         raise PermissionDenied()
-                method = getattr(controller(), json_data['function'])
+                method = getattr(controller(), func_name)
 
                 logger.info(f"SDC call Socket received: {json_data['app']}.{controller_name}.{json_data['function']}")
                 if asyncio.iscoroutinefunction(method):
@@ -281,8 +290,8 @@ class SDCModelConsumer(WebsocketConsumer):
                 traceback.print_tb(e.__traceback__)
             else:
                 logger.error(e_text)
-                e_text_details = str(e)
-                e_text = _f('Something went wrong! {e}').format(e=e_text_details)
+                # Do not leak internal exception details to the client in production.
+                e_text = _f('Something went wrong!')
 
             self.state_error({
                 'type': msg_type,
@@ -313,7 +322,7 @@ class SDCModelConsumer(WebsocketConsumer):
         data_load_result = self.model.data_load(self.scope['user'], queryset, self.queryset)
         if data_load_result is not None:
             return data_load_result
-        res = queryset.filter(**self.queryset)
+        res = queryset.filter(**sanitize_filter_query(self.model, self.queryset))
         self.ids = list(res.values_list('id', flat=True))
 
         return res
@@ -343,7 +352,7 @@ class SDCModelConsumer(WebsocketConsumer):
         instance.scope = self.scope
         form_name = json_data['args']['form_name']
         if not hasattr(self.model.SdcMeta, form_name):
-            raise NotImplemented()
+            raise NotImplementedError()
 
         return self._load_form(json_data, getattr(self.model.SdcMeta, form_name), instance)
 
@@ -351,7 +360,7 @@ class SDCModelConsumer(WebsocketConsumer):
         if callable(form_attr):
             form_attr = form_attr({})
         if form_attr is None:
-            raise NotImplemented()
+            raise NotImplementedError()
         elif isinstance(form_attr, str):
             edit_form_path = form_attr.split('.')
             form = getattr(importlib.import_module('.'.join(edit_form_path[0:-1])), edit_form_path[-1])
@@ -373,7 +382,7 @@ class SDCModelConsumer(WebsocketConsumer):
         return self._submit_element(json_data, self.model.SdcMeta.create_form, instance)
 
     def _save_element(self, json_data):
-        instance = self._load_model().get(pk=json_data['args']['data']['pk'])
+        instance = self._load_model().get(pk=json_data['args']['pk'])
         instance.scope = self.scope
         key = str(json_data['args'].get('form_name', 'edit_form'))
         if not hasattr(self.model.SdcMeta, key):
@@ -392,7 +401,11 @@ class SDCModelConsumer(WebsocketConsumer):
                              field_name=file_data['field_name'],
                              content_type=file_data['content_type'],
                              content_length=file_data['content_length'], )
-        handler.receive_data_chunk(bytes([ord(x) for x in file_data['chunk']]), int(file_data['idx']))
+        if isinstance(file_data['chunk'], list):
+            data = bytes(file_data['chunk'])
+        else:
+            data = file_data['chunk'].encode()
+        handler.receive_data_chunk(data, int(file_data['idx']))
         number_of_chunks = number_of_chunks - 1
         self._upload_handler[json_data['event_id']] = (handler, number_of_chunks)
         if number_of_chunks == 0:
@@ -407,7 +420,7 @@ class SDCModelConsumer(WebsocketConsumer):
         data = json_data['args']['data']
         files = json_data['args'].get('files')
         if form_attr is None:
-            raise NotImplemented()
+            raise NotImplementedError()
         elif isinstance(form_attr, str):
             edit_form_path = form_attr.split('.')
             form = getattr(importlib.import_module('.'.join(edit_form_path[0:-1])), edit_form_path[-1])
@@ -430,7 +443,7 @@ class SDCModelConsumer(WebsocketConsumer):
         else:
             msg = {'header': 'Upss!',
                    'msg': "<ul>%s</ul>" % "\n".join(
-                       ["<li>%s: %s</li>" % (k, v[0]) for k, v in form_instance.errors.items()])
+                       ["<li>%s: %s</li>" % (escape(k), escape(v[0])) for k, v in form_instance.errors.items()])
                    }
 
         self.send(text_data=json.dumps(msg | {
@@ -445,12 +458,13 @@ class SDCModelConsumer(WebsocketConsumer):
 
     def _load_list_view(self, json_data):
         if self.model.SdcMeta.html_list_template is None:
-            raise NotImplemented()
+            raise NotImplementedError()
+        filter = self.queryset.pop('__search_values', {})
         loaded_data = self._load_model()
         self.send(text_data=json.dumps({
             'type': json_data['event_type'],
             'event_id': json_data['event_id'],
-            'html': self._render(self.model.SdcMeta.html_list_template, {'instances': loaded_data}, json_data),
+            'html': self._render(self.model.SdcMeta.html_list_template, {'instances': loaded_data, 'filter': filter}, json_data),
             'args': self._prepare_loaded_data(loaded_data),
             'is_error': False
         }))
@@ -459,7 +473,7 @@ class SDCModelConsumer(WebsocketConsumer):
         loaded_data = self._load_model()
         view_name = json_data['args']['view_name']
         if not hasattr(self.model.SdcMeta, view_name):
-            raise NotImplemented()
+            raise NotImplementedError()
         self.send(text_data=json.dumps({
             'type': json_data['event_type'],
             'event_id': json_data['event_id'],
@@ -470,7 +484,7 @@ class SDCModelConsumer(WebsocketConsumer):
 
     def _load_detail_view(self, json_data):
         if self.model.SdcMeta.html_detail_template is None:
-            raise NotImplemented()
+            raise NotImplementedError()
         instance = self._load_model().get(pk=json_data['args']['pk'])
         instance.scope = self.scope
         self.send(text_data=json.dumps({

simpledomcontrol-0.158.0/sdc_core/jwt_utils.py

@@ -0,0 +1,126 @@
+import jwt
+import datetime
+
+from django.conf import settings
+
+from functools import wraps
+
+from django.http import JsonResponse
+from django.contrib.auth import get_user_model
+
+User = get_user_model()
+
+
+def generate_jwt(user):
+    payload = {
+        "user_id": user.id,
+        "username": user.username,
+        "iat": user.last_login,
+        "exp": datetime.datetime.now(datetime.UTC) + datetime.timedelta(
+            seconds=settings.JWT['exp_delta_seconds']
+        ),
+        "type": "auth"
+    }
+
+    token = jwt.encode(
+        payload,
+        settings.JWT['secret'],
+        algorithm=settings.JWT['algorithm'],
+    )
+
+    payload = {
+        "user_id": user.id,
+        "username": user.username,
+        "iat": user.last_login,
+        "exp": datetime.datetime.now(datetime.UTC) + datetime.timedelta(
+            seconds=settings.JWT['exp_delta_seconds'] * 20
+        ),
+        "iat": datetime.datetime.now(datetime.UTC),
+        "type": "refresh"
+    }
+
+    recover_token = jwt.encode(
+        payload,
+        settings.JWT['secret'],
+        algorithm=settings.JWT['algorithm'],
+    )
+
+    return token, recover_token
+
+
+def verify_jwt(token, type):
+
+        payload = jwt.decode(
+            token,
+            settings.JWT['secret'],
+            algorithms=[settings.JWT['algorithm']],
+        )
+        if payload is None or payload.get('type') != type:
+            raise jwt.InvalidTokenError
+
+        user = User.objects.get(id=payload["user_id"])
+
+        if type == 'refresh' and abs(payload['iat'] - user.last_login.timestamp()) > 10:
+            raise jwt.InvalidTokenError
+
+        return payload, user
+
+
+def verify_refresh_jwt(token):
+    return verify_jwt(token, 'refresh')
+
+
+def verify_auth_jwt(token):
+    return verify_jwt(token, 'auth')
+
+def get_auth_token_from_request(request):
+    auth_header = request.headers.get("Authorization")
+
+    if not auth_header:
+        return None, JsonResponse(
+            {"error": "Missing Authorization header"},
+            status=401,
+        )
+
+    try:
+        prefix, token = auth_header.split(" ")
+
+        if prefix.lower() != "bearer":
+            raise ValueError()
+
+    except ValueError:
+        return None, JsonResponse(
+            {"error": "Invalid Authorization header"},
+            status=401,
+        )
+    return token, None
+
+def jwt_required(view_func):
+    @wraps(view_func)
+    def wrapped(request, *args, **kwargs):
+        token, err = get_auth_token_from_request(request)
+        if err is not None:
+            return err
+        try:
+            payload, user = verify_auth_jwt(token)
+        except jwt.ExpiredSignatureError:
+            return JsonResponse(
+                {"error": "Expired token"},
+                status=401,
+            )
+        except jwt.InvalidTokenError:
+            return JsonResponse(
+                {"error": "Invalid token"},
+                status=401,
+            )
+        except User.DoesNotExist:
+            return JsonResponse(
+                {"error": "User not found"},
+                status=401,
+            )
+
+        request.user = user
+
+        return view_func(request, *args, **kwargs)
+
+    return wrapped

{simpledomcontrol-0.58.5 → simpledomcontrol-0.158.0}/sdc_core/management/commands/init_add/add_controller_manager.py

@@ -164,7 +164,7 @@ class AddControllerManager:
                          os.path.join(str(main_static), self.controller_name_sc + ".scss"),
                          self.reps)
 
-        copy_and_prepare(os.path.join(options.SCRIPT_ROOT, "template_files", "controller", "templade_view.html"),
+        copy_and_prepare(os.path.join(options.SCRIPT_ROOT, "template_files", "controller", "template_view.html"),
                          os.path.join(main_templates, "sdc",
                                       self.controller_name_sc + ".html"),
                          self.reps)
@@ -190,7 +190,7 @@ class AddControllerManager:
 
     def add_js_test(self):
         text = prepare_as_string(
-            os.path.join(options.SCRIPT_ROOT, "template_files", "controller", "template_test.js.text"), self.reps)
+            os.path.join(options.SCRIPT_ROOT, "template_files", "controller", "template_test.js.txt"), self.reps)
         fp = os.path.join(options.PROJECT_ROOT, self.app_name, 'Assets/tests', f"{self.app_name}.test.js")
         fout = open(fp, "a", encoding='utf-8')
         fout.write(text)

{simpledomcontrol-0.58.5 → simpledomcontrol-0.158.0}/sdc_core/management/commands/init_add/add_model_manager.py

@@ -60,16 +60,18 @@ class AddModelManager():
             '{0}{0}DEFAULT_CHOICES = CHOICES[0][0]',
             '{0}{0}SEARCH_FIELDS = ("id",)',
             '',
-            '{0}class _SdcMeta:',
+            '{0}class SdcMeta:',
             '{0}{0}"""Meta data information needed to manage all SDC operations."""',
             '{0}{0}edit_form = "{1}.forms.{2}Form"',
+            '{0}{0}fields = "__all__"',
+            '{0}{0}exclude = None',
             '{0}{0}create_form = "{1}.forms.{2}Form"',
             '{0}{0}html_list_template = "{1}/models/{2}/{2}_list.html"',
             '{0}{0}html_detail_template = "{1}/models/{2}/{2}_details.html"',
             '',
             '{0}@classmethod\n{0}def render(cls, template_name, context=None, request=None, using=None):\n{0}{0}if template_name == cls.SdcMeta.html_list_template:\n{0}{0}{0}sf = cls.SearchForm(data=context.get("filter", {{}}))\n{0}{0}{0}context = context | handle_search_form(context["instances"], sf,  range=10)\n{0}{0}return render_to_string(template_name=template_name, context=context, request=request, using=using)',
             '',
-            '{0}@classmethod\n{0}def is_authorised(cls, user, action, obj):\n{0}{0}return True',
+            '{0}@classmethod\n{0}def is_authorised(cls, user, action, obj):\n{0}{0}return False',
             '',
             '{0}@classmethod\n{0}def get_queryset(cls, user, action, obj):\n{0}{0}return cls.objects.all()',
         ]).format(options.SEP, self.app_name, self.model_name)

{simpledomcontrol-0.58.5 → simpledomcontrol-0.158.0}/sdc_core/management/commands/init_add/sdc_core_manager.py

@@ -5,6 +5,7 @@ import shutil
 
 from sdc_core.management.commands.init_add import options
 
+
 def add_sdc_to_main_urls(main_urls_path):
     fin = open(main_urls_path, "rt", encoding='utf-8')
     text = ""
@@ -12,13 +13,20 @@ def add_sdc_to_main_urls(main_urls_path):
 
     for line in fin:
         if 'from django.urls import path' in line:
-            line = re.sub(r'path', 'path, re_path, include\nfrom django.shortcuts import render\nfrom django.conf import settings\nfrom django.views.i18n import JavaScriptCatalog', line)
+            line = re.sub(r'path',
+                          'path, re_path, include\nfrom django.shortcuts import render\nfrom django.conf import settings\nfrom django.views.i18n import JavaScriptCatalog\nfrom sdc_core.rest_api import AdcApi, get_api_token',
+                          line)
 
         if "urlpatterns = [" in line:
             new_apps = "%sre_path('sdc_view/sdc_tools/', include('sdc_tools.sdc_urls')),\n" % options.SEP
             new_apps += "%sre_path('sdc_view/sdc_user/', include('sdc_user.sdc_urls')),\n" % options.SEP
+
+            new_apps += f"{options.SEP}path('sdc_api/<str:model>/<int:id>/', AdcApi.as_view()),\n"
+            new_apps += f"{options.SEP}path('sdc_api/<str:model>/', AdcApi.as_view()),\n"
+            new_apps += f"{options.SEP}path('sdc_api/login/', get_api_token),\n"
+
             line = re.sub(r'urlpatterns = \[',
-                          "urlpatterns = [\n%s%s# scd view below\n" % (new_apps,options.SEP), line)
+                          "urlpatterns = [\n%s%s# scd view below\n" % (new_apps, options.SEP), line)
             is_done = True
         text += line
 

{simpledomcontrol-0.58.5 → simpledomcontrol-0.158.0}/sdc_core/management/commands/sdc_init.py

@@ -4,14 +4,12 @@ import json
 from pathlib import Path
 
 from django.core.management.base import BaseCommand, CommandError
-from django.core import serializers
 from django.utils import timezone
 from sdc_core.management.commands.init_add import options, settings_manager
 from sdc_core.management.commands.init_add.add_controller_manager import AddControllerManager
 from sdc_core.management.commands.init_add.sdc_core_manager import add_sdc_to_main_urls
 from sdc_core.management.commands.init_add.utils import copy, copy_and_prepare, prepare_as_string
 from sdc_core.management.commands.sdc_update_links import make_app_links
-from sdc_core.management.commands.sdc_db_tools import update_to_sdc_user
 
 
 class Command(BaseCommand):

simpledomcontrol-0.158.0/sdc_core/management/commands/sdc_make_model_js.py

@@ -0,0 +1,118 @@
+import json
+import shutil
+from os import makedirs
+from pathlib import Path
+
+from django.core.management import BaseCommand
+
+from sdc_core.management.commands.utils import get_model_schema
+from sdc_core.sdc_extentions.models import all_models
+
+
+def generate_field_config(field):
+    config = {
+        "type": field["type"],
+        "required": not field["null"] and not field["blank"],
+        "max_length": field.get("max_length"),
+        "is_relation": field["is_relation"],
+        "many_to_many": field["many_to_many"],
+        "one_to_many": field["one_to_many"],
+        "many_to_one": field["many_to_one"],
+        "one_to_one": field["one_to_one"],
+        "related_model": field["related_model"],
+        "remote_field": field["remote_field"],
+    }
+
+    if field["type"] == "FileField":
+        config.update({
+            # optional — you can hardcode or extract from validators
+            "max_size": 5 * 1024 * 1024 * 1024,  # 5 MB
+            "allowed_types": None,        # or list of mime types
+        })
+
+    return config
+
+def generate_schema_js(fields):
+    schema = {
+        f["name"]: generate_field_config(f)
+        for f in fields
+    }
+    return '  static fields = ' + '\n    '.join(json.dumps(schema, indent=2).split('\n'))
+
+def _generate_js_class(schema):
+    class_name = schema["model"]
+
+    lines = ["import {SdcModel, SdcQuerySet} from 'sdc_client';", "", f"export default class {class_name} extends SdcModel {{", ""]
+    constructor_line = ["  constructor(data = {}) {", f'    super("{class_name}");', f'    this._toManyFields = [];']
+    setter_line = ["  setValues(data = {}) {", f'    data.id ??= data.pk ?? null;']
+    getter = []
+    setter = []
+    setter_functions = []
+
+    field_settings = ["", generate_schema_js(schema["fields"]),""]
+
+
+    for field in schema["fields"]:
+        name = field["name"]
+        setter.append(f"  set {name}(value){{")
+        setter.append(f"    this.set{name}(value);")
+        setter_functions.append(f"  set{name}(value){{")
+        setter_functions.append(f"    this.validate(value, {class_name}.fields.{name});")
+        getter.append(f"  get {name}(){{")
+        if name == 'id':
+            setter_functions.append("    this._toManyFields.forEach(([x, fn]) => x.setFilter({[fn]: value}));")
+        setter_line.append("    try {")
+
+        if field["is_relation"] and field["related_model"]:
+            constructor_line.append(f"    this._{name} = new SdcQuerySet('{field['related_model']}');")
+            if field["many_to_many"] or field["one_to_many"]:
+                constructor_line.append(f"    this._toManyFields.push([this._{name}, '{field['remote_field']}']);")
+                setter_line.append(f"    this.{name}.setFilter({{ {field['remote_field']}:  data.id }});")
+                setter_line.append(f"    this.{name} = data.{name} || [];")
+                setter_functions.append(f"    this._{name}.setIds(this.parseValue(value, {class_name}.fields.{name}));")
+                getter.append(f"    return this._{name};")
+            else:
+                setter_line.append(f"      if (data.{name}) {{ this.{name} = data.{name}; }}")
+                setter_functions.append(f"    this._{name}.setIds(this.parseValue(value, {class_name}.fields.{name}));")
+                getter.append(f"    return this._{name}.length > 0 ? this._{name}[0] : this._{name}.new();")
+        else:
+            constructor_line.append(f"    this._{name} = null;")
+            setter_line.append(f"      this.{name} = data.{name} ?? null;")
+            getter.append(f"    return this._{name};")
+            setter_functions.append(f"    this._{name} = this.parseValue(value, {class_name}.fields.{name});")
+        setter_line.append("    } catch {} ")
+        setter.append(f"    this._updateForm('{name}');")
+        setter.append("  }\n")
+        setter_functions.append("  }\n")
+        getter.append("  }\n")
+    constructor_line.append("    this.setValues(data);")
+    constructor_line.append("  }")
+    setter_line.append("  }")
+
+    lines += field_settings + constructor_line + [""] + setter_line + [""] + setter + [""] + setter_functions + [""] + getter
+    lines.append("}")
+    return "\n".join(lines)
+
+def _prepare_js_models():
+    file_path = Path('Assets/src/models')
+    if file_path.exists():
+        shutil.rmtree(file_path)
+    makedirs(file_path, exist_ok=True)
+    src_js = [f"import {{ registerModel }} from 'sdc_client';", ""]
+    for name, model in all_models().items():
+        src_js.insert(0, f"import {name} from './{name}.js';")
+        src_js.append(f'registerModel("{name}", {name});')
+        ms = get_model_schema(model)
+        with open(file_path / f'{name}.js', 'w+') as f:
+            f.write(_generate_js_class(ms))
+    with open(file_path / 'src.js', 'w+') as f:
+        f.write('\n'.join(src_js))
+
+class Command(BaseCommand):
+    help = 'This function links all templates into the controller directory'
+
+    def add_arguments(self, parser):
+        pass
+
+    def handle(self, *args, **ops):
+        _prepare_js_models()