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

djgentelella/__init__.py

@@ -1 +1 @@
-__version__ = '0.3.29'
+__version__ = '0.4.30'

djgentelella/admin.py

@@ -1,5 +1,6 @@
 from django.contrib import admin
 
+from djgentelella.firmador_digital.models import UserSignatureConfig
 from djgentelella.models import MenuItem, Help, GentelellaSettings, Notification, \
     ChunkedUpload
 from djgentelella.models import PermissionsCategoryManagement
@@ -9,7 +10,6 @@ from djgentelella.utils import clean_cache
 class MenuAdmin(admin.ModelAdmin):
     filter_horizontal = ['permission']
 
-
 class GentelellaSettingsAdmin(admin.ModelAdmin):
     list_display = ['key', 'value']
     search_fields = ['key']
@@ -21,18 +21,19 @@ class GentelellaSettingsAdmin(admin.ModelAdmin):
 
     clean_settings_cache.short_description = "Clean settings cache"
 
-
 class NotificationAdmin(admin.ModelAdmin):
     list_display = ['description', 'state', 'message_type']
     list_editable = ['state']
 
-
 class ChunkedUploadAdmin(admin.ModelAdmin):
     list_display = ('upload_id', 'filename', 'status', 'created_on')
     search_fields = ('filename', 'filename')
     list_filter = ('status',)
 
+class UserSignatureConfigAdmin(admin.ModelAdmin):
+    list_display = ('id', 'user', 'config')
 
+admin.site.register(UserSignatureConfig, UserSignatureConfigAdmin)
 admin.site.register(ChunkedUpload, ChunkedUploadAdmin)
 admin.site.register(MenuItem, MenuAdmin)
 admin.site.register(Help)

djgentelella/fields/files.py

@@ -7,6 +7,7 @@ from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _
 from rest_framework import serializers
 
+from djgentelella.firmador_digital.signvalue_utils import ValueDSParser
 from djgentelella.models import ChunkedUpload
 
 
@@ -68,7 +69,7 @@ class GTBase64FileField(serializers.FileField):
 
 
 class ChunkedFileField(serializers.FileField):
-    
+
     def parse_value(self, value):
         """
         Parses the given value and returns the parsed result.
@@ -123,3 +124,28 @@ class ChunkedFileField(serializers.FileField):
         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}
+
+
+class DigitalSignatureField(serializers.FileField, ValueDSParser):
+    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.
+        """
+        dev = None
+        jsondata = self.get_json_file(data)
+        if jsondata:
+            return self.get_filefield(jsondata)
+        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/firmador_digital/config/asgi_config.py

@@ -0,0 +1,32 @@
+
+import os
+
+from django.core.asgi import get_asgi_application
+from channels.routing import ProtocolTypeRouter, URLRouter
+from channels.auth import AuthMiddlewareStack
+from djgentelella.firmador_digital.config.websocket_urls import websocket_urlpatterns
+
+class AsgiConfig:
+
+    def __init__(self, settings_module: str):
+        # Configuramos la variable de entorno con el módulo de settings
+        os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings_module)
+        # variable de la aplicación
+        self.application = self._build_application()
+
+    def _build_application(self):
+        """
+        Construye y retorna la aplicación ASGI compuesta.
+        """
+        return ProtocolTypeRouter({
+            "http": get_asgi_application(),
+            "websocket": AuthMiddlewareStack(
+                URLRouter(websocket_urlpatterns)
+            ),
+        })
+
+    def __call__(self, scope, receive, send):
+        """
+        Permite que la instancia sea llamada como una aplicación ASGI.
+        """
+        return self.application(scope, receive, send)

djgentelella/firmador_digital/config/asgi_worker.py

@@ -0,0 +1,5 @@
+from uvicorn_worker import UvicornWorker as BaseUvicornWorker
+
+
+class DjgentelellaUvicornWorker(BaseUvicornWorker):
+    CONFIG_KWARGS = {"lifespan": "off", "loop": "auto", "http": "auto"}

djgentelella/firmador_digital/config/websocket_urls.py

@@ -0,0 +1,4 @@
+from django.urls import path
+from djgentelella.firmador_digital.consumers.sign import SignConsumer
+
+websocket_urlpatterns = [path("async/sign_document", SignConsumer.as_asgi())]

djgentelella/firmador_digital/consumers/pdf_render.py

@@ -0,0 +1,8 @@
+from rest_framework.renderers import BaseRenderer
+
+class PDFRenderer(BaseRenderer):
+    media_type = 'application/pdf'
+    format = 'pdf'
+
+    def render(self, data, accepted_media_type=None, renderer_context=None):
+        return data

djgentelella/firmador_digital/consumers/sign.py

@@ -0,0 +1,148 @@
+import base64
+import logging
+from io import BytesIO
+
+from PIL import Image
+from PIL.Image import Resampling
+from channels.generic.websocket import JsonWebsocketConsumer
+from django.contrib.staticfiles import finders
+from django.utils.translation import gettext_lazy as _
+
+from djgentelella.firmador_digital.utils import RemoteSignerClient
+from djgentelella.serializers.firmador_digital import (
+    WSRequest,
+    InitialSignatureSerializer,
+    CompleteSignatureSerializer,
+)
+
+logger = logging.getLogger("djgentelella")
+
+
+class SignConsumer(JsonWebsocketConsumer):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.data = None
+
+    def connect(self):
+        self.accept()
+        self.signclient = RemoteSignerClient(None)
+
+    def get_serializer(self, content):
+        serializer = WSRequest(data=content)
+
+        if serializer.is_valid():
+            if serializer.validated_data["action"] == "initial_signature":
+                return InitialSignatureSerializer(data=content)
+            if serializer.validated_data["action"] == "complete_signature":
+                return CompleteSignatureSerializer(data=content)
+
+    def disconnect(self, close_code):
+        super().disconnect(close_code)
+
+    def receive_json(self, content, **kwargs):
+        """
+        Called with decoded JSON content.
+        """
+        try:
+            serializer = self.get_serializer(content)
+
+            if serializer.is_valid():
+
+                match serializer.validated_data["action"]:
+                    case "initial_signature":
+                        self.do_initial_signature(serializer)
+                    case "complete_signature":
+                        self.do_complete_signature(serializer)
+                    case _:
+                        self.do_default(serializer)
+            else:
+                # errors when serializing data
+                self.send_json({
+                    "result": False,
+                    "error": str(_("Invalid request.")),
+                    "details": serializer.errors,
+                    "status": 400,
+                    "code": 11,
+                })
+                logger.error("Invalid request.")
+
+        except Exception as e:
+            # uncontrolled data serializing errors
+            self.send_json({
+                "result": False,
+                "error": str(_("An unexpected error occurred.")),
+                "details": str(e),
+                "status": 500,
+                "code": 999,
+            })
+            logger.error("An unexpected error occurred.", exc_info=e)
+
+    def do_initial_signature(self, serializer):
+        signer = RemoteSignerClient(self.scope["user"])
+
+        # data for the request to Firmador server
+        response = signer.send_document_to_sign(
+            instance=serializer.validated_data["instance"],
+            usertoken=serializer.validated_data["card"],
+            docsettings=serializer.validated_data["docsettings"],
+        )
+
+        # remove signer image
+        if "imageIcon" in response:
+            del response["imageIcon"]
+
+        # about writing the answer to add b64image
+        logo_url = serializer.validated_data["logo_url"]
+        if "b64image" in response and logo_url:
+            response["b64image"] = self.get_logo_base64(logo_url)
+
+        self.send_json(response)
+
+    def do_complete_signature(self, serializer):
+        try:
+            signer = RemoteSignerClient(self.scope["user"])
+            data = dict(serializer.validated_data)
+            response = signer.complete_signature(data)
+            self.send_json({"result": response})
+        except Exception as e:
+            logger.error("Complete the signature fail", exc_info=e)
+
+    def do_default(self, serializer):
+        pass
+
+    def get_logo_base64(self, path_logo, target_width=128):
+        if not path_logo:
+            print("Do not have logo")
+            return ""
+
+        # Si la ruta contiene el prefijo /static/, lo removemos
+        if path_logo.startswith('/static/'):
+            path_logo = path_logo[len('/static/'):]
+
+        # Buscar la ruta real del archivo en los directorios estáticos
+        real_path = finders.find(path_logo)
+        if not real_path:
+            print("Logo file not found in static directories.")
+            return ""
+
+        try:
+            with Image.open(real_path) as img:
+                # Calcular la altura de forma proporcional
+                ratio = target_width / float(img.width)
+                target_height = int(img.height * ratio)
+
+                # Redimensionar
+                img = img.resize((target_width, target_height), Resampling.LANCZOS)
+
+                # Guardar en memoria
+                buffer = BytesIO()
+                img.save(buffer, format='PNG')
+
+                # Convertir a base64
+                b64_logo = base64.b64encode(buffer.getvalue()).decode()
+                return b64_logo
+
+        except Exception as e:
+            print("Error leyendo logo:", e)
+            logger.error("Reading logo fail", exc_info=e)
+            return ""

djgentelella/firmador_digital/forms.py

@@ -0,0 +1,28 @@
+import logging
+
+from django import forms
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+
+from djgentelella.firmador_digital.signvalue_utils import ValueDSParser
+from djgentelella.forms.forms import GTForm
+from djgentelella.widgets import core as genwidgets
+
+logger = logging.getLogger('djgentelella')
+
+
+class CardForm(GTForm):
+    card = forms.ChoiceField(choices=[], widget=genwidgets.Select, label=_("Card"))
+
+
+class RenderValueForm(GTForm, ValueDSParser):
+    value = forms.CharField(required=True)
+
+    def clean_value(self):
+        value = self.cleaned_data['value']
+        jsondata = self.get_json_file(value)
+        if not jsondata:
+            raise ValidationError(
+                _("Invalid value not encoded as b64 o json parser error"),
+                code="invalid")
+        return jsondata

djgentelella/firmador_digital/gunicorn/config_asgi.py

@@ -0,0 +1,12 @@
+import os
+
+from django.conf import settings
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE",
+                      os.getenv("DJANGO_ASETTINGS_MODULE", "demo.asettings"))
+
+bind = getattr(settings, "UVICORN_BIND", "127.0.0.1:9022")
+wsgi_app = getattr(settings, "GUNICORN_ASGI_APP", "demo.asgi:application")
+workers = getattr(settings, "UVICORN_WORKER", 1)
+worker_class = getattr(settings, "UVICORN_WORKER_CLASS",
+                       "demo.asgi_worker.UvicornWorker")

djgentelella/firmador_digital/gunicorn/config_wsgi.py

@@ -0,0 +1,13 @@
+import os
+
+from django.conf import settings
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "demo.settings")
+
+bind = getattr(settings, "GUNICORN_BIND", "unix:/run/supervisor/gunicorn_wsgi.sock")
+wsgi_app = getattr(settings, "GUNICORN_WSGI_APP", "demo.wsgi:application")
+workers = getattr(settings, "GUNICORN_WORKERS", 1)
+worker_class = getattr(settings, "GUNICORN_WORKER_CLASS",
+                       "demo.asgi_worker.UvicornWorker")
+user = getattr(settings, "GUNICORN_USER", "demo")
+group = getattr(settings, "GUNICORN_GROUP", "demo")

djgentelella/firmador_digital/models.py

@@ -0,0 +1,33 @@
+from django.contrib.auth import get_user_model
+from django.db import models
+
+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,
+    }
+
+
+class UserSignatureConfig(models.Model):
+    user = models.ForeignKey(get_user_model(), on_delete=models.CASCADE)
+    config = models.JSONField(default=get_signature_default)

djgentelella/firmador_digital/signvalue_utils.py

@@ -0,0 +1,41 @@
+import base64
+import json
+import logging
+
+from django.contrib.contenttypes.models import ContentType
+
+from djgentelella.models import ChunkedUpload
+
+logger = logging.getLogger("djgentelella")
+
+
+class ValueDSParser:
+
+    def get_file_from_token(self, token):
+        tmpupload = ChunkedUpload.objects.filter(upload_id=token).first()
+        dev = None
+        if tmpupload:
+            dev = tmpupload.get_uploaded_file()
+        return dev
+
+    def get_json_file(self, value):
+        jsondata = None
+        try:
+            instance = base64.b64decode(value.encode())
+            jsondata = json.loads(instance.decode())
+        except Exception as e:
+            logger.error("Validation of value on digital signature fail", exc_info=e)
+        return jsondata
+
+    def get_filefield(self, jsondata):
+        if 'field_name' in jsondata:
+            ccinstance = ContentType.objects.get_for_id(jsondata['contenttype'])
+            instance = ccinstance.get_object_for_this_type(pk=jsondata['pk'])
+            return self.get_instance_file(instance, jsondata['field_name'])
+        if 'token' in jsondata:
+            return self.get_file_from_token(jsondata['token'])
+        return None
+
+    def get_instance_file(self, instance, fieldname):
+        file_path = getattr(instance, fieldname)
+        return file_path

djgentelella/firmador_digital/utils.py

@@ -0,0 +1,154 @@
+import base64
+import io
+import logging
+
+import requests
+from django.conf import settings
+from django.core.files.base import ContentFile
+from django.utils.timezone import now
+from django.utils.translation import gettext_lazy as _
+from requests import HTTPError, Timeout, RequestException
+
+logger = logging.getLogger(__name__)
+
+
+class RemoteSignerClient:
+    def __init__(self, user):
+        self.user = user
+
+    def load_settings(self, docsettings):
+        from djgentelella.firmador_digital.models import UserSignatureConfig
+        sc = UserSignatureConfig.objects.filter(user=self.user).first()
+        settings = {}
+        if sc:
+            settings.update(sc.config)
+        settings.update(docsettings)
+        return settings
+
+    def load_certificate(self, certtoken):
+        return certtoken["certificate"]
+
+    def get_b64document(self, value):
+
+        return base64.b64encode(value).decode()
+
+    def send_document_to_sign(self, instance, usertoken, docsettings):
+        b64doc = self.get_b64document(instance['value'])
+
+        files = {
+            "b64Document": b64doc,
+            "DocumentExtension": ".pdf",
+            "settings": self.load_settings(docsettings),
+            "certToken": self.load_certificate(usertoken),
+        }
+
+        response = requests.post(
+            settings.FIRMADOR_SIGN_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.")
+
+        try:
+            logger.info("Sending request to signing service")
+            response = requests.post(settings.FIRMADOR_SIGN_COMPLETE, json=data_to_sign)
+            response.raise_for_status()
+            logger.info("Successfully finalized signature for the task.")
+            result = response.json()
+        except HTTPError as errh:
+            logger.error(
+                "HTTPError during signature finalization for task %s: %s",
+                task,
+                str(errh),
+                exc_info=errh
+            )
+            error_msg = _(
+                "An error occurred while communicating with the signing service."
+            )
+            result = self.get_error_response(error_msg, str(errh), 502, 2)
+
+        except ConnectionError as errc:
+            logger.error(
+                "ConnectionError during signature finalization for task %s: %s",
+                task,
+                str(errc),
+                exc_info=errc
+            )
+            error_msg = _("Unable to connect to the signing service.")
+            result = self.get_error_response(error_msg, str(errc), 503, 2)
+        except Timeout as errt:
+            logger.error(
+                "Timeout during signature finalization for task %s: %s",
+                task,
+                str(errt),
+                exc_info=errt
+            )
+            error_msg = _("The request to the signing service timed out.")
+            result = self.get_error_response(error_msg, str(errt), 408, 12)
+        except RequestException as errr:
+            logger.error(
+                "RequestException during signature finalization for task %s: %s",
+                task,
+                str(errr),
+                exc_info=errr
+            )
+            error_msg = _("An exception ocurred el request to the signing service.")
+            result = self.get_error_response(error_msg, str(errr), 500, 999)
+        except Exception as erre:
+            logger.error(
+                "Exception during signature finalization for task %s: %s",
+                task,
+                str(erre),
+                exc_info=erre
+            )
+            error_msg = _("An unexpected error occurred during the signing process.")
+            result = self.get_error_response(error_msg, str(erre), 500, 999)
+
+        return result
+
+    def get_error_response(self, error_msg, details, status, code):
+        return {
+            "result": False,
+            "error": error_msg,
+            "details": details,
+            "status": status,
+            "code": code,
+        }
+
+    def complete_signature(self, data_to_sign):
+        from djgentelella.models import ChunkedUpload
+        datatosign = {
+            "signature": data_to_sign["signature"],
+            "documentid": data_to_sign["documentid"],
+            "certificate": data_to_sign["certificate"],
+        }
+
+        instance = data_to_sign["instance"]
+        doc_info = self._finalize_signature(datatosign, instance)
+
+        if doc_info:
+            name = "%s_%s_%s.pdf" % (
+                instance['pk'],
+                self.user.pk,
+                now().strftime("%m%d%Y"),
+            )
+            chunk = self.convert_to_django_file(
+                doc_info["bytes"],
+                name,
+            )
+            chfile = ChunkedUpload.objects.create(
+                filename=name,
+                file=ContentFile(b'', name=name),
+                completed_on=now(),
+                created_on=now(),
+                user=self.user,
+                status=2  # this is complete, but I can import constants here
+            )
+            chfile.append_chunk(chunk, save=True)
+            return chfile.upload_id
+        return False
+
+    def convert_to_django_file(self, data, name):
+        return io.BytesIO(base64.b64decode(data))

djgentelella/firmador_digital/viewsets.py

@@ -0,0 +1,77 @@
+from django.contrib.auth.decorators import login_required
+from django.contrib.contenttypes.models import ContentType
+from django.utils.decorators import method_decorator
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from djgentelella.firmador_digital.consumers.pdf_render import PDFRenderer
+from djgentelella.firmador_digital.forms import RenderValueForm
+from djgentelella.models import ChunkedUpload
+
+
+@method_decorator(login_required, name='dispatch')
+class DigitalSignatureRenderFileAPIView(APIView):
+    renderer_classes = [PDFRenderer]
+
+    form_class = RenderValueForm
+
+    def check_user(self, cc, pk, user, token=None):
+        return True
+
+    def get_token_from_form(self, form):
+        jsondata = form.cleaned_data['value']
+        if 'token' in jsondata:
+            return jsondata['token']
+        return None
+
+    def get_file_from_token(self, token):
+        tmpupload = ChunkedUpload.objects.filter(upload_id=token).first()
+        dev = None
+        if tmpupload:
+            dev = tmpupload.get_uploaded_file()
+        return dev
+
+    def file_document(self, form, cc, pk):
+        jsondata = form.cleaned_data['value']
+        if 'field_name' in jsondata:
+            ccinstance = ContentType.objects.get_for_id(cc)
+            instance = ccinstance.get_object_for_this_type(pk=pk)
+            return self.get_instance_file(instance, jsondata['field_name'])
+        if 'token' in jsondata:
+            return self.get_file_from_token(jsondata['token'])
+        return None
+
+    def get(self, request, cc, pk, format=None):
+        """
+        Retrieve and serve the PDF file associated with a DigitalSignature instance.
+
+        Parameters:
+            request (HttpRequest): The incoming HTTP request.
+            pk (int or str): The primary key of the DigitalSignature instance.
+            format (optional): The format specifier (default is None).
+
+        Returns:
+            Response: An HTTP response containing the PDF file data with the
+                      content type 'application/pdf'. If the DigitalSignature instance
+                      is not found, returns a 404 Not Found response.
+        """
+        form = self.form_class(data=request.GET)
+        if not form.is_valid():
+            return Response({"detail": "File not found"},
+                            status=status.HTTP_404_NOT_FOUND)
+        token = self.get_token_from_form(form)
+        if not self.check_user(cc, pk, request.user, token=token):
+            return Response({"detail": "File not found"},
+                            status=status.HTTP_403_FORBIDDEN)
+
+        file_data = self.file_document(form, cc, pk)
+
+        return Response(file_data, content_type='application/pdf')
+
+    def get_instance_file(self, instance, fieldname):
+        file_path = getattr(instance, fieldname)
+        file_data = None
+        with open(file_path.path, 'rb') as f:
+            file_data = f.read()
+        return file_data