djgentelella 0.4.30__py3-none-any.whl → 0.5.1__py3-none-any.whl

djgentelella/__init__.py

@@ -1 +1,4 @@
-__version__ = '0.4.30'
+__version__ = '0.5.1'
+
+if __name__ == '__main__':
+    print(__version__)

djgentelella/admin.py

@@ -2,10 +2,12 @@ from django.contrib import admin
 
 from djgentelella.firmador_digital.models import UserSignatureConfig
 from djgentelella.models import MenuItem, Help, GentelellaSettings, Notification, \
-    ChunkedUpload
+    ChunkedUpload, Trash
 from djgentelella.models import PermissionsCategoryManagement
 from djgentelella.utils import clean_cache
-
+from django.contrib.admin.models import LogEntry
+from djgentelella.history.utils import ACTIONS
+from django.utils.translation import gettext_lazy as _
 
 class MenuAdmin(admin.ModelAdmin):
     filter_horizontal = ['permission']
@@ -33,6 +35,41 @@ class ChunkedUploadAdmin(admin.ModelAdmin):
 class UserSignatureConfigAdmin(admin.ModelAdmin):
     list_display = ('id', 'user', 'config')
 
+class TrashAdmin(admin.ModelAdmin):
+    list_display = ("id", "deleted_by", "content_type", "object_id", "object_repr", "created_at")
+    ordering = ("-created_at",)
+    search_fields = ("id",)
+
+
+class ActionFlagFilter(admin.SimpleListFilter):
+    title = _("Action")
+    parameter_name = "action_flag"
+
+    def lookups(self, request, model_admin):
+        return [(k, str(v)) for k, v in ACTIONS.items()]
+
+    def queryset(self, request, queryset):
+        val = self.value()
+        if not val:
+            return queryset
+        try:
+            return queryset.filter(action_flag=int(val))
+        except ValueError:
+            return queryset.none()
+
+class LogEntryAdmin(admin.ModelAdmin):
+    verbose_name = _("History")
+    verbose_name_plural = _("History")
+    list_display = ("id", "action_time", "user", "content_type", "object_id", "object_repr", "action_label", "change_message")
+    search_fields = ("content_type__app_label", "content_type__model", "object_id", "user__username")
+    list_filter = (
+        ActionFlagFilter,
+    )
+    def action_label(self, obj):
+        return ACTIONS.get(obj.action_flag, obj.get_action_flag_display() or obj.action_flag)
+    action_label.short_description = _("Action")
+
+
 admin.site.register(UserSignatureConfig, UserSignatureConfigAdmin)
 admin.site.register(ChunkedUpload, ChunkedUploadAdmin)
 admin.site.register(MenuItem, MenuAdmin)
@@ -40,3 +77,5 @@ admin.site.register(Help)
 admin.site.register(PermissionsCategoryManagement)
 admin.site.register(GentelellaSettings, GentelellaSettingsAdmin)
 admin.site.register(Notification, NotificationAdmin)
+admin.site.register(Trash, TrashAdmin)
+admin.site.register(LogEntry, LogEntryAdmin)

djgentelella/firmador_digital/consumers/sign.py

@@ -12,7 +12,7 @@ from djgentelella.firmador_digital.utils import RemoteSignerClient
 from djgentelella.serializers.firmador_digital import (
     WSRequest,
     InitialSignatureSerializer,
-    CompleteSignatureSerializer,
+    CompleteSignatureSerializer, ValidateDocumentSerializer,
 )
 
 logger = logging.getLogger("djgentelella")
@@ -35,24 +35,30 @@ class SignConsumer(JsonWebsocketConsumer):
                 return InitialSignatureSerializer(data=content)
             if serializer.validated_data["action"] == "complete_signature":
                 return CompleteSignatureSerializer(data=content)
+            if serializer.validated_data["action"] == "validate_document":
+                return ValidateDocumentSerializer(data=content)
 
     def disconnect(self, close_code):
         super().disconnect(close_code)
+        logger.info(f"Disconnect {close_code}")
 
     def receive_json(self, content, **kwargs):
         """
         Called with decoded JSON content.
         """
+        socket_id = ""
         try:
             serializer = self.get_serializer(content)
 
             if serializer.is_valid():
-
+                socket_id = serializer.validated_data['socket_id']
                 match serializer.validated_data["action"]:
                     case "initial_signature":
                         self.do_initial_signature(serializer)
                     case "complete_signature":
                         self.do_complete_signature(serializer)
+                    case "validate_document":
+                        self.do_validate_document(serializer)
                     case _:
                         self.do_default(serializer)
             else:
@@ -63,6 +69,7 @@ class SignConsumer(JsonWebsocketConsumer):
                     "details": serializer.errors,
                     "status": 400,
                     "code": 11,
+                    'socket_id': serializer.data.get('socket_id')
                 })
                 logger.error("Invalid request.")
 
@@ -74,9 +81,20 @@ class SignConsumer(JsonWebsocketConsumer):
                 "details": str(e),
                 "status": 500,
                 "code": 999,
+                "socket_id": socket_id
             })
             logger.error("An unexpected error occurred.", exc_info=e)
 
+    def do_validate_document(self, serializer):
+        signer = RemoteSignerClient(self.scope["user"])
+
+        response = signer.validate_document(
+            instance=serializer.validated_data["instance"],
+        )
+
+        response['socket_id'] = serializer.validated_data['socket_id']
+        self.send_json(response)
+
     def do_initial_signature(self, serializer):
         signer = RemoteSignerClient(self.scope["user"])
 
@@ -87,6 +105,8 @@ class SignConsumer(JsonWebsocketConsumer):
             docsettings=serializer.validated_data["docsettings"],
         )
 
+        response['socket_id'] = serializer.validated_data['socket_id']
+
         # remove signer image
         if "imageIcon" in response:
             del response["imageIcon"]
@@ -103,7 +123,8 @@ class SignConsumer(JsonWebsocketConsumer):
             signer = RemoteSignerClient(self.scope["user"])
             data = dict(serializer.validated_data)
             response = signer.complete_signature(data)
-            self.send_json({"result": response})
+            self.send_json({"result": response,
+                            'socket_id': serializer.validated_data['socket_id']})
         except Exception as e:
             logger.error("Complete the signature fail", exc_info=e)
 

djgentelella/firmador_digital/forms.py

@@ -1,12 +1,20 @@
+import base64
 import logging
+from io import BytesIO
 
 from django import forms
 from django.core.exceptions import ValidationError
+from django.core.files.uploadedfile import UploadedFile
+from django.templatetags.static import static
+from django.utils.safestring import mark_safe
 from django.utils.translation import gettext_lazy as _
 
+from djgentelella.firmador_digital.models import UserSignatureConfig, \
+    get_signature_default, FORMATS_DATE, FONT_ALIGNMENT
 from djgentelella.firmador_digital.signvalue_utils import ValueDSParser
 from djgentelella.forms.forms import GTForm
 from djgentelella.widgets import core as genwidgets
+from djgentelella.widgets.core import FileInput
 
 logger = logging.getLogger('djgentelella')
 
@@ -26,3 +34,135 @@ class RenderValueForm(GTForm, ValueDSParser):
                 _("Invalid value not encoded as b64 o json parser error"),
                 code="invalid")
         return jsondata
+
+
+class SignatureConfigForm(GTForm, forms.ModelForm):
+    contact = forms.CharField(
+        required=False,
+        max_length=100,
+        widget=genwidgets.TextInput,
+        label=_("Contact")
+    )
+    dateFormat = forms.ChoiceField(
+        widget=genwidgets.Select,
+        required=True,
+        choices=FORMATS_DATE,
+        label=_("Date format")
+    )
+
+    defaultSignMessage = forms.CharField(
+        widget=genwidgets.Textarea,
+        required=False,
+        max_length=100,
+        label=_("Signature message")
+    )
+    fontAlignment = forms.ChoiceField(
+        choices=FONT_ALIGNMENT,
+        widget=genwidgets.Select,
+        required=True,
+        label=_("Font alignment")
+    )
+    fontColor = forms.CharField(
+        max_length=50,
+        widget=genwidgets.ColorInput,
+        required=True,
+        label=_("Font color"),
+        initial="#FFFFFF",
+    )
+    fontSize = forms.IntegerField(
+        min_value=5,
+        max_value=28,
+        initial=7,
+        widget=genwidgets.NumberInput,
+        label=_("Font size")
+    )
+    place = forms.CharField(
+        required=False,
+        max_length=100,
+        widget=genwidgets.TextInput,
+        label=_("Place")
+    )
+    reason = forms.CharField(
+        required=False,
+        max_length=100,
+        widget=genwidgets.TextInput,
+        label=_("Reason")
+    )
+    isVisibleSignature = forms.BooleanField(
+        required=False,
+        widget=genwidgets.YesNoInput,
+        label=_("Visible signature")
+    )
+    image = forms.ImageField(
+        required=False,
+        widget=FileInput,
+        label=_("Signature image")
+    )
+
+    default_render_type = "as_grid"
+
+    grid_representation = [
+        [["contact"]],
+        [["place"]],
+        [["reason"]],
+        [["image"], ["preview_image"]],
+        [["dateFormat"], ["isVisibleSignature"]],
+        [["fontSize"], ["fontColor"], ["fontAlignment"]],
+        [["defaultSignMessage"]],
+    ]
+
+    class Meta:
+        model = UserSignatureConfig
+        fields = []
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        cfg = self.instance.config if getattr(self.instance, "config",
+                                              None) else get_signature_default()
+        for key, value in cfg.items():
+            if key in self.fields:
+                self.fields[key].initial = value
+
+    def preview_image(self):
+        label = _("Image preview")
+        src = static("gentelella/images/default.png")
+
+        if self.instance and self.instance.config:
+            image_b64 = self.instance.config.get("image")
+            if image_b64 and image_b64.startswith("data:image"):
+                src = image_b64
+
+        return mark_safe(f"""
+            <label for="image-preview"><strong>{label}:</strong></label><br>
+            <div class="d-flex justify-content-center">
+                <img id="image-preview" alt="{label}" src="{src}" style="max-height:100px; max-width:300px; display:block;">
+            </div>
+        """)
+
+    def save(self, commit=True):
+        data = get_signature_default()
+        prev_image = self.instance.config.get("image")
+
+        for key in data.keys():
+            if key in self.cleaned_data:
+                val = self.cleaned_data[key]
+                if key == "image":
+                    if isinstance(val, UploadedFile):
+                        # el usuario subió un nuevo archivo
+                        buffered = BytesIO()
+                        for chunk in val.chunks():
+                            buffered.write(chunk)
+                        mime = val.content_type
+                        b64 = base64.b64encode(buffered.getvalue()).decode()
+                        val = f"data:{mime};base64,{b64}"
+                    else:
+                        # no se subió archivo nuevo → conservamos imagen anterior
+                        val = prev_image
+
+                if isinstance(data[key], str) and not isinstance(val, str):
+                    val = str(val)
+                data[key] = val
+
+        self.instance.config = data
+        return super().save(commit=commit)

djgentelella/firmador_digital/models.py

@@ -1,31 +1,26 @@
 from django.contrib.auth import get_user_model
 from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+FORMATS_DATE = [("dd/MM/yyyy hh:mm:ss a", "dd/MM/yyyy hh:mm:ss a"),
+                ("yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm:ss"),
+                ("MM/dd/yyyy hh:mm:ss a", "MM/dd/yyyy hh:mm:ss a"),
+                ("dd-MM-yyyy", "dd-MM-yyyy"), ]
+
+FONT_ALIGNMENT = (('NONE', _('None')), ('RIGHT', _('Right')), ('LEFT', _('Left')),
+                  ('TOP', _('Top')), ('BOTTOM', _('Bottom')),)
+
 
 def get_signature_default():
-    return {
-        "backgroundColor": "transparente",
-        "cAdESLevel": "LTA",
-        "contact": "",
-        "country": "CR",
-        "dateFormat": "dd/MM/yyyy hh\:mm\:ss a",
-        "defaultSignMessage": "Esta es una representación gráfica únicamente,\nverifique la validez de la firma.",
-        "font": "Nimbus Sans Regular",
-        "fontAlignment": "RIGHT",
-        "fontColor": "000000",
-        "fontSize": "7",
-        "image": "",
-        "language": "es",
-        "pAdESLevel": "LTA",
-        "place": "",
-        "portNumber": "3516",
-        "reason": "",
-        "signHeight": "33",
-        "signWidth": "133",
-        "signX": "40",
-        "signY": "60",
-        "xAdESLevel": "LTA",
-        "isVisibleSignature": False,
-    }
+    return {"backgroundColor": "transparent", "cAdESLevel": "LTA", "contact": "",
+            "country": "CR", "dateFormat": "dd/MM/yyyy hh:mm:ss a",
+            "defaultSignMessage": "Esta es una representación gráfica únicamente,\nverifique la validez de la firma.",
+            "font": "Nimbus Sans Regular", "fontAlignment": "None",
+            "fontColor": "000000",
+            "fontSize": "7", "image": "", "language": "es", "pAdESLevel": "LTA",
+            "place": "", "portNumber": "3516", "reason": "", "signHeight": "33",
+            "signWidth": "133", "signX": "40", "signY": "60", "xAdESLevel": "LTA",
+            "isVisibleSignature": False, "hideSignatureAdvice": False, }
 
 
 class UserSignatureConfig(models.Model):

djgentelella/firmador_digital/utils.py

@@ -47,6 +47,17 @@ class RemoteSignerClient:
         )
         return response.json()
 
+    def validate_document(self, instance):
+        b64doc = self.get_b64document(instance['value'])
+        files = {
+            "b64Document": b64doc,
+            "DocumentExtension": ".pdf",
+        }
+        response = requests.post(
+            settings.FIRMADOR_VALIDA_URL, json=files
+        )
+        return response.json()
+
     def _finalize_signature(self, data_to_sign, task):
         result = None
         error_msg = _("An unexpected error occurred during the signing process.")

djgentelella/firmador_digital/views.py

@@ -0,0 +1,31 @@
+from django.contrib import messages
+from django.contrib.auth.decorators import login_required
+from django.shortcuts import render, get_object_or_404, redirect
+from django.utils.translation import gettext_lazy as _
+
+from djgentelella.firmador_digital.forms import SignatureConfigForm
+from djgentelella.firmador_digital.models import UserSignatureConfig
+
+@login_required
+def update_signature_settings(request):
+
+    config, is_created = UserSignatureConfig.objects.get_or_create(user=request.user)
+
+
+    if request.method == "POST":
+        form = SignatureConfigForm(request.POST, request.FILES, instance=config, render_type="as_grid")
+        if form.is_valid():
+            form.save()
+            messages.success(request, _("Updated signature settings successfully."))
+            return redirect("signature_config")
+    else:
+        form = SignatureConfigForm(instance=config, render_type="as_grid")
+
+
+    return render(
+        request,
+        "gentelella/digital_signature/update_signature_settings.html",
+        context={
+            "form": form
+        }
+    )

djgentelella/firmador_digital/viewsets.py

@@ -70,8 +70,19 @@ class DigitalSignatureRenderFileAPIView(APIView):
         return Response(file_data, content_type='application/pdf')
 
     def get_instance_file(self, instance, fieldname):
+        # check if instance and fieldname are not None
+        if not instance or not fieldname:
+            return None
+
         file_path = getattr(instance, fieldname)
-        file_data = None
-        with open(file_path.path, 'rb') as f:
-            file_data = f.read()
-        return file_data
+        if not file_path:
+            return None
+
+        # check if not file
+        try:
+            with open(file_path.path, 'rb') as f:
+                file_data = f.read()
+
+            return file_data
+        except (FileNotFoundError, OSError):
+            return None

djgentelella/forms/forms.py

@@ -69,6 +69,11 @@ class GTForm(forms.Form):
             case _:
                 self.renderer.form_template_name = self.template_name_horizontal
 
+    def get_error_for_grid(self, name):
+        if name in self.errors:
+            return self.errors[name]
+        return None
+
     @property
     def grid(self):
         """
@@ -97,10 +102,13 @@ class GTForm(forms.Form):
                     row_list = []
                     for field in col:
                         if field in dic_fields and dic_fields[field]:
-                            row_list.append(dic_fields[field])
+                            row_list.append(
+                                (dic_fields[field], self.get_error_for_grid(field))
+                            )
                         else:
                             if hasattr(self, field):
-                                row_list.append(getattr(self, field)())
+                                row_list.append((getattr(self, field)(),
+                                                 self.get_error_for_grid(field)))
                     col_list.append(row_list)
                 grid.append(col_list)
             return grid

djgentelella/groute.py

@@ -18,7 +18,10 @@ def register_lookups(prefix='', basename=None):
     def decore(klass):
         if basename in ['userbase', 'groupbase']:
             from djgentelella import settings
-            if settings.REGISTER_DEFAULT_USER_API:
+            if klass.__module__ == 'djgentelella.gtselects':
+                if settings.REGISTER_DEFAULT_USER_API:
+                    routes.register(prefix, klass, basename=basename)
+            else:
                 routes.register(prefix, klass, basename=basename)
         else:
             routes.register(prefix, klass, basename=basename)

djgentelella/history/api.py

@@ -0,0 +1,145 @@
+from djgentelella.objectmanagement import AuthAllPermBaseObjectManagement
+from django.utils.translation import gettext_lazy as _
+from djgentelella.history.utils import add_log
+from django.contrib.admin.models import LogEntry, ADDITION, CHANGE, DELETION
+from djgentelella.history.serializers import HistoryDataTableSerializer
+from djgentelella.history.filterset import HistoryFilterSet
+from rest_framework.authentication import SessionAuthentication
+from rest_framework.filters import SearchFilter, OrderingFilter
+from rest_framework.pagination import LimitOffsetPagination
+from django_filters.rest_framework import DjangoFilterBackend
+from rest_framework.response import Response
+from django.conf import settings
+from django.db.models import Q
+from django.contrib.contenttypes.models import ContentType
+
+
+
+class BaseViewSetWithLogs(AuthAllPermBaseObjectManagement):
+
+    def perform_create(self, serializer):
+        super().perform_create(serializer)
+        new_instance = serializer.instance
+
+        add_log(
+            self.request.user,
+            new_instance,
+            ADDITION,
+            new_instance._meta.verbose_name.title().lower(),
+            [],
+            change_message=_("Created"),
+        )
+
+    def perform_update(self, serializer):
+        # get the instance before the update
+        instance = self.get_object()
+        old_values = {
+            field: getattr(instance, field)
+            for field in serializer.validated_data.keys()
+        }
+
+        super().perform_update(serializer)
+
+        new_instance = serializer.instance
+        # get changed fields
+        changed_fields = []
+
+        for field in serializer.validated_data.keys():
+            old_value = old_values.get(field)
+            new_value = getattr(new_instance, field)
+            if old_value != new_value:
+                changed_fields.append(field)
+
+        add_log(
+            self.request.user,
+            new_instance,
+            CHANGE,
+            new_instance._meta.verbose_name.title().lower(),
+            changed_data=changed_fields,
+            change_message=_("Updated"),
+        )
+
+    def perform_destroy(self, instance):
+        instance = self.get_object()
+        if instance._meta.verbose_name.title() in self.models_log:
+            add_log(
+                self.request.user,
+                instance,
+                DELETION,
+                instance._meta.verbose_name.title().lower(),
+                change_message=_("Deleted"),
+            )
+
+        super().perform_destroy(instance)
+
+
+class HistoryViewSet(AuthAllPermBaseObjectManagement):
+    authentication_classes = [SessionAuthentication]
+    serializer_class = HistoryDataTableSerializer
+    queryset = LogEntry.objects.all()
+    pagination_class = LimitOffsetPagination
+    filter_backends = (DjangoFilterBackend, SearchFilter, OrderingFilter)
+    search_fields = ["object_repr"]
+    filterset_class = HistoryFilterSet
+    ordering_fields = ["-action_time"]
+    ordering = ("-action_time",)
+    perms = {"list": ["admin.view_logentry"]}
+
+    def get_queryset(self):
+        queryset = self.queryset
+
+        # check allowed models in settings
+        allowed = getattr(settings, "GT_HISTORY_ALLOWED_MODELS", None)
+
+        if allowed:
+            allowed_ctypes = self.contenttypes_from_settings(allowed)
+
+            if not allowed_ctypes.exists():
+                return queryset.none()
+
+            queryset = queryset.filter(content_type__in=allowed_ctypes).distinct()
+
+
+        # check contenttype param in form
+        ctypes_param = self.request.GET.get("contenttype")
+        print(allowed)
+        if ctypes_param and ctypes_param in allowed:
+
+            ctypes_qs = self.contenttypes_from_settings([ctypes_param])
+            print(ctypes_qs)
+
+
+            if not ctypes_qs.exists():
+                return queryset.none()
+
+            queryset = queryset.filter(content_type__in=ctypes_qs).distinct()
+
+        # default values
+        return queryset
+
+    def contenttypes_from_settings(self, entries):
+        q = Q()
+        for item in entries:
+            if isinstance(item, str) and "." in item:
+                app_label, model_name = item.split(".", 1)
+                app_label = app_label.strip()
+                model_key = model_name.strip().lower()
+                q |= Q(app_label=app_label, model=model_key)
+
+        if not q:
+            return ContentType.objects.none()
+        return ContentType.objects.filter(q)
+
+
+    def list(self, request, *args, **kwargs):
+        queryset = self.filter_queryset(self.get_queryset())
+        page = self.paginate_queryset(queryset)
+        data = page if page is not None else queryset
+
+        response = {
+            "data": data,
+            "recordsTotal": LogEntry.objects.count(),
+            "recordsFiltered": queryset.count(),
+            "draw": self.request.GET.get("draw", 1),
+        }
+        return Response(self.get_serializer(response).data)

djgentelella/history/filterset.py

@@ -0,0 +1,23 @@
+from django.contrib.admin.models import LogEntry
+from django_filters.rest_framework import FilterSet, ChoiceFilter
+from django_filters import DateTimeFromToRangeFilter
+from djgentelella.fields.drfdatetime import DateTimeRangeTextWidget
+from djgentelella.history.utils import ACTIONS
+
+class HistoryFilterSet(FilterSet):
+    action_time = DateTimeFromToRangeFilter(
+        widget=DateTimeRangeTextWidget(attrs={"placeholder": "DD/MM/YYYY/"})
+    )
+
+    action_flag = ChoiceFilter(
+        field_name="action_flag",
+        choices=[(k, str(v)) for k, v in ACTIONS.items()],  # added 4 y 5
+    )
+
+    class Meta:
+        model = LogEntry
+        fields = {
+            "object_repr": ["icontains"],
+            "change_message": ["icontains"],
+            "user": ["exact"],
+        }