django-spire 0.23.6__py3-none-any.whl → 0.23.8__py3-none-any.whl

django_spire/file/tests/test_models.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import json
+
+from django.test import override_settings
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.file.tests.factories import create_test_file
+
+
+STORAGES_OVERRIDE = {
+    'default': {
+        'BACKEND': 'django.core.files.storage.FileSystemStorage',
+    },
+    'staticfiles': {
+        'BACKEND': 'django.contrib.staticfiles.storage.StaticFilesStorage',
+    },
+}
+
+
+@override_settings(STORAGES=STORAGES_OVERRIDE)
+class FileModelTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.file = create_test_file()
+
+    def test_str(self):
+        assert str(self.file) == self.file.name
+
+    def test_default_is_active(self):
+        assert self.file.is_active is True
+
+    def test_default_is_deleted(self):
+        assert self.file.is_deleted is False
+
+    def test_name_field(self):
+        assert self.file.name == 'test_file'
+
+    def test_type_field(self):
+        assert self.file.type == 'pdf'
+
+    def test_size_field(self):
+        assert self.file.size == '1.5 Mb'
+
+    def test_related_field_default(self):
+        assert self.file.related_field is None
+
+    def test_related_field_set(self):
+        file = create_test_file(related_field='abc')
+        assert file.related_field == 'abc'
+
+    def test_content_type_null(self):
+        assert self.file.content_type is None
+
+    def test_object_id_null(self):
+        assert self.file.object_id is None
+
+    def test_created_datetime_auto_set(self):
+        assert self.file.created_datetime is not None
+
+    def test_to_dict(self):
+        result = self.file.to_dict()
+
+        assert result['name'] == self.file.name
+        assert result['id'] == self.file.id
+        assert 'url' in result
+
+    def test_to_dict_keys(self):
+        result = self.file.to_dict()
+
+        assert set(result.keys()) == {'name', 'url', 'id'}
+
+    def test_to_json(self):
+        result = self.file.to_json()
+        parsed = json.loads(result)
+
+        assert parsed['name'] == self.file.name
+        assert parsed['id'] == self.file.id
+
+    def test_file_field_url(self):
+        assert self.file.file.url is not None

django_spire/file/tests/test_querysets.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from django.test import override_settings
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.file.models import File
+from django_spire.file.tests.factories import create_test_file
+
+
+STORAGES_OVERRIDE = {
+    'default': {
+        'BACKEND': 'django.core.files.storage.FileSystemStorage',
+    },
+    'staticfiles': {
+        'BACKEND': 'django.contrib.staticfiles.storage.StaticFilesStorage',
+    },
+}
+
+
+@override_settings(STORAGES=STORAGES_OVERRIDE)
+class FileQuerySetTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.file1 = create_test_file(name='File 1')
+        self.file2 = create_test_file(name='File 2')
+
+    def test_active_returns_non_deleted(self):
+        result = File.objects.active()
+
+        assert self.file1 in result
+        assert self.file2 in result
+
+    def test_active_excludes_deleted(self):
+        self.file1.is_deleted = True
+        self.file1.save()
+
+        result = File.objects.active()
+
+        assert self.file1 not in result
+        assert self.file2 in result
+
+    def test_active_excludes_inactive(self):
+        self.file1.is_active = False
+        self.file1.save()
+
+        result = File.objects.active()
+
+        assert self.file1 not in result
+        assert self.file2 in result
+
+    def test_active_excludes_deleted_and_inactive(self):
+        self.file1.is_deleted = True
+        self.file1.is_active = False
+        self.file1.save()
+
+        result = File.objects.active()
+
+        assert self.file1 not in result
+        assert self.file2 in result
+
+    def test_related_field_filters_correctly(self):
+        self.file1.related_field = 'abc'
+        self.file1.save()
+        self.file2.related_field = 'xyz'
+        self.file2.save()
+
+        result = File.objects.related_field('abc')
+
+        assert self.file1 in result
+        assert self.file2 not in result
+
+    def test_related_field_returns_empty_when_no_match(self):
+        self.file1.related_field = 'abc'
+        self.file1.save()
+
+        result = File.objects.related_field('xyz')
+
+        assert result.count() == 0
+
+    def test_related_field_filters_null_values(self):
+        self.file1.related_field = None
+        self.file1.save()
+        self.file2.related_field = 'abc'
+        self.file2.save()
+
+        result = File.objects.related_field(None)
+
+        assert self.file1 in result
+        assert self.file2 not in result
+
+    def test_chaining_active_and_related_field(self):
+        self.file1.related_field = 'abc'
+        self.file1.save()
+        self.file2.related_field = 'abc'
+        self.file2.is_deleted = True
+        self.file2.save()
+
+        result = File.objects.active().related_field('abc')
+
+        assert self.file1 in result
+        assert self.file2 not in result

django_spire/file/tests/test_utils.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.file.utils import random_64_char_token
+
+
+class Random64CharTokenTests(BaseTestCase):
+    def test_returns_string(self):
+        result = random_64_char_token()
+
+        assert isinstance(result, str)
+
+    def test_returns_64_characters(self):
+        result = random_64_char_token()
+
+        assert len(result) == 64
+
+    def test_returns_hexadecimal(self):
+        result = random_64_char_token()
+
+        int(result, 16)
+
+    def test_returns_unique_values(self):
+        result1 = random_64_char_token()
+        result2 = random_64_char_token()
+
+        assert result1 != result2
+
+    def test_returns_lowercase(self):
+        result = random_64_char_token()
+
+        assert result == result.lower()

django_spire/file/tests/test_views.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import json
+
+from django.test import RequestFactory, override_settings
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.file.models import File
+from django_spire.file.tests.factories import create_test_in_memory_uploaded_file
+from django_spire.file.views import file_multiple_upload_ajax, file_single_upload_ajax
+
+
+STORAGES_OVERRIDE = {
+    'default': {
+        'BACKEND': 'django.core.files.storage.FileSystemStorage',
+    },
+    'staticfiles': {
+        'BACKEND': 'django.contrib.staticfiles.storage.StaticFilesStorage',
+    },
+}
+
+
+@override_settings(STORAGES=STORAGES_OVERRIDE)
+class FileMultipleUploadAjaxViewTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.factory = RequestFactory()
+
+    def test_post_creates_files(self):
+        initial_count = File.objects.count()
+        uploaded_file = create_test_in_memory_uploaded_file()
+
+        request = self.factory.post(
+            '/upload/multiple/ajax',
+            data={'related_field': ''},
+        )
+        request.FILES['file'] = uploaded_file
+        request.user = self.super_user
+
+        file_multiple_upload_ajax(request)
+
+        assert File.objects.count() == initial_count + 1
+
+    def test_post_returns_json_response(self):
+        uploaded_file = create_test_in_memory_uploaded_file()
+
+        request = self.factory.post(
+            '/upload/multiple/ajax',
+            data={'related_field': ''},
+        )
+        request.FILES['file'] = uploaded_file
+        request.user = self.super_user
+
+        response = file_multiple_upload_ajax(request)
+
+        assert response.status_code == 200
+        assert response['Content-Type'] == 'application/json'
+
+    def test_post_returns_files_in_response(self):
+        uploaded_file = create_test_in_memory_uploaded_file(name='test_upload')
+
+        request = self.factory.post(
+            '/upload/multiple/ajax',
+            data={'related_field': ''},
+        )
+        request.FILES['file'] = uploaded_file
+        request.user = self.super_user
+
+        response = file_multiple_upload_ajax(request)
+        data = json.loads(response.content)
+
+        assert 'files' in data
+        assert len(data['files']) == 1
+        assert data['files'][0]['name'] == 'test_upload'
+
+    def test_get_returns_none(self):
+        request = self.factory.get('/upload/multiple/ajax')
+        request.user = self.super_user
+
+        response = file_multiple_upload_ajax(request)
+
+        assert response is None
+
+
+@override_settings(STORAGES=STORAGES_OVERRIDE)
+class FileSingleUploadAjaxViewTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.factory = RequestFactory()
+
+    def test_post_creates_file(self):
+        initial_count = File.objects.count()
+        uploaded_file = create_test_in_memory_uploaded_file()
+
+        request = self.factory.post(
+            '/upload/single/ajax',
+            data={'related_field': ''},
+        )
+        request.FILES['file'] = uploaded_file
+        request.user = self.super_user
+
+        file_single_upload_ajax(request)
+
+        assert File.objects.count() == initial_count + 1
+
+    def test_post_returns_json_response(self):
+        uploaded_file = create_test_in_memory_uploaded_file()
+
+        request = self.factory.post(
+            '/upload/single/ajax',
+            data={'related_field': ''},
+        )
+        request.FILES['file'] = uploaded_file
+        request.user = self.super_user
+
+        response = file_single_upload_ajax(request)
+
+        assert response.status_code == 200
+        assert response['Content-Type'] == 'application/json'
+
+    def test_post_returns_file_in_response(self):
+        uploaded_file = create_test_in_memory_uploaded_file(name='single_upload')
+
+        request = self.factory.post(
+            '/upload/single/ajax',
+            data={'related_field': ''},
+        )
+        request.FILES['file'] = uploaded_file
+        request.user = self.super_user
+
+        response = file_single_upload_ajax(request)
+        data = json.loads(response.content)
+
+        assert 'file' in data
+        assert data['file']['name'] == 'single_upload'
+
+    def test_get_returns_none(self):
+        request = self.factory.get('/upload/single/ajax')
+        request.user = self.super_user
+
+        response = file_single_upload_ajax(request)
+
+        assert response is None

django_spire/file/tests/test_widgets.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import json
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.file.widgets import MultipleWidget, SingleFileWidget
+
+
+class MultipleWidgetTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.widget = MultipleWidget()
+
+    def test_needs_multipart_form(self):
+        assert self.widget.needs_multipart_form is True
+
+    def test_template_name(self):
+        assert self.widget.template_name == 'django_spire/file/widget/multiple_file_widget.html'
+
+    def test_value_from_datadict(self):
+        data = {
+            'files_data': json.dumps([{'id': 1, 'name': 'test'}])
+        }
+
+        result = self.widget.value_from_datadict(data, None, 'files')
+
+        assert result == [{'id': 1, 'name': 'test'}]
+
+    def test_value_from_datadict_empty(self):
+        data = {
+            'files_data': json.dumps([])
+        }
+
+        result = self.widget.value_from_datadict(data, None, 'files')
+
+        assert result == []
+
+    def test_value_from_datadict_multiple_files(self):
+        data = {
+            'files_data': json.dumps([
+                {'id': 1, 'name': 'file1'},
+                {'id': 2, 'name': 'file2'},
+            ])
+        }
+
+        result = self.widget.value_from_datadict(data, None, 'files')
+
+        assert len(result) == 2
+        assert result[0]['name'] == 'file1'
+        assert result[1]['name'] == 'file2'
+
+
+class SingleFileWidgetTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.widget = SingleFileWidget()
+
+    def test_needs_multipart_form(self):
+        assert self.widget.needs_multipart_form is True
+
+    def test_template_name(self):
+        assert self.widget.template_name == 'django_spire/file/widget/single_file_widget.html'
+
+    def test_value_from_datadict(self):
+        data = {
+            'file_data': json.dumps({'id': 1, 'name': 'test'})
+        }
+
+        result = self.widget.value_from_datadict(data, None, 'file')
+
+        assert result == {'id': 1, 'name': 'test'}
+
+    def test_value_from_datadict_null(self):
+        data = {
+            'file_data': json.dumps(None)
+        }
+
+        result = self.widget.value_from_datadict(data, None, 'file')
+
+        assert result is None

django_spire/file/tools.py

@@ -1,11 +1,16 @@
-from typing import Any
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 from django.contrib.contenttypes.models import ContentType
 
 from django_spire.file.models import File
 
+if TYPE_CHECKING:
+    from django.db import models
+
 
-def copy_files_from_source_to_target_model_object(source: Any, target: Any) -> list[File]:
+def copy_files_from_source_to_target_model_object(source: models.Model, target: models.Model) -> list[File]:
     target_class = target.__class__
     target_content_type = ContentType.objects.get_for_model(target_class)
 
@@ -15,6 +20,7 @@ def copy_files_from_source_to_target_model_object(source: Any, target: Any) -> l
         return []
 
     files_to_create = []
+
     for file in file_list:
         new_file = File(
             content_type=target_content_type,

django_spire/file/views.py

@@ -12,7 +12,7 @@ if TYPE_CHECKING:
 
 
 @login_required()
-def file_multiple_upload_ajax(request: WSGIRequest) -> JsonResponse:
+def file_multiple_upload_ajax(request: WSGIRequest) -> JsonResponse | None:
     if request.method == 'POST':
         file_uploader = MultiFileUploader(request.POST.get('related_field', ''))
         files = file_uploader.upload(list(request.FILES.values()))
@@ -21,13 +21,17 @@ def file_multiple_upload_ajax(request: WSGIRequest) -> JsonResponse:
             'files': [file.to_dict() for file in files]
         })
 
+    return None
+
 
 @login_required()
-def file_single_upload_ajax(request: WSGIRequest) -> JsonResponse:
+def file_single_upload_ajax(request: WSGIRequest) -> JsonResponse | None:
     if request.method == 'POST':
         file_uploader = SingleFileUploader(request.POST.get('related_field', ''))
-        file = file_uploader.upload(list(request.FILES.values())[0])
+        file = file_uploader.upload(next(iter(request.FILES.values())))
 
         return JsonResponse({
             'file': file.to_dict()
         })
+
+    return None

django_spire/file/widgets.py

@@ -2,38 +2,38 @@ from __future__ import annotations
 
 import json
 
-from django.template import loader
-from django.utils.safestring import mark_safe
 from django.forms import Widget
+from django.template import loader
+from django.utils.safestring import SafeString, mark_safe
 
 
 class MultipleWidget(Widget):
     needs_multipart_form = True
     template_name = 'django_spire/file/widget/multiple_file_widget.html'
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
 
-    def value_from_datadict(self, data, files, name):
-        return json.loads(data.get(f'{name}_data'))
-
-    def render(self, name, value, attrs=None, renderer=None):
+    def render(self, name: str, value, attrs: dict | None = None, renderer=None) -> SafeString:
         context = self.get_context(name, value, attrs)
         template = loader.get_template(self.template_name).render(context)
         return mark_safe(template)
 
+    def value_from_datadict(self, data: dict, files, name: str) -> list[dict]:
+        return json.loads(data.get(f'{name}_data'))
+
 
 class SingleFileWidget(Widget):
     needs_multipart_form = True
     template_name = 'django_spire/file/widget/single_file_widget.html'
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
 
-    def value_from_datadict(self, data, files, name) -> dict:
-        return json.loads(data.get(f'{name}_data'))
-
-    def render(self, name, value, attrs=None, renderer=None):
+    def render(self, name: str, value, attrs: dict | None = None, renderer=None) -> SafeString:
         context = self.get_context(name, value, attrs)
         template = loader.get_template(self.template_name).render(context)
         return mark_safe(template)
+
+    def value_from_datadict(self, data: dict, files, name: str) -> dict:
+        return json.loads(data.get(f'{name}_data'))

django_spire/help_desk/admin.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from django.contrib import admin
+
+from django_spire.help_desk.models import HelpDeskTicket
+
+
+@admin.register(HelpDeskTicket)
+class HelpDeskTicketAdmin(admin.ModelAdmin):
+    list_display = ('pk', 'purpose', 'priority', 'status', 'created_by', 'created_datetime')
+    list_filter = ('priority', 'purpose', 'status', 'is_active', 'is_deleted')
+    ordering = ('-created_datetime',)
+    raw_id_fields = ('created_by',)
+    readonly_fields = ('created_by', 'created_datetime', 'is_active', 'is_deleted')
+    search_fields = ('description', 'created_by__username', 'created_by__email')

django_spire/help_desk/apps.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.apps import AppConfig
 
 from django_spire.utils import check_required_apps

django_spire/help_desk/auth/controller.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django_spire.auth.controller.controller import BaseAuthController
 
 

django_spire/help_desk/choices.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.db import models
 
 

django_spire/help_desk/enums.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from enum import Enum
 
 

django_spire/help_desk/exceptions.py

@@ -1,5 +1,33 @@
-class TicketEventNotificationTypeNotSupportedError(TypeError):
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django_spire.exceptions import DjangoSpireError
+
+if TYPE_CHECKING:
+    from django_spire.help_desk.enums import TicketEventType
+    from django_spire.notification.choices import NotificationTypeChoices
+
+
+class HelpDeskError(DjangoSpireError):
     pass
 
-class HelpDeskNotificationRecipientMissingEmailError(ValueError):
-    pass
+
+class TicketEventNotificationTypeNotSupportedError(HelpDeskError, TypeError):
+    def __init__(
+        self,
+        event_type: TicketEventType | None,
+        notification_type: NotificationTypeChoices
+    ) -> None:
+        if event_type is None:
+            super().__init__(f'Notification type not supported: {notification_type}')
+        else:
+            super().__init__(
+                f'Combination of event type and notification type not supported: '
+                f'Event type {event_type} - Notification type {notification_type}'
+            )
+
+
+class HelpDeskNotificationRecipientMissingEmailError(HelpDeskError, ValueError):
+    def __init__(self, recipient: str) -> None:
+        super().__init__(f'Recipient is missing an email address: {recipient}')

django_spire/help_desk/forms.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import ClassVar
 
 from django import forms

django_spire/help_desk/models.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from django.db import models
 from django.contrib.auth.models import User
 

django_spire/help_desk/querysets.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 from django_spire.history.querysets import HistoryQuerySet
 
+
 class HelpDeskTicketQuerySet(HistoryQuerySet):
-    pass
+    pass