simpledomcontrol 0.55.4__tar.gz → 0.56.1__tar.gz

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: SimpleDomControl
-Version: 0.55.4
+Version: 0.56.1
 Summary: Simple DOM control -> a django MVC framework
 Home-page: https://github.com/StarmanMartin/sdc
 License: Apache-2.0
@@ -17,14 +17,18 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: attrs (>=23.2.0,<24.0.0)
+Requires-Dist: attrs (>=24.2.0,<25.0.0)
 Requires-Dist: channels (>=4.1.0,<5.0.0)
 Requires-Dist: channels-redis (>=4.2.0,<5.0.0)
+Requires-Dist: click (>=8.1.7,<9.0.0)
 Requires-Dist: daphne (>=4.1.2,<5.0.0)
-Requires-Dist: django (>=5.0.6,<6.0.0)
+Requires-Dist: django (>=5.1.2,<6.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)
-Requires-Dist: regex (>=2024.5.15,<2025.0.0)
+Requires-Dist: regex (>=2024.7.24,<2025.0.0)
 Description-Content-Type: text/markdown
 
-simpleDomControl
+# Simple Dom Control (SDC)
 
+SDC is a framework that combines elements of both the MVC (Model-View-Controller) and MVT (Model-View-Template) patterns. Its main goal is to provide a tool for simple and efficient web development. The name ‘SDC’ is an abbreviation for ‘Simple DOM Control,’ indicating its focus on controlling and manipulating the Document Object Model (DOM), which is crucial for web development, particularly in dynamic web pages.
+
+For detailed docs go to [rtd](https://simpledomcontrol.readthedocs.io/en/latest/)

simpledomcontrol-0.56.1/README.md

@@ -0,0 +1,5 @@
+# Simple Dom Control (SDC)
+
+SDC is a framework that combines elements of both the MVC (Model-View-Controller) and MVT (Model-View-Template) patterns. Its main goal is to provide a tool for simple and efficient web development. The name ‘SDC’ is an abbreviation for ‘Simple DOM Control,’ indicating its focus on controlling and manipulating the Document Object Model (DOM), which is crucial for web development, particularly in dynamic web pages.
+
+For detailed docs go to [rtd](https://simpledomcontrol.readthedocs.io/en/latest/)

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "SimpleDomControl"
-version = "0.55.4"
+version = "0.56.1"
 authors = [ "Martin Starman <private@martin-starman.com>", ]
 description = "Simple DOM control -> a django MVC framework"
 readme = "README.md"
@@ -22,10 +22,11 @@ python = "^3.10"
 daphne = "^4.1.2"
 channels = "^4.1.0"
 channels-redis = "^4.2.0"
-django = "^5.0.6"
+django = "^5.1.2"
 psycopg2-binary = "^2.9.9"
-attrs = "^23.2.0"
-regex = "^2024.5.15"
+attrs = "^24.2.0"
+regex = "^2024.7.24"
+click = "^8.1.7"
 
 [tool.pytest.ini_options]
 pythonpath = [
@@ -38,6 +39,9 @@ testpaths = [
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.2.2"
 pillow = "^10.1.0"
+sphinx-toolbox = "^3.6.0"
+sphinx-rtd-theme = "^2.0.0"
+sphinx-markdown-builder = "^0.6.6"
 
 [build-system]
 requires = ["poetry-core"]

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/sdc_core/consumers.py

@@ -14,7 +14,7 @@ from asgiref.sync import async_to_sync
 import importlib
 import json
 
-from sdc_core.sdc_extentions.models import SdcModel, ConsumerSerializer, all_models
+from sdc_core.sdc_extentions.models import SdcModel, SDCSerializer, all_models
 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
@@ -248,7 +248,7 @@ class SDCModelConsumer(WebsocketConsumer):
             elif event_type == 'model_delete':
                 self._delete_element(json_data)
             elif event_type == 'model_load':
-                model_data = ConsumerSerializer().serialize(self._load_model())
+                model_data = SDCSerializer().serialize(self._load_model())
                 self.send(text_data=json.dumps({
                     'type': json_data['event_type'],
                     'event_id': json_data['event_id'],
@@ -317,12 +317,12 @@ class SDCModelConsumer(WebsocketConsumer):
     def _load_create_form(self, json_data):
         instance: SdcModel = self.model()
         instance.scope = self.scope
-        return self._load_form(json_data, self.model.create_form, instance)
+        return self._load_form(json_data, self.model.SdcMeta.create_form, instance)
 
     def _load_edit_form(self, json_data):
         instance = self._load_model().get(pk=json_data['args']['pk'])
         instance.scope = self.scope
-        return self._load_form(json_data, self.model.edit_form, instance)
+        return self._load_form(json_data, self.model.SdcMeta.edit_form, instance)
 
     def _load_named_form(self, json_data):
         instance = self._load_model().get(pk=json_data['args']['pk'])
@@ -347,7 +347,7 @@ class SDCModelConsumer(WebsocketConsumer):
         self.send(text_data=json.dumps({
             'type': json_data['event_type'],
             'event_id': json_data['event_id'],
-            'html': self._render(self.model.html_form_template, {'instance': instance, 'form': form(instance=instance)},
+            'html': self._render(self.model.SdcMeta.html_form_template, {'instance': instance, 'form': form(instance=instance)},
                                  json_data),
             'is_error': False
         }))
@@ -355,12 +355,12 @@ class SDCModelConsumer(WebsocketConsumer):
     def _create_element(self, json_data):
         instance: SdcModel = self.model()
         instance.scope = self.scope
-        return self._submit_element(json_data, self.model.create_form, instance)
+        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.scope = self.scope
-        return self._submit_element(json_data, self.model.edit_form, instance)
+        return self._submit_element(json_data, self.model.SdcMeta.edit_form, instance)
 
     def _upload_file(self, json_data):
         file_data = json_data['args']
@@ -406,7 +406,7 @@ class SDCModelConsumer(WebsocketConsumer):
 
         if is_valid:
             form_instance.save()
-            new_instance = ConsumerSerializer().serialize(self._load_model().filter(pk=form_instance.instance.pk))
+            new_instance = SDCSerializer().serialize(self._load_model().filter(pk=form_instance.instance.pk))
             msg = self.msg_manager.get_msg(form_instance.instance, json_data['event_type'])
         else:
             msg = {'header': 'Upss!',
@@ -418,20 +418,20 @@ class SDCModelConsumer(WebsocketConsumer):
             'type': json_data['event_type'],
             'event_id': json_data['event_id'],
             'data': {'instance': new_instance},
-            'html': self._render(self.model.html_form_template,
+            'html': self._render(self.model.SdcMeta.html_form_template,
                                  {'instance': form_instance.instance, 'form': form_instance},
                                  json_data),
             'is_error': not is_valid
         }))
 
     def _load_list_view(self, json_data):
-        if self.model.html_list_template is None:
+        if self.model.SdcMeta.html_list_template is None:
             raise NotImplemented()
 
         self.send(text_data=json.dumps({
             'type': json_data['event_type'],
             'event_id': json_data['event_id'],
-            'html': self._render(self.model.html_list_template, {'instances': self._load_model()}, json_data),
+            'html': self._render(self.model.SdcMeta.html_list_template, {'instances': self._load_model()}, json_data),
             'is_error': False
         }))
 

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/sdc_core/management/commands/init_add/add_model_manager.py

@@ -49,22 +49,25 @@ class AddModelManager():
         self._check_if_sdcmodel_imported(model_path)
         f = open(model_path, 'a')
 
-        search_form_def = "\n".join([
-            'class {2}SearchForm(AbstractSearchForm):',
-            '{0}CHOICES = (("id", "Id"),)',
-            '{0}PLACEHOLDER = ""',
-            '{0}DEFAULT_CHOICES = CHOICES[0][0]',
-            '{0}SEARCH_FIELDS = ("id",)',
-        ]).format(options.SEP, self.app_name, self.model_name)
+        search_form_def = "\n".join([]).format(options.SEP, self.app_name, self.model_name)
 
         class_def = "\n".join([
             'class {2}(models.Model, SdcModel):',
-            '{0}edit_form = "{1}.forms.{2}Form"',
-            '{0}create_form = "{1}.forms.{2}Form"',
-            '{0}html_list_template = "{1}/models/{2}/{2}_list.html"',
-            '{0}html_detail_template = "{1}/models/{2}/{2}_details.html"',
+            '{0}class SearchForm(AbstractSearchForm):',
+            '{0}{0}"""A default search form used in the list view. You can delete it if you dont need it"""',
+            '{0}{0}CHOICES = (("id", "Id"),)',
+            '{0}{0}PLACEHOLDER = ""',
+            '{0}{0}DEFAULT_CHOICES = CHOICES[0][0]',
+            '{0}{0}SEARCH_FIELDS = ("id",)',
+            '',
+            '{0}class _SdcMeta:',
+            '{0}{0}"""Meta data information needed to manage all SDC operations."""',
+            '{0}{0}edit_form = "{1}.forms.{2}Form"',
+            '{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.html_list_template:\n{0}{0}{0}sf = {2}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 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',
             '',

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/sdc_core/management/commands/init_add/settings_manager.py

@@ -77,8 +77,8 @@ class SettingsManager:
 
         data = fin.read()
         fin.close()
-        data = re.sub(r'(from[^\n]*)', '\g<1>\nimport os\nfrom urllib.parse import urlparse, urlunparse', data)
-        data = re.sub(r'(ALLOWED_HOSTS[^\n]*)', '# \g<1>', data)
+        data = re.sub(r'(from[^\n]*)', r'\g<1>\nimport os\nfrom urllib.parse import urlparse, urlunparse', data)
+        data = re.sub(r'(ALLOWED_HOSTS[^\n]*)', r'# \g<1>', data)
         data = re.sub(r'INSTALLED_APPS\s*=\s*\[[^\]]+\]', new_val, data)
 
         new_val = f"DATABASES_AVAILABLE = {{\n{sep}'jest': {{'ENGINE': 'django.db.backends.sqlite3', 'NAME': BASE_DIR / 'test_db.sqlite3', }},"

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/sdc_core/management/commands/sdc_get_model_infos.py

@@ -44,26 +44,26 @@ class Command(BaseCommand):
             'model_file': os.path.join(options.PROJECT_ROOT, model.__module__.replace('.', os.path.sep) + '.py'),
             'model_file_line': self._get_class_line_number(
                 os.path.join(options.PROJECT_ROOT, model.__module__.replace('.', os.path.sep) + '.py'), model.__name__),
-            'create_form': self._separate_file_class(model.create_form),
-            'edit_form': self._separate_file_class(model.edit_form)
+            'create_form': self._separate_file_class(model.SdcMeta.create_form),
+            'edit_form': self._separate_file_class(model.SdcMeta.edit_form)
 
         }
 
-        if model.html_detail_template:
+        if model.SdcMeta.html_detail_template:
             try:
-                mi['html_detail_template'] = get_template(model.html_detail_template).origin.name
+                mi['html_detail_template'] = get_template(model.SdcMeta.html_detail_template).origin.name
             except:
                 pass
 
-        if model.html_list_template:
+        if model.SdcMeta.html_list_template:
             try:
-                mi['html_list_template'] = get_template(model.html_list_template).origin.name
+                mi['html_list_template'] = get_template(model.SdcMeta.html_list_template).origin.name
             except:
                 pass
 
-        if model.html_form_template:
+        if model.SdcMeta.html_form_template:
             try:
-                mi['html_form_template'] = get_template(model.html_form_template).origin.name
+                mi['html_form_template'] = get_template(model.SdcMeta.html_form_template).origin.name
             except:
                 pass
 

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/sdc_core/management/commands/sdc_new_model.py

@@ -46,7 +46,7 @@ class Command(BaseCommand):
             app_name = all_apps[idx]
         model_name = ops.get('model_name')
         if model_name is None:
-            text = "Enter the name of the new Model class name (use camel-case):"
+            text = "Enter the name of the new Model class name (use CamelCase):"
             model_name = str(input(text))
 
         if model_name in [model.__name__ for model in apps.get_app_config(app_name).get_models()]:

simpledomcontrol-0.56.1/sdc_core/sdc_extentions/forms.py

@@ -0,0 +1,48 @@
+"""
+The SDC package 'sdc_extentions' houses a form called 'AbstractSearchForm' to simplify search implementations.
+"""
+
+from django import forms
+from django.utils.translation import gettext_lazy as _
+
+
+class AbstractSearchForm(forms.Form):
+    """
+    The AbstractSearchForm facilitates the development of a user interface for searching
+    entries of a Django model type from the database. This form is closely  linked to
+    the :func:`sdc_core.sdc_extentions.search.handle_search_form` handler. A form class
+    that extends this class is automatically created when you use the sdc management
+    command 'sdc_new_model'.
+
+    The following class properties can be used to customize the search form:
+
+    :cvar CHOICES: specifies the property according to which the search results are to be sorted.
+    The value is a tuple of tuples of human-readable name, property name.
+    :cvar DEFAULT_CHOICES: is the name of the property to which the search results are to be sorted if non is selected.
+    :cvar SEARCH_FIELDS: is a list or a tuple of names of the properties that are included in the actual search
+    :cvar PLACEHOLDER: is the placeholder text in the search input field.
+
+    """
+
+    CHOICES: tuple[tuple[str,str]] = ()
+    SEARCH_FIELDS: list[str] = []
+    DEFAULT_CHOICES: str = ""
+    NO_RESULTS_ON_EMPTY_SEARCH = False
+    PLACEHOLDER = _('Search')
+    search = forms.CharField(label=_('Search'), required=False, max_length=100, initial='')
+    order_by = forms.ChoiceField(widget=forms.Select, required=False, choices=CHOICES)
+    range_start = forms.IntegerField(widget=forms.HiddenInput(), required=False, initial=0)
+    _method = forms.CharField(widget=forms.HiddenInput(), required=True, initial='search')
+
+
+    def __init__(self, data=None, *args, **kwargs):
+        auto_id= self.__class__.__name__ + "_%s"
+        if len(data) == 0:
+            data = None
+        super(AbstractSearchForm, self).__init__(data, auto_id=auto_id, *args, **kwargs)
+        self.fields['search'].widget.attrs['placeholder'] = self.PLACEHOLDER
+        if len(self.CHOICES) == 0:
+            del self.fields["order_by"]
+        else:
+            self.fields['order_by'].choices = self.CHOICES
+            self.fields['order_by'].initial = self.DEFAULT_CHOICES

simpledomcontrol-0.56.1/sdc_core/sdc_extentions/import_manager.py

@@ -0,0 +1,18 @@
+import importlib
+
+
+def import_function(string_path: str) -> any:
+    """
+    Imports a function or a property using a python import sting (path separated by dots)
+
+    :param string_path: python import sting
+    :return: callable function, property or None
+    """
+
+    if string_path is not None:
+        p, m = string_path.rsplit('.', 1)
+        mod = importlib.import_module(p)
+        met = getattr(mod, m)
+        return met
+
+    return None

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/sdc_core/sdc_extentions/models.py

@@ -11,11 +11,20 @@ from django.apps import apps
 from channels.layers import get_channel_layer
 from django.contrib.auth import get_user_model
 
+from sdc_core.sdc_extentions.forms import AbstractSearchForm
+
 User = get_user_model()
 
 _ALL_MODELS = None
 
-def all_models():
+
+def all_models() -> dict[str,any]:
+    """
+    Collects and returns all SDC Models
+
+    :return: all SDC models as a dict with keys are model names and the class as value
+    """
+
     global _ALL_MODELS
     if _ALL_MODELS is None:
         _ALL_MODELS = {
@@ -23,7 +32,12 @@ def all_models():
         }
     return _ALL_MODELS
 
-class ConsumerSerializer(Serializer):
+
+class SDCSerializer(Serializer):
+    """
+    The SDCSerializer serializes SdcModels for the API and websocket communication
+
+    """
 
     def handle_m2m_field(self, obj, field):
         super().handle_m2m_field(obj, field)
@@ -42,22 +56,78 @@ class ConsumerSerializer(Serializer):
             return field.value_from_object(obj).url
         return super()._value_from_field(obj, field)
 
+
+_SDC_META_DEFAULT = {'edit_form': None,
+                     'create_form': None,
+                     'html_list_template': None,
+                     'html_detail_template': None,
+                     'html_form_template': getattr(settings, 'MODEL_FORM_TEMPLATE', "elements/form.html")
+                     }
+
+
+class classproperty(property):
+    def __get__(self, obj, objtype=None):
+        return super().__get__(objtype)
+
+    def __set__(self, obj, value):
+        super().__set__(type(obj), value)
+
+
+class _SdcMetaDummy:
+    _sdc_checked = False
+
+
 class SdcModel():
+    """
+    A Django Model which also extents the SdcModel class can be used as a Websocked based Client Model.
+    Use the SDC management command new_model to create a new model class.
+    """
+
     __is_sdc_model__ = True
-    edit_form = None
-    create_form = None
-    html_list_template = None
-    html_detail_template = None
-    html_form_template = getattr(settings, 'MODEL_FORM_TEMPLATE', "elements/form.html")
-    apply_filter = None
     _scope = None
 
+    class SearchForm(AbstractSearchForm):
+        CHOICES = (("id", "Id"),)
+        PLACEHOLDER = ""
+        DEFAULT_CHOICES = CHOICES[0][0]
+        SEARCH_FIELDS = ("id",)
+
+    @classproperty
+    def SdcMeta(cls):
+        """
+        SdcMeta is a metaclass that contains all the
+        important metadata for rendering HTML views of instances.
+        All class variable are python import sting
+
+        :cvar edit_form: Import string to edit form class
+        :cvar create_form: Import string to edit form class
+        :cvar forms: Import string to edit form class
+
+        """
+        if not hasattr(cls, '_SdcMeta'):
+            setattr(cls, '_SdcMeta', _SdcMetaDummy())
+
+        sdc_meta = getattr(cls, '_SdcMeta')
+
+        if not getattr(sdc_meta, '_sdc_checked', False):
+            setattr(sdc_meta, '_sdc_checked', True)
+            for k, v in _SDC_META_DEFAULT.items():
+                if not hasattr(sdc_meta, k):
+                    setattr(sdc_meta, k, getattr(cls, k, v))
+        return sdc_meta
+
     @property
     def scope(self) -> dict[str: any]:
+        """
+        :return: Websocket scope object
+        """
         return self._scope
 
     @scope.setter
     def scope(self, scope: dict[str: any]):
+        """
+        Set the Websocket scope object
+        """
         self._scope = scope
 
     @classmethod
@@ -73,15 +143,24 @@ class SdcModel():
         raise NotImplemented
 
     @classmethod
-    def data_load(cls, user: User, action: str, obj: dict[str: any]) -> QuerySet|None:
+    def data_load(cls, user: User, action: str, obj: dict[str: any]) -> QuerySet | None:
         return None
 
 
 @receiver(post_save)  # instead of @receiver(post_save, sender=Rebel)
 @receiver(post_delete)  # instead of @receiver(post_save, sender=Rebel)
-def set_winner(sender, instance=None, created=False, **kwargs):
+def set_winner(sender, instance=None, created: bool = False, **kwargs):
+    """
+    Handles the client notification if an SDC model has been saved, created or deleted.
+
+    :param sender: The modul class
+    :param instance: Saved, created or deleted instance
+    :param created: True if instance has no db id before it has been saved
+    :param kwargs:
+    """
+
     if instance is not None and hasattr(sender, '__is_sdc_model__'):
-        serialize_instance = ConsumerSerializer().serialize([instance])
+        serialize_instance = SDCSerializer().serialize([instance])
         if created:
             async_to_sync(get_channel_layer().group_send)(sender.__name__, {
                 'event_id': 'none',

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/sdc_core/sdc_extentions/response.py

@@ -5,13 +5,12 @@ from django.http import HttpResponse
 from django.template.loader import render_to_string
 from django.core.serializers.json import DjangoJSONEncoder
 
-
 NEXT = 'next_controller'
 
 
-
-def sdc_link_factory(controller: str = None, link_data: dict = None, add_sdc_index : bool = True) -> str:
+def sdc_link_factory(controller: str = None, link_data: dict = None, add_sdc_index: bool = True) -> str:
     """
+
     :param controller: path to controller
     :type controller: str, optional
     :param link_data: arguments passed to the new redirected controller
@@ -51,16 +50,14 @@ def send_redirect(controller: str = None, back: bool = False, link_data: dict =
     send_redirect is a simple way to redirect a client to another SDC controller. Set the controller argument according to
     the rules of the sdc_tools.sdc_navigator. Following you see some examples:
 
-
     - /view-a/view-b -> view-b as subview of view-a
     - */view-b -> keeps first view as it is and view-b as subview
     - ../view-b -> replaces current latest subview by view-b
     - ./view-b -> adds view-b as next latest subview to the current path
 
-
     :param controller: path to controller
     :type controller: str, optional
-    :param back: if 'True' the redirect url is equal to '..', default is 'False'
+    :param back: if ``True`` the redirect url is equal to ``..``, default is ``False``
     :type back: boolean, optional
     :param link_data: arguments passed to the new redirected controller
     :type link_data: dict, optional
@@ -86,7 +83,7 @@ def send_redirect(controller: str = None, back: bool = False, link_data: dict =
     return HttpResponse(json.dumps(kwargs, cls=DjangoJSONEncoder), status=301, content_type="application/json")
 
 
-def send_success(template_name: str = None, context: dict = None, request = None, status= 'success', **kwargs):
+def send_success(template_name: str = None, context: dict = None, request=None, status='success', **kwargs):
     """
 
     :param template_name: HTML template name
@@ -110,5 +107,6 @@ def send_error(template_name: str = None, context: dict = None, request=None, st
         kwargs['html'] = render_to_string(template_name, request=request, context=context)
     return HttpResponse(json.dumps(kwargs, cls=DjangoJSONEncoder), status=status, content_type="application/json")
 
+
 def send_controller(controller_name: str):
-    return HttpResponse('<%s></%s>' % (controller_name,controller_name), content_type="text/html")
+    return HttpResponse('<%s></%s>' % (controller_name, controller_name), content_type="text/html")

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/sdc_core/sdc_extentions/search.py

@@ -1,11 +1,21 @@
-from django.db.models import Q
+from django.db.models import Q, QuerySet
+from sdc_core.sdc_extentions.forms import AbstractSearchForm
 
-def generate_q_key_value_request(key, val):
+def _generate_q_key_value_request(key, val):
     map_val = {key + '__icontains': val}
     return Q(**map_val)
 
 
-def handle_search_form(query_set, search_form, filter_dict=None, range=0):
+def handle_search_form(query_set: QuerySet, search_form: AbstractSearchForm, filter_dict: dict=None, range: int=0):
+    """
+    This handler function takes a :class:`sdc_core.sdc_extentions.forms.AbstractSearchForm`
+
+    :param query_set:
+    :param search_form:
+    :param filter_dict:
+    :param range:
+    :return:
+    """
     if not search_form.is_valid():
         data = {}
     else:
@@ -26,9 +36,9 @@ def handle_search_form(query_set, search_form, filter_dict=None, range=0):
         q_list = None
         for key in search_form.SEARCH_FIELDS:
             if q_list is None:
-                q_list = generate_q_key_value_request(key, key_word)
+                q_list = _generate_q_key_value_request(key, key_word)
             else:
-                q_list = q_list | generate_q_key_value_request(key, key_word)
+                q_list = q_list | _generate_q_key_value_request(key, key_word)
         query_set = query_set.filter(q_list).distinct()
         query_set_count = query_set.count()
     elif(search_form.NO_RESULTS_ON_EMPTY_SEARCH):

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/sdc_core/template_files/Assets/gulpfile.jsx

@@ -1,8 +1,10 @@
 'use strict'
 
 const {src, dest, series, parallel} = require('gulp');
-const path = require("path");
 const webpack = require('webpack-stream');
+const copy = require('gulp-copy');
+
+process.env.JS_CILENT_FILE_EXTENTIONS = ['.js', '.json'];
 
 const {
     sdc_scss,
@@ -20,11 +22,20 @@ function webpack_javascript() {
         .pipe(dest('../static'));
 }
 
+function copy_statics() {
+    return src('./static/**/*')
+        .pipe(copy('../static', { prefix: 1 }))
+        .on('end', () => {
+            console.log('Contents copied successfully!');
+        });
+}
+
 exports.webpack = webpack_javascript;
 exports.scss = sdc_scss;
 exports.link_files = sdc_link_files;
 exports.clean = sdc_clean;
-exports.default = sdc_default_build_factory(webpack_javascript);
+exports.copy_statics = copy_statics;
+exports.default = series(copy_statics, sdc_default_build_factory(webpack_javascript));
 exports.watch_scss = sdc_watch_scss;
 exports.watch_webpack = sdc_watch_webpack_factory(webpack_javascript);
 

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/sdc_core/template_files/Assets/src/index.style.scss

@@ -1,17 +1,17 @@
-@import "../node_modules/bootstrap/scss/bootstrap";
+@import "../../node_modules/bootstrap/dist/css/bootstrap";
 @import "./sdc_user/sdc_user.style";
 @import "./sdc_tools/sdc_tools.style";
 
+body::before {
+    content: "SDC Works";
+    font-size: larger;
+    color: red;
+}
+
 body {
     background-color: cornflowerblue;
 
-    ::before {
-        content: "SDC Works";
-        font-size: larger;
-        color: red;
-    }
-
     .navbar-dummy {
         height: 70px;
     }
-}
+}

{simpledomcontrol-0.55.4 → simpledomcontrol-0.56.1}/sdc_core/template_files/controller/template_controller.js.txt

@@ -7,12 +7,26 @@ class §CONTROLLERNAMETITLE§Controller extends AbstractSDC {
         super();
         this.contentUrl = "§TEMPLATEURL§"; //§TAGNAME§
 
+        /**
+         * Uncomment the following line to make sure the HTML template
+         * of this controller is not cached and reloaded for every instance
+         * of this controller.
+         */
+        // this.contentReload = true;
+
+        /**
+         * Uncomment the following line to make this controller asynchronous.
+         * This means that the parent controller finishes loading without
+         * waiting for this controller
+         */
+        // this.load_async = true;
+
         /**
          * Events is an array of dom events.
          * The pattern is {'event': {'dom_selector': handler}}
-         * Uncommend the following line to add events;
+         * Uncomment the following line to add events;
          */
-        // this.events.unshift({'click': {'.header-sample': (ev, $elem)=> $elem.css('border', '2px solid black')}}});
+        // this.events.unshift({'click': {'.header-sample': (ev, $elem)=> $elem.css('border', '2px solid black')}});
     }
 
     //-------------------------------------------------//