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

djgentelella/models.py

@@ -5,6 +5,10 @@ from django.utils.translation import gettext_lazy as _
 from tree_queries.models import TreeNode
 
 from djgentelella.chunked_upload.models import AbstractChunkedUpload
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.contenttypes.fields import GenericForeignKey
+from .models_manager import ObjectManager, AllObjectsManager, \
+    DeletedObjectsManager
 
 
 class GentelellaSettings(models.Model):
@@ -123,3 +127,95 @@ class ChunkedUpload(AbstractChunkedUpload):
         null=DEFAULT_MODEL_USER_FIELD_NULL,
         blank=DEFAULT_MODEL_USER_FIELD_BLANK
     )
+
+
+# Trash
+class Trash(models.Model):
+    """
+        Trash generic. Each row represents an instance deleted.
+    """
+    content_type = models.ForeignKey(ContentType, on_delete=models.PROTECT,
+                                     verbose_name=_("Content type"))
+    object_id = models.PositiveIntegerField(verbose_name=_("Object ID"))
+    content_object = GenericForeignKey("content_type", "object_id")
+    object_repr = models.CharField(
+        _("Object repr"), max_length=200,
+        help_text=_("Value of str(instance) at deletion time"),
+    )
+    deleted_by = models.ForeignKey(
+        User,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        verbose_name=_("Deleted by")
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        ordering = ("id",)
+        unique_together = ("content_type", "object_id")
+        indexes = [
+            models.Index(fields=["content_type", "object_id"]),
+        ]
+        verbose_name = _("Trash")
+        verbose_name_plural = _("Trash")
+
+    def __str__(self):
+        return _("Registration in trash: %(obj)s") % {"obj": self.object_repr}
+
+    def restore(self, user=None):
+        obj = self.content_object
+
+        # if `is_deleted` is in the model, unmark it
+        if hasattr(obj, "restore"):
+            obj.restore()
+
+        self.delete()  # delete the instance of trash
+
+
+    def hard_delete(self):
+        """
+            Permanent deletion of the original object and then the trash entry.
+        """
+        obj = self.content_object
+
+        if obj is None:
+            return
+
+        obj.delete(hard=True)
+
+        super().delete()
+
+
+class DeletedWithTrash(models.Model):
+    is_deleted = models.BooleanField(default=False, db_index=True)
+
+    objects = ObjectManager()
+    objects_with_deleted = AllObjectsManager()
+    objects_deleted_only = DeletedObjectsManager()
+
+    class Meta:
+        abstract = True
+
+    def delete(self, using=None, keep_parents=False, *, hard=False, user=None):
+        if hard:
+            # Permanent deletion
+            return super().delete(using=using, keep_parents=keep_parents)
+
+        self.is_deleted = True
+        self.save(update_fields=["is_deleted"])
+
+        # create trash instance
+        Trash.objects.get_or_create(
+            content_type=ContentType.objects.get_for_model(self.__class__),
+            object_id=self.pk,
+            defaults={
+                "object_repr": str(self)[:200],
+                "deleted_by": user,
+            },
+        )
+
+    # Restore an object
+    def restore(self):
+        self.is_deleted = False
+        self.save(update_fields=["is_deleted"])

djgentelella/models_manager.py

@@ -0,0 +1,40 @@
+from django.db import models
+
+
+class ObjectQuerySet(models.QuerySet):
+    # Non-deleted records
+    def alive(self):
+        return self.filter(is_deleted=False)
+
+    # Only deleted records
+    def dead(self):
+        return self.filter(is_deleted=True)
+
+    # Overridden delete (soft delete)
+    def delete(self):
+        return super().update(is_deleted=True)
+
+    # Permanent deletion
+    def hard_delete(self):
+        return super().delete()
+
+    # Bulk restore
+    def restore(self):
+        return self.update(is_deleted=False)
+
+
+class ObjectManager(models.Manager):
+    # Only alive objects by default
+    def get_queryset(self):
+        return ObjectQuerySet(self.model, using=self._db).alive()
+
+class AllObjectsManager(models.Manager):
+    # Explicit access to all objects
+    def get_queryset(self):
+        return ObjectQuerySet(self.model, using=self._db)
+
+class DeletedObjectsManager(models.Manager):
+    # Only deleted objects
+    def get_queryset(self):
+        return ObjectQuerySet(self.model, using=self._db).dead()
+

djgentelella/serializers/firmador_digital.py

@@ -69,7 +69,8 @@ class RequestInitialDoc(serializers.Serializer):
 
 
 class WSRequest(serializers.Serializer):
-    action = serializers.CharField()
+    action = serializers.CharField(required=True)
+    socket_id = serializers.CharField(required=True)
 
 
 class CardSerializer(serializers.Serializer):
@@ -88,6 +89,7 @@ class SignatureSerializer(serializers.Serializer):
 
 class InitialSignatureSerializer(serializers.Serializer):
     action = serializers.CharField()
+    socket_id = serializers.CharField(required=True)
     docsettings = DocumentSettingsSerializer()
     card = CardSerializer()
     logo_url = serializers.CharField(required=False, allow_null=True, allow_blank=True)
@@ -96,8 +98,14 @@ class InitialSignatureSerializer(serializers.Serializer):
 
 class CompleteSignatureSerializer(serializers.Serializer):
     action = serializers.CharField()
+    socket_id = serializers.CharField(required=True)
     documentid = serializers.CharField()
     certificate = serializers.CharField()
     signature = SignatureSerializer()
     logo_url = serializers.CharField(required=False, allow_null=True, allow_blank=True)
     instance = InstanceSerializer()
+
+class ValidateDocumentSerializer(serializers.Serializer):
+    action = serializers.CharField()
+    socket_id = serializers.CharField(required=True)
+    instance = InstanceSerializer()

djgentelella/serializers/selects.py

@@ -30,3 +30,17 @@ class GTS2SerializerBase(serializers.Serializer):
     text = serializers.SerializerMethodField()
     disabled = serializers.SerializerMethodField()
     selected = serializers.SerializerMethodField()
+
+
+class ChoicesGTS2Serializer(GTS2SerializerBase):
+    def __init__(self, *args, choices=None, **kwargs):
+        self.choices = dict(choices)
+        super().__init__(*args, **kwargs)
+
+    def get_id(self, obj):
+        return obj
+
+    def get_text(self, obj):
+        if obj in self.choices:
+            return self.choices[obj]
+        return obj