Merge pull request #19 from SADiLaR/feature/docs-upload-admin

Feature/docs upload admin

Author: daniel-gray-tangent

.gitignore

@@ -31,3 +31,4 @@ ENV/
 env.bak/
 venv.bak/
 app/static_files/
+/app/documents/

app/app/urls.py

@@ -15,6 +15,8 @@
     2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
 """
 
+from django.conf import settings
+from django.conf.urls.static import static
 from django.contrib import admin
 from django.urls import path
 
@@ -34,3 +36,6 @@
 handler403 = "app.views.error_403"
 handler404 = "app.views.error_404"
 handler500 = "app.views.error_500"
+
+if settings.DEBUG:
+    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

app/general/admin.py

@@ -1,13 +1,57 @@
+import mimetypes
+
 from django.contrib import admin
+from django.forms import ModelForm, fields_for_model
 
-from .models import Institution, Language, Project, Subject
+from .models import DocumentFile, Institution, Language, Project, Subject
 
 
 class ProjectAdminInline(admin.TabularInline):
     model = Project
     extra = 0
 
 
+class DocumentFileForm(ModelForm):
+    class Meta:
+        model = DocumentFile
+        fields = fields_for_model(DocumentFile)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["mime_type"].widget.attrs["disabled"] = True
+
+    def clean(self):
+        cleaned_data = super().clean()
+        url = cleaned_data.get("url", "")
+        uploaded_file = cleaned_data.get("uploaded_file", "")
+
+        if cleaned_data["mime_type"] is not None:
+            cleaned_data["mime_type"] = (
+                mimetypes.guess_type(uploaded_file.name)[0] if uploaded_file else ""
+            )
+
+        if not url and not uploaded_file:
+            self.add_error("url", "Either URL or uploaded file must be provided.")
+            self.add_error("uploaded_file", "Either URL or uploaded file must be provided.")
+
+        if uploaded_file:
+            limit = 10 * 1024 * 1024
+            if uploaded_file.size and uploaded_file.size > limit:
+                self.add_error("uploaded_file", "File size must not exceed 10MB.")
+
+        return cleaned_data
+
+
+class DocumentFileAdmin(admin.ModelAdmin):
+    list_display = ["title", "license", "document_type", "available"]
+    ordering = [
+        "license",
+    ]
+    search_fields = ["title", "license", "document_type"]
+
+    form = DocumentFileForm
+
+
 class ProjectAdmin(admin.ModelAdmin):
     inlines = [ProjectAdminInline]
 
@@ -16,3 +60,4 @@ class ProjectAdmin(admin.ModelAdmin):
 admin.site.register(Institution, ProjectAdmin)
 admin.site.register(Language)
 admin.site.register(Subject)
+admin.site.register(DocumentFile, DocumentFileAdmin)

app/general/migrations/0002_documentfile.py

@@ -0,0 +1,29 @@
+import django.core.validators
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('general', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='DocumentFile',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('title', models.CharField(max_length=200)),
+                ('url', models.URLField(blank=True)),
+                ('uploaded_file', models.FileField(blank=True, help_text='Only PDF files are allowed.', upload_to='documents/', validators=[django.core.validators.FileExtensionValidator(['pdf'])])),
+                ('available', models.BooleanField(default=True)),
+                ('license', models.CharField(choices=[('MIT', 'MIT'), ('GNU', 'GNU'), ('Apache', 'Apache')], max_length=200)),
+                ('mime_type', models.CharField(blank=True, help_text='This input will auto-populate.', max_length=200)),
+                ('document_type', models.CharField(choices=[('Glossary', 'Glossary'), ('Translation', 'Translation')], max_length=200)),
+                ('Institution', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='general.institution')),
+                ('languages', models.ManyToManyField(blank=True, to='general.language')),
+                ('subjects', models.ManyToManyField(blank=True, to='general.subject')),
+            ],
+        ),
+    ]

app/general/models.py

@@ -1,3 +1,4 @@
+from django.core.validators import FileExtensionValidator
 from django.db import models
 
 
@@ -43,3 +44,33 @@ class Subject(models.Model):
 
     def __str__(self):
         return self.name
+
+
+class DocumentFile(models.Model):
+    file_validators = [FileExtensionValidator(["pdf"])]
+
+    license_choices = [("MIT", "MIT"), ("GNU", "GNU"), ("Apache", "Apache")]
+    document_type_choices = [("Glossary", "Glossary"), ("Translation", "Translation")]
+
+    file_type = "pdf"
+
+    title = models.CharField(max_length=200)
+    url = models.URLField(max_length=200, blank=True)
+    uploaded_file = models.FileField(
+        upload_to="documents/",
+        validators=file_validators,
+        blank=True,
+        help_text="Only PDF files are allowed.",
+    )
+    available = models.BooleanField(default=True)
+    license = models.CharField(max_length=200, choices=license_choices)
+    mime_type = models.CharField(
+        max_length=200, blank=True, help_text="This input will auto-populate."
+    )
+    document_type = models.CharField(max_length=200, choices=document_type_choices)
+    Institution = models.ForeignKey("Institution", on_delete=models.CASCADE)
+    subjects = models.ManyToManyField("Subject", blank=True)
+    languages = models.ManyToManyField("Language", blank=True)
+
+    def __str__(self):
+        return self.title

app/general/tests/test_document_admin_file.py

@@ -0,0 +1,83 @@
+import unittest
+from unittest.mock import Mock
+
+from django.core.files.uploadedfile import SimpleUploadedFile
+
+from general.admin import DocumentFileForm
+from general.models import Institution
+
+
+class TestDocumentFileForm(unittest.TestCase):
+    def setUp(self):
+        self.file_mock = Mock(spec=SimpleUploadedFile)
+        self.file_mock.name = "test.pdf"
+        self.file_mock.size = 5242880
+
+    def test_clean_without_url_and_file(self):
+        tests_form = {
+            "title": "Test",
+            "license": "MIT",
+            "document_type": "Glossary",
+            "mime_type": "pdf",
+            "Institution": Institution.objects.create(name="Test Institution"),
+            "url": "",
+            "uploaded_file": "",
+        }
+
+        form = DocumentFileForm(tests_form)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form.errors["url"], ["Either URL or uploaded file must be provided."])
+        self.assertEqual(
+            form.errors["uploaded_file"], ["Either URL or uploaded file must be provided."]
+        )
+
+    def test_clean_without_file(self):
+        tests_form = {
+            "title": "Test",
+            "license": "MIT",
+            "document_type": "Glossary",
+            "mime_type": "pdf",
+            "Institution": Institution.objects.create(name="Test Institution 2"),
+            "url": "www.example.com",
+            "uploaded_file": "",
+        }
+
+        form = DocumentFileForm(tests_form)
+        self.assertTrue(form.is_valid())
+
+    def test_clean_without_url(self):
+        tests_form = {
+            "title": "Test",
+            "license": "MIT",
+            "document_type": "Glossary",
+            "mime_type": "pdf",
+            "Institution": Institution.objects.create(name="Test Institution 3"),
+            "url": "",
+            "uploaded_file": self.file_mock,
+        }
+
+        form = DocumentFileForm(tests_form, files={"uploaded_file": self.file_mock})
+
+        self.assertTrue(form.is_valid())
+
+    def test_clean_with_large_file(self):
+        self.file_mock.size = 15728640
+
+        tests_form = {
+            "title": "Test",
+            "license": "MIT",
+            "document_type": "Glossary",
+            "mime_type": "pdf",
+            "Institution": Institution.objects.create(name="Test Institution 4"),
+            "url": "",
+            "uploaded_file": self.file_mock,
+        }
+
+        form = DocumentFileForm(tests_form, files={"uploaded_file": self.file_mock})
+        self.assertFalse(form.is_valid())
+        self.assertIn("uploaded_file", form.errors)
+        self.assertEqual(form.errors["uploaded_file"], ["File size must not exceed 10MB."])
+
+
+if __name__ == "__main__":
+    unittest.main()

app/general/tests/test_document_file.py

@@ -0,0 +1,53 @@
+import unittest
+
+from django.core.files.uploadedfile import SimpleUploadedFile
+from django.test import TestCase
+
+from general.models import DocumentFile, Institution, Language, Subject
+
+
+class DocumentFileTest(TestCase):
+    def setUp(self):
+        self.subject = Subject.objects.create(name="Test Subject")
+        self.language = Language.objects.create(name="Test Language", iso_code="TL")
+        self.institution = Institution.objects.create(name="Test Institution")
+
+        self.title = "Some document"
+        self.url = "https://example.com"
+        self.uploaded_file = SimpleUploadedFile(
+            "example.pdf", b"file_content", content_type="application/pdf"
+        )
+        self.license = "MIT"
+        self.mime_type = "pdf"
+        self.document_type = "Glossary"
+        self.institution = self.institution
+
+        self.document = DocumentFile.objects.create(
+            title=self.title,
+            url=self.url,
+            uploaded_file=self.uploaded_file,
+            license=self.license,
+            mime_type=self.mime_type,
+            document_type=self.document_type,
+            Institution=self.institution,
+        )
+        self.document.subjects.add(self.subject)
+        self.document.languages.add(self.language)
+
+    def test_document_creation(self):
+        self.assertEqual(DocumentFile.objects.count(), 1)
+        self.assertEqual(DocumentFile.objects.get().title, self.title)
+
+    def test_document_str_representation(self):  # Test __str__ method
+        self.assertEqual(str(self.document), self.title)
+
+    def test_document_available_by_default(self):  # Test default value
+        self.assertTrue(self.document.available)
+
+    def tearDown(self):
+        if self.document.uploaded_file:
+            self.document.uploaded_file.delete()
+
+
+if __name__ == "__main__":
+    unittest.main()