djgentelella 0.5.5__py3-none-any.whl → 0.5.7__py3-none-any.whl

djgentelella/__init__.py

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

djgentelella/chunked_upload/constants.py

@@ -1,4 +1,4 @@
-from django.utils.translation import gettext as _
+from django.utils.translation import gettext_lazy as _
 
 
 class http_status:

djgentelella/chunked_upload/utils.py

@@ -0,0 +1,47 @@
+"""
+Utility functions for chunked upload management.
+"""
+from django.utils import timezone
+
+from djgentelella.chunked_upload.constants import UPLOADING, COMPLETE
+from djgentelella.models import ChunkedUpload
+from djgentelella.settings import EXPIRATION_DELTA
+
+
+def get_expired_uploads():
+    """
+    Get queryset of chunked uploads that have expired.
+
+    Returns:
+        QuerySet: ChunkedUpload objects that have expired.
+    """
+    return ChunkedUpload.objects.filter(
+        created_on__lt=(timezone.now() - EXPIRATION_DELTA)
+    )
+
+
+def delete_expired_uploads(exclude_ids=None):
+    """
+    Delete chunked uploads that have already expired.
+
+    Args:
+        exclude_ids: Optional list of upload IDs to exclude from deletion.
+
+    Returns:
+        dict: A dictionary with 'complete' and 'uploading' keys containing
+              the count of deleted uploads for each status.
+    """
+    count = {UPLOADING: 0, COMPLETE: 0}
+    qs = get_expired_uploads()
+
+    if exclude_ids:
+        qs = qs.exclude(id__in=exclude_ids)
+
+    for chunked_upload in qs:
+        count[chunked_upload.status] += 1
+        chunked_upload.delete()
+
+    return {
+        'complete': count[COMPLETE],
+        'uploading': count[UPLOADING],
+    }

djgentelella/fields/secure.py

@@ -0,0 +1,109 @@
+import base64
+import io
+import json
+import os
+from base64 import b64encode, b64decode
+
+from Crypto.Cipher import AES
+from django.conf import settings
+from django.db import models
+
+
+def create_key(size=32):
+    key = os.urandom(size)
+    base64_encoded = base64.b64encode(key)
+    return base64_encoded.decode("utf-8")
+
+
+def get_salt_session(size=16):
+    key = settings.SECRET_KEY.encode()
+    if len(key) > size:
+        return key[:size]
+    return key
+
+
+def salt_encrypt(message, session_key=None):
+    if type(message) == str:
+        message = message.encode()
+    session_key = get_salt_session()
+    file_out = io.BytesIO()
+    cipher_aes = AES.new(session_key, AES.MODE_EAX)
+    ciphertext, tag = cipher_aes.encrypt_and_digest(message)
+    [file_out.write(x) for x in (cipher_aes.nonce, tag, ciphertext)]
+    file_out.seek(0)
+    return b64encode(file_out.read())
+
+
+def salt_decrypt(message):
+    if message is None:
+        return None
+    raw_cipher_data = b64decode(message)
+    file_in = io.BytesIO(raw_cipher_data)
+    file_in.seek(0)
+
+    nonce, tag, ciphertext = [file_in.read(x) for x in (16, 16, -1)]
+    session_key = get_salt_session()
+    cipher_aes = AES.new(session_key, AES.MODE_EAX, nonce)
+    decrypted = cipher_aes.decrypt_and_verify(ciphertext, tag)
+    return decrypted
+
+
+class GTEncryptedText(models.TextField):
+    """
+    Encrypt data using AES and secure django key use in models like:
+    in models.py
+
+        class MyModel(models.Model):
+            my_secret = GTEncryptedText(null=True, blank=True)
+
+    """
+
+    def from_db_value(self, value, expression, connection):
+        if value is None:
+            return value
+        if isinstance(value, str):
+            value = value.encode()
+        return salt_decrypt(value)
+
+    def pre_save(self, model_instance, add):
+        field = getattr(model_instance, self.attname)
+        if field is None:
+            return None
+        dev = salt_encrypt(field)
+        if type(dev) == bytes:
+            dev = dev.decode()
+        return dev
+
+    def value_from_object(self, obj):
+        dev = super(GTEncryptedText, self).value_from_object(obj)
+        return dev.decode() if dev is not None else None
+
+
+class GTEncryptedJSONField(models.JSONField):
+    """
+    Encrypt data using AES and secure django key use in models can store JSON objects:
+    in models.py
+
+        class MyModel(models.Model):
+            my_secret = GTEncryptedJSONField(null=True, blank=True)
+
+    """
+
+    def get_prep_value(self, value):
+        # encrypt the JSON before save to the database
+        if value is not None:
+            value = json.dumps(value)
+            encrypted_value = salt_encrypt(
+                super().get_prep_value(value).encode("utf-8")
+            )
+            return encrypted_value.decode("utf-8")  # Store as text in DB
+        return value
+
+    def from_db_value(self, value, expression, connection):
+        # decrypt when loading from the database
+        if value is not None:
+            decrypted_value = salt_decrypt(value.encode("utf-8"))
+            return super().from_db_value(
+                decrypted_value.decode("utf-8"), expression, connection
+            )
+        return value

djgentelella/management/commands/delete_expired_uploads.py

@@ -1,48 +1,58 @@
-from optparse import make_option
-
-from chunked_upload.constants import UPLOADING, COMPLETE
-from chunked_upload.models import ChunkedUpload
-from chunked_upload.settings import EXPIRATION_DELTA
 from django.core.management.base import BaseCommand
-from django.utils import timezone
-from django.utils.translation import ugettext as _
 
-prompt_msg = _(u'Do you want to delete {obj}?')
+from djgentelella.chunked_upload.constants import UPLOADING, COMPLETE
+from djgentelella.chunked_upload.utils import get_expired_uploads, delete_expired_uploads
 
 
 class Command(BaseCommand):
-    # Has to be a ChunkedUpload subclass
-    model = ChunkedUpload
-
     help = 'Deletes chunked uploads that have already expired.'
 
-    option_list = BaseCommand.option_list + (
-        make_option('--interactive',
-                    action='store_true',
-                    dest='interactive',
-                    default=False,
-                    help='Prompt confirmation before each deletion.'),
-    )
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--interactive',
+            action='store_true',
+            dest='interactive',
+            default=False,
+            help='Prompt confirmation before each deletion.',
+        )
 
     def handle(self, *args, **options):
         interactive = options.get('interactive')
 
+        if interactive:
+            result = self._handle_interactive()
+        else:
+            result = delete_expired_uploads()
+
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"{result['complete']} complete uploads were deleted."
+            )
+        )
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"{result['uploading']} incomplete uploads were deleted."
+            )
+        )
+
+    def _handle_interactive(self):
+        """Handle interactive deletion with user confirmation."""
         count = {UPLOADING: 0, COMPLETE: 0}
-        qs = self.model.objects.all()
-        qs = qs.filter(created_on__lt=(timezone.now() - EXPIRATION_DELTA))
+        exclude_ids = []
 
-        for chunked_upload in qs:
-            if interactive:
-                prompt = prompt_msg.format(obj=chunked_upload) + u' (y/n): '
+        for chunked_upload in get_expired_uploads():
+            prompt = f'Do you want to delete {chunked_upload}? (y/n): '
+            answer = input(prompt).lower()
+            while answer not in ('y', 'n'):
                 answer = input(prompt).lower()
-                while answer not in ('y', 'n'):
-                    answer = input(prompt).lower()
-                if answer == 'n':
-                    continue
 
-            count[chunked_upload.status] += 1
-            # Deleting objects individually to call delete method explicitly
-            chunked_upload.delete()
+            if answer == 'n':
+                exclude_ids.append(chunked_upload.id)
+            else:
+                count[chunked_upload.status] += 1
+                chunked_upload.delete()
 
-        print('%i complete uploads were deleted.' % count[COMPLETE])
-        print('%i incomplete uploads were deleted.' % count[UPLOADING])
+        return {
+            'complete': count[COMPLETE],
+            'uploading': count[UPLOADING],
+        }

djgentelella/migrations/0018_alter_chunkedupload_status.py

@@ -13,6 +13,6 @@ class Migration(migrations.Migration):
         migrations.AlterField(
             model_name='chunkedupload',
             name='status',
-            field=models.PositiveSmallIntegerField(choices=[(1, 'Subiendo'), (2, 'Completo')], default=1),
+            field=models.PositiveSmallIntegerField(choices=[(1, 'Uploading'), (2, 'Complete')], default=1),
         ),
     ]

djgentelella/models_utils.py

@@ -0,0 +1,87 @@
+import datetime
+import logging
+import os
+from pathlib import Path
+
+from django.utils.text import slugify
+
+logger = logging.getLogger("djgentelella")
+
+
+def get_file_name(instance, name):
+    model_name = str(type(instance).__name__).lower()
+
+    return "%s-%s" % (
+        model_name,
+        name
+    )
+
+
+def upload_files_by_model_and_dates(instance, filename):
+    """
+    Create a directory structure of the type model/date/file. Usage:
+
+        myfile = models.FileField(upload_to=upload_files_by_model_and_dates)
+    """
+    date = int(datetime.datetime.now().strftime("%Y%m%d%H%M%S"))
+    path = Path(filename)
+    extension = path.suffix
+
+    if extension == ".zip":
+        name = path.stem
+    else:
+        name = get_file_name(instance, slugify(path.stem))
+
+    model_name = str(type(instance).__name__).lower()
+    return f"{model_name}/{date}/{name}{extension}"
+
+
+def upload_files_by_model_and_month(instance, filename):
+    """
+    Create a directory structure of the type model/yearmonth/file. Usage:
+
+        myfile = models.FileField(upload_to=upload_files_by_model_and_dates)
+    """
+    dates = datetime.datetime.now().strftime("%Y%m")
+    path = Path(filename)
+    extension = path.suffix
+
+    if extension == ".zip":
+        name = path.stem
+    else:
+        name = get_file_name(instance, slugify(path.stem))
+
+    model_name = str(type(instance).__name__).lower()
+    return f"{model_name}/{dates}/{name}{extension}"
+
+
+def delete_file_and_folder(file_field):
+    """
+        Delete the file associated with file_field and, if the containing folder is empty,
+        delete it.
+    """
+    if not file_field:
+        return
+
+    # Obtener la ruta absoluta del archivo
+    file_path = file_field.path
+    if os.path.exists(file_path):
+        try:
+            os.remove(file_path)
+            logger.info(f"Deleted file: {file_path}")
+        except Exception as e:
+            logger.error(f"Error deleting file: {file_path}", exc_info=e)
+
+    # Obtener la carpeta contenedora del archivo
+    directory = os.path.dirname(file_path)
+
+    # Intentar eliminar la carpeta, si está vacía.
+    if os.path.exists(directory):
+        # Listar el contenido de la carpeta
+        files = os.listdir(directory)
+        if not files:
+            try:
+                os.rmdir(directory)
+                logger.info(f"Folder created: {directory}")
+            except Exception as e:
+                logger.error(f"Error deleting folder: {directory}", exc_info=e)

djgentelella/permission_management/__init__.py

@@ -69,3 +69,10 @@ class AnyPermissionByAction(BasePermission):
             return False
 
         return any_permission(request.user, perms)
+
+
+def get_actions_by_perms(user, actions_list):
+    actions = {}
+    for action, perms in actions_list.items():
+        actions[action] = all_permission(user, perms)
+    return actions

djgentelella/serializers/__init__.py

@@ -31,3 +31,17 @@ class GTDateTimeField(DateTimeField):
         if not value and self.allow_empty_str:
             return None
         return super().to_internal_value(value)
+
+
+class DateFieldWithEmptyString(DateField):
+    def to_internal_value(self, value):
+        if not value:
+            return None
+        return super(DateFieldWithEmptyString, self).to_internal_value(value)
+
+
+class DateTimeFieldFieldWithEmptyString(DateTimeField):
+    def to_internal_value(self, value):
+        if not value:
+            return None
+        return super(DateTimeFieldFieldWithEmptyString, self).to_internal_value(value)

djgentelella/serializers/secure.py

@@ -0,0 +1,8 @@
+from rest_framework import serializers
+
+
+class GTEncryptedTextField(serializers.CharField):
+    def to_representation(self, value):
+        if not value:
+            return ""
+        return str(value.decode())