djgentelella 0.3.18__py3-none-any.whl → 0.3.20__py3-none-any.whl

djgentelella/__init__.py

@@ -1 +1 @@
-__version__ = '0.3.18'
+__version__ = '0.3.20'

djgentelella/blog/forms.py

@@ -2,12 +2,12 @@ from django import forms
 from markitup.widgets import MarkItUpWidget
 from rest_framework.reverse import reverse_lazy
 
-from djgentelella.forms.forms import CustomForm
+from djgentelella.forms.forms import GTForm
 from djgentelella.widgets import core as genwidgets
 from . import models
 
 
-class EntryForm(CustomForm, forms.ModelForm):
+class EntryForm(GTForm, forms.ModelForm):
     class Meta:
         model = models.Entry
         exclude = ('published_content', 'author')
@@ -22,7 +22,7 @@ class EntryForm(CustomForm, forms.ModelForm):
         }
 
 
-class CategoryForm(CustomForm, forms.ModelForm):
+class CategoryForm(GTForm, forms.ModelForm):
     class Meta:
         model = models.Category
         fields = '__all__'

djgentelella/fields/files.py

@@ -0,0 +1,125 @@
+import base64
+import json
+from pathlib import Path
+
+from django.core.files.base import ContentFile
+from django.utils.text import slugify
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+
+from djgentelella.models import ChunkedUpload
+
+
+class GTBase64FileField(serializers.FileField):
+    def __init__(self, *args, max_files=1, delete_if_empty=False,
+                 allow_empty_file=False, **kwargs):
+        self.max_files = max_files
+        self.delete_if_empty = delete_if_empty
+        self.allow_empty_file = allow_empty_file
+        super().__init__(*args, **kwargs)
+
+    def to_internal_value(self, datalist):
+        result = []
+        if not isinstance(datalist, list):
+            raise serializers.ValidationError(
+                _("A list of elements is expected, ej: [{name: 'name of file', value:'base64 string representation'}]"))
+        if len(datalist) > self.max_files:
+            raise serializers.ValidationError(
+                _(f"Too many elements, max_file = {self.max_files}"))
+
+        for data in datalist:
+            required_fields = ["name", "value"]
+            for field in required_fields:
+                if field not in data:
+                    raise serializers.ValidationError(
+                        _("Invalid structure you need to provide {name: 'name of file', value:'base64 string representation'}"))
+            name = slugify(Path(data["name"]).stem)
+            suffix = Path(data["name"]).suffix
+            file_name = name + suffix
+            file_value = data["value"]
+
+            try:
+                # Decodificar el contenido en base64
+                decoded_value = base64.b64decode(file_value)
+            except base64.binascii.Error:
+                self.fail('invalid')
+                # raise serializers.ValidationError(_(
+                #    "The 'value' is not a valid base64 string"))
+
+            file_content = ContentFile(decoded_value, name=file_name)
+            result.append(file_content)
+        if result:
+            if self.max_files == 1:
+                return result[0]
+
+            return result
+        # here check for field of the instance
+        if not self.delete_if_empty and self.root.instance:
+            if hasattr(self.root.instance, self.source):
+                return getattr(self.root.instance, self.source)
+        if not self.allow_empty_file:
+            self.fail('required')
+
+    def to_representation(self, value):
+        data = super().to_representation(value)
+        if data and value.name and value.storage.exists(value.name):
+            name = Path(value.name).name
+            return {'name': name, 'url': data}
+
+
+class ChunkedFileField(serializers.FileField):
+    
+    def parse_value(self, value):
+        """
+        Parses the given value and returns the parsed result.
+
+        Args:
+            value (str): The value to be parsed.
+
+        Returns:
+            The parsed result if the value is valid and contains the required attributes,
+            one of url, token, or actions otherwise returns None.
+        """
+        dev = None
+        try:
+            dev = json.loads(value)
+            if not ('url' in dev or 'token' in dev or 'actions' in dev):
+                dev = None
+        except Exception as e:
+            pass
+        return dev
+
+    def to_internal_value(self, data):
+        """
+        Converts the given data to internal value representation.
+
+        Args:
+            data (str): The data to be converted.
+
+        Returns:
+            The internal value representation of the data, or None if the data is invalid
+            or does not contain the required attributes.
+        """
+        token = self.parse_value(data)
+        dev = None
+        if token:
+            if 'actions' in token and token['actions'] == 'delete':
+                return False
+            if 'token' in token:
+                tmpupload = ChunkedUpload.objects.filter(
+                    upload_id=token['token']).first()
+                if tmpupload:
+                    dev = tmpupload.get_uploaded_file()
+                    # tmpupload.delete()
+
+            else:
+                if self.root.instance:
+                    if hasattr(self.root.instance, self.source):
+                        return getattr(self.root.instance, self.source)
+        return dev
+
+    def to_representation(self, value):
+        data = super().to_representation(value)
+        if data and value.name and value.storage.exists(value.name):
+            name = Path(value.name).name
+            return {'name': value.name, 'url': data, 'display_name': name}

djgentelella/forms/decorators.py

@@ -1,5 +1,5 @@
 from djgentelella.fields import tree
-from djgentelella.forms.forms import CustomForm
+from djgentelella.forms.forms import GTForm
 from djgentelella.widgets import core
 from djgentelella.widgets import trees
 
@@ -55,8 +55,8 @@ def decore_form_instance(form_instance, exclude=()):
             widget = get_field_widget(form_instance.fields[field])
             if widget:
                 form_instance.fields[field].widget = widget
-    for method in CustomForm.exposed_method:
+    for method in GTForm.exposed_method:
         setattr(form_instance, method,
-                _form_instance(getattr(CustomForm, method), form_instance))
+                _form_instance(getattr(GTForm, method), form_instance))
     form_instance.is_customized = True
     return form_instance

djgentelella/forms/forms.py

@@ -1,5 +1,4 @@
 from django import forms
-# "'<tr%(html_class_attr)s><th>%(label)s</th><td>%(errors)s%(field)s%(help_text)s</td></tr>'"
 from django.forms import BaseFormSet, HiddenInput
 from django.forms import BaseModelFormSet
 from django.forms.formsets import DELETION_FIELD_NAME
@@ -8,46 +7,162 @@ from django.utils.safestring import mark_safe
 
 class GTForm(forms.Form):
     """
-    Append the next render methods to forms
+    GTForm is the basis of form management, it does the work of django `forms.Form`, including enhancements and boostrap rendering, so it should be inherited from this form, rather than `forms.Form`.
+
+    Example of use:
+
+    .. code:: python
+
+         from djgentelella.forms.forms import GTForm
+         class MyForm(GTForm):
+              myfield = forms.TextField()
+
+    Using with forms.ModelForm
+
+    .. code:: python
+
+         from djgentelella.forms.forms import GTForm
+         class MyForm(GTForm, forms.ModelForm):
+              myfield = forms.TextField()
+              class Meta:
+                model = MyModel
+
+    Creating an instance and specify how render it.
+
+    .. code:: python
+
+        myform = myGTForm(render_type='as_inline', ... )
+
     """
     exposed_method = ('as_plain', 'as_inline', 'as_horizontal')
+    default_render_type = None
+    template_name_plain = 'forms/as_plain.html'
+    template_name_inline = 'forms/as_inline.html'
+    template_name_horizontal = 'forms/as_horizontal.html'
+    template_name_grid = 'forms/as_grid.html'
+    grid_representation = None
+
+    def __init__(self, *args, **kwargs):
+        render_type = self.default_render_type if self.default_render_type is not None else 'as_horizontal'
+        if 'render_type' in kwargs and hasattr(self, kwargs['render_type']):
+            render_type = kwargs.pop('render_type')
+
+        super().__init__(*args, **kwargs)
+
+        match render_type:
+            case 'as_table':
+                self.renderer.form_template_name = self.template_name_table
+            case 'as_ul':
+                self.renderer.form_template_name = self.template_name_ul
+            case 'as_p':
+                self.renderer.form_template_name = self.template_name_p
+            case 'as_div':
+                self.renderer.form_template_name = self.template_name_div
+            case 'as_horizontal':
+                self.renderer.form_template_name = self.template_name_horizontal
+            case 'as_inline':
+                self.renderer.form_template_name = self.template_name_inline
+            case 'as_plain':
+                self.renderer.form_template_name = self.template_name_plain
+            case 'as_grid':
+                self.renderer.form_template_name = self.template_name_grid
+            case _:
+                self.renderer.form_template_name = self.template_name_horizontal
+
+    @property
+    def grid(self):
+        """
+        Example of return structure:
+
+        .. code:: python
+
+            [
+                [ [forms.Field],[], [] ],
+                [ [], [] ],
+            ]
+
+        """
+        fields = []
+        dic_fields = {}
+        for name, bf in self._bound_items():
+            if not bf.is_hidden:
+                fields.append(bf)
+                dic_fields[name] = bf
+
+        if self.grid_representation is not None:
+            grid = []  # self.grid_representation
+            for row in self.grid_representation:
+                col_list = []
+                for col in row:
+                    row_list = []
+                    for field in col:
+                        if field in dic_fields and dic_fields[field]:
+                            row_list.append(dic_fields[field])
+                        else:
+                            if hasattr(self, field):
+                                row_list.append(getattr(self, field)())
+                    col_list.append(row_list)
+                grid.append(col_list)
+            return grid
+        return [[fields]]
 
     def as_plain(self):
-        "Returns this form rendered as HTML <tr>s -- excluding the <table></table>."
-
-        return self._html_output(
-            normal_row='<div class="as_plain"><div %(html_class_attr)s ' +
-                       '>%(label)s%(errors)s%(field)s%(help_text)s</div></div>',
-            error_row='%s',
-            row_ender=' ',
-            help_text_html='<br /><span class="helptext">%s</span>',
-            errors_on_separate_row=False)
+        "Returns this form rendered as HTML using as_plain bootstrap approach."
+        if hasattr(self, '_html_output'):
+            return self._html_output(
+                normal_row='<div class="as_plain"><div %(html_class_attr)s ' +
+                           '>%(label)s%(errors)s%(field)s%(help_text)s</div></div>',
+                error_row='%s',
+                row_ender=' ',
+                help_text_html='<br /><span class="helptext">%s</span>',
+                errors_on_separate_row=False)
+        return self.render(self.template_name_plain)
 
     def as_inline(self):
-        "Return this form rendered as HTML <tr>s -- excluding the <table></table>."
-        return self._html_output(
-            normal_row='<div class="mb-4"><span class="">%(label)s</span>' +
-                       ' %(errors)s%(field)s%(help_text)s</div>',
-            error_row='%s',
-            row_ender='</div>',
-            help_text_html=' <span class="helptext">%s</span>',
-            errors_on_separate_row=False,
-        )
+        "Return this form rendered as HTML using as_inline bootstrap approach."
+        if hasattr(self, '_html_output'):
+            return self._html_output(
+                normal_row='<div class="mb-4"><span class="">%(label)s</span>' +
+                           ' %(errors)s%(field)s%(help_text)s</div>',
+                error_row='%s',
+                row_ender='</div>',
+                help_text_html=' <span class="helptext">%s</span>',
+                errors_on_separate_row=False,
+            )
+        return self.render(self.template_name_inline)
 
     def as_horizontal(self):
-        "Return this form rendered as HTML <tr>s -- excluding the <table></table>."
-        return self._html_output(
-            normal_row='<div class="form-group row"><span class="col-sm-3">' +
-                       '%(label)s</span> <div class="col-sm-9 " ' +
-                       '>%(errors)s%(field)s%(help_text)s</div></div>',
-            error_row='%s',
-            row_ender='</div>',
-            help_text_html=' <span class="helptext">%s</span>',
-            errors_on_separate_row=False,
-        )
-
-
-CustomForm = GTForm
+        "Return this form rendered as HTML using as_horizontal bootstrap approach."
+        if hasattr(self, '_html_output'):
+            return self._html_output(
+                normal_row='<div class="form-group row"><span class="col-sm-3">' +
+                           '%(label)s</span> <div class="col-sm-9 " ' +
+                           '>%(errors)s%(field)s%(help_text)s</div></div>',
+                error_row='%s',
+                row_ender='</div>',
+                help_text_html=' <span class="helptext">%s</span>',
+                errors_on_separate_row=False,
+            )
+        return self.render(self.template_name_horizontal)
+
+    def as_grid(self):
+        """
+        Allow you to arrange the form fields in rows and cols,
+        When you use this render needs to fill  `grid_representation` attribute in your form
+        Return this form rendered as HTML using grid bootstrap approach.,
+
+        .. code:: python
+
+            grid_representation=[
+                [ ['key'],[], [] ],
+                [ [], [] ],
+            ]
+
+        """
+        return self.render(self.template_name_grid)
+
+    def closediv(self):
+        return "</div>"
 
 
 class BaseFormset:
@@ -65,6 +180,11 @@ class BaseFormset:
 
 
 class GTFormSet(BaseFormSet, BaseFormset):
+    """
+    This class Allow to manage FormSet using GTForm and Widgets,
+    provide an implementation to integrate with django formset system.
+    """
+
     ordering_widget = HiddenInput
 
     def add_fields(self, form, index):

djgentelella/forms/models.py

@@ -2,10 +2,10 @@ from django import forms
 
 from djgentelella.models import Help
 from djgentelella.widgets import core as genwidgets
-from .forms import CustomForm
+from .forms import GTForm
 
 
-class HelpForm(CustomForm, forms.ModelForm):
+class HelpForm(GTForm, forms.ModelForm):
     class Meta:
         model = Help
         fields = ['help_title', 'help_text']

djgentelella/serializers/selects.py

@@ -0,0 +1,32 @@
+from rest_framework import serializers
+
+
+class GTS2SerializerBase(serializers.Serializer):
+    id_field = 'pk'
+    display_fields = '__str__'
+    default_selected = True
+    default_disable = False
+
+    def get_id(self, obj):
+        return getattr(obj, self.id_field)
+
+    def get_text(self, obj):
+        if isinstance(self.display_fields, str):
+            if self.display_fields == '__str__':
+                return str(obj)
+            return getattr(obj, self.display_fields)
+        if isinstance(self.display_fields, (list, tuple)):
+            lwords = [getattr(obj, key) for key in self.display_fields]
+            return " ".join(lwords)
+        return repr(obj)
+
+    def get_selected(self, obj):
+        return self.default_selected
+
+    def get_disabled(self, obj):
+        return self.default_disable
+
+    id = serializers.SerializerMethodField()
+    text = serializers.SerializerMethodField()
+    disabled = serializers.SerializerMethodField()
+    selected = serializers.SerializerMethodField()

djgentelella/settings.py

@@ -44,7 +44,7 @@ except Exception as e:
     from django.contrib.auth.models import User
 
 #####################################################
-#    Chuncked Upload
+#    Chunked Upload
 ############################################
 
 # How long after creation the upload will expire