Initialise Backend with Certain Dedicated Features

backend/config/settings/base.py

@@ -66,6 +66,7 @@
     "django_filters",
     "commands",
     "course_evaluations",
+    "reviews",
     # Authentication
     "rest_framework",
     "rest_framework.authtoken",

backend/config/urls.py

@@ -12,6 +12,13 @@
             ),
         ),
         path("authentication/", include("authentication.urls", namespace="authentication")),
+        path(
+            "reviews/",
+            include(
+                ("reviews.urls", "reviews"),
+                namespace="reviews",
+            ),
+        ),
     ],
     "api",
 )

backend/conftest.py

@@ -6,7 +6,8 @@
 from django.core.management import call_command
 from rest_framework.test import APIClient
 
-from course_evaluations.models import CourseEvaluation, EOCSet
+from course_evaluations.models import CourseEvaluation, Document, EOCSet
+from reviews.models import Review
 
 
 @pytest.fixture
@@ -142,3 +143,84 @@ def _make_course_evaluation(
     # Teardown
     for course_evaluation in created_course_evaluation:
         course_evaluation.delete()
+
+
+@pytest.fixture
+@pytest.mark.django_db
+def make_course_evaluation_document(setup_indeaa, make_course_evaluation) -> Document:
+    """Make CourseEvaluation on demand inside tests"""
+    created_course_evaluation_document = []
+
+    # Create a CourseEvaluation record
+    def _make_course_evaluation_document(
+        course_evaluation=None,
+        name="Test CourseEvaluation Document",
+        description="Test CourseEvaluation Document",
+        url="https://systemhealthlab.com/",
+        is_introduction=False,
+        eoc_generals=[],
+        eoc_specifics=[],
+    ):
+        if course_evaluation is None:
+            course_evaluation = make_course_evaluation()
+        # Create the record
+        document = Document.objects.create(
+            name=name,
+            description=description,
+            url=url,
+            is_introduction=is_introduction,
+            course_evaluation=course_evaluation,
+        )
+
+        for eoc_general in eoc_generals:
+            document.eoc_generals.add(eoc_general)
+
+        for eoc_specific in eoc_specifics:
+            document.eoc_specifics.add(eoc_specific)
+
+        created_course_evaluation_document.append(document)
+
+        return document
+
+    # Recommended reading: https://docs.pytest.org/en/stable/fixture.html#yield-fixtures-recommended
+    yield _make_course_evaluation_document
+
+    # Teardown
+    for document in created_course_evaluation_document:
+        document.delete()
+
+
+@pytest.fixture
+@pytest.mark.django_db
+def make_course_review(setup_indeaa, make_course_evaluation, create_user) -> CourseEvaluation:
+    """Make CourseEvaluation on demand inside tests"""
+    created_course_review = []
+
+    # Create a CourseEvaluation record
+    def _make_course_review(
+        course_evaluation=None,
+        reviewer=None,
+        final_comment="Test CourseEvaluation Review",
+        date_submitted=None,
+    ):
+        if course_evaluation is None:
+            course_evaluation = make_course_evaluation()
+        if reviewer is None:
+            reviewer = create_user()
+
+        # Create the record
+        course_review = Review.objects.create(
+            course_evaluation=course_evaluation,
+            reviewer=reviewer,
+            final_comment=final_comment,
+            date_submitted=date_submitted,
+        )
+
+        return course_review
+
+    # Recommended reading: https://docs.pytest.org/en/stable/fixture.html#yield-fixtures-recommended
+    yield _make_course_review
+
+    # Teardown
+    for document in created_course_review:
+        document.delete()

backend/course_evaluations/admin.py

@@ -1,6 +1,12 @@
 from django.contrib import admin
 
-from course_evaluations.models import CourseEvaluation, EOCGeneral, EOCSet, EOCSpecific
+from course_evaluations.models import (
+    CourseEvaluation,
+    CourseEvaluationJustification,
+    EOCGeneral,
+    EOCSet,
+    EOCSpecific,
+)
 
 
 @admin.register(EOCSet)
@@ -33,12 +39,28 @@ class EOCGeneralAdmin(admin.ModelAdmin):
 
 @admin.register(EOCSpecific)
 class EOCSpecificAdmin(admin.ModelAdmin):
-    list_display = ("id", "number", "eoc_general", "get_general_and_specific_eoc", "description")
+    list_display = (
+        "id",
+        "number",
+        "eoc_general",
+        "general_and_specific_eoc",
+        "description",
+    )
     list_filter = ("eoc_general",)
     search_fields = ("id", "number", "description")
     ordering = ("number",)
 
 
+@admin.register(CourseEvaluationJustification)
+class CourseEvaluationJustificationAdmin(admin.ModelAdmin):
+    list_display = ("id", "course_evaluation", "justification")
+    list_filter = ("course_evaluation",)
+    search_fields = ("id", "justification")
+    ordering = ("id",)
+
+    filter_horizontal = ("eoc_specifics",)
+
+
 @admin.register(CourseEvaluation)
 class CourseEvaluationAdmin(admin.ModelAdmin):
     list_display = ("id", "unit_code", "description", "eoc_set")

backend/course_evaluations/migrations/0002_courseevaluationjustification.py

@@ -0,0 +1,27 @@
+# Generated by Django 3.2.13 on 2022-08-16 05:20
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("course_evaluations", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="CourseEvaluationJustification",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("justification", models.TextField(blank=True)),
+                (
+                    "development_level",
+                    models.IntegerField(choices=[(1, "Foundational"), (2, "Broad And Coherent"), (3, "Advanced"), (4, "Specialist")]),
+                ),
+                ("course_evaluation", models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to="course_evaluations.courseevaluation")),
+                ("eoc_specifics", models.ManyToManyField(related_name="justification", to="course_evaluations.EOCSpecific")),
+            ],
+        ),
+    ]

backend/course_evaluations/migrations/0003_document.py

@@ -0,0 +1,36 @@
+# Generated by Django 3.2.13 on 2022-08-18 06:53
+
+import uuid
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("course_evaluations", "0002_courseevaluationjustification"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Document",
+            fields=[
+                ("id", models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ("name", models.CharField(max_length=50)),
+                ("description", models.TextField(blank=True)),
+                ("url", models.URLField()),
+                ("is_introduction", models.BooleanField()),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "course_evaluation",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE, related_name="documents", to="course_evaluations.courseevaluation"
+                    ),
+                ),
+                ("eoc_generals", models.ManyToManyField(blank=True, to="course_evaluations.EOCGeneral")),
+                ("eoc_specifics", models.ManyToManyField(blank=True, to="course_evaluations.EOCSpecific")),
+            ],
+        ),
+    ]

backend/course_evaluations/models.py

@@ -50,9 +50,9 @@ class Meta:
     eoc_general = models.ForeignKey(EOCGeneral, on_delete=models.CASCADE)
 
     def __str__(self):
-        return f"{self.eoc_general.eoc_set.name} - {self.get_general_and_specific_eoc()}"
+        return f"{self.eoc_general.eoc_set.name} - {self.general_and_specific_eoc()}"
 
-    def get_general_and_specific_eoc(self):
+    def general_and_specific_eoc(self):
         return f"{self.eoc_general.number}.{self.number}"
 
 
@@ -72,11 +72,65 @@ class CourseEvaluation(models.Model):
     # Many-to-many Relationship with the Django User model
     # related_name: Allows to reference `CourseEvaluation` from User model
     coordinators = models.ManyToManyField("auth.User", related_name="course_evaluation_coordinator")
-
     eoc_set = models.ForeignKey(EOCSet, on_delete=models.CASCADE)
-
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
 
     def __str__(self):
         return f"{self.eoc_set.name} - {self.unit_code} ({self.created_at})"
+
+
+class DevelopmentLevels(models.IntegerChoices):
+    """
+    Foundational - Developing a foundation for university level study
+    Broad and Coherent - Sufficient capability to enter the workforce as a non-engineer
+    Advanced - Sufficient capability for professional practice as a starting engineer
+    Specialist - Selected areas of strength beyond the requirement for entering professional practice
+    """
+
+    FOUNDATIONAL = 1
+    BROAD_AND_COHERENT = 2
+    ADVANCED = 3
+    SPECIALIST = 4
+
+
+class CourseEvaluationJustification(models.Model):
+    """
+    A course coodinator must provide some written justification for how their course
+    is acheiving a variety of EOCs. It may be the case that a single written justification
+    can be used for multiple different EOC specifics.
+    """
+
+    course_evaluation = models.ForeignKey(CourseEvaluation, on_delete=models.CASCADE)
+    eoc_specifics = models.ManyToManyField(EOCSpecific, related_name="justification")
+    justification = models.TextField(null=False, blank=True)
+    development_level = models.IntegerField(choices=DevelopmentLevels.choices)
+
+    def __str__(self):
+        eoc_specifics = ", ".join([eoc_specific.general_and_specific_eoc() for eoc_specific in self.eoc_specifics.all()])
+        return f"Course Evaluation Justification ({self.course_evaluation.unit_code}) - {eoc_specifics}"
+
+
+class Document(models.Model):
+    """
+    A document is a url to a resource that a reviewer will look at
+    to judge the quality of a course
+    """
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+
+    # Main relations
+    course_evaluation = models.ForeignKey(CourseEvaluation, on_delete=models.CASCADE, related_name="documents")
+
+    # Information about the document
+    name = models.CharField(max_length=50, null=False, blank=False)
+    description = models.TextField(null=False, blank=True)
+    url = models.URLField()
+
+    # Tags Equivalence
+    is_introduction = models.BooleanField()
+    eoc_generals = models.ManyToManyField(EOCGeneral, blank=True)
+    eoc_specifics = models.ManyToManyField(EOCSpecific, blank=True)
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)

backend/course_evaluations/permissions.py

@@ -1,14 +1,30 @@
 from rest_framework import permissions
 
 
-class IsCoordinatorAllowAll(permissions.BasePermission):
+class CourseEvaluationIsCoordinatorAllowAll(permissions.BasePermission):
     """
     Custom permission to only allow coordinators the API
     """
 
     def has_object_permission(self, request, view, obj):
         """
         A coordinator should be allowed to perform any operation
-        """
 
+        Note: This only applies for methods that calls `.get_object()`
+        see https://stackoverflow.com/questions/69959797/has-object-permission-not-working-for-detail-action-decorator
+        """
         return request.user in obj.coordinators.all()
+
+
+class CourseEvaluationIsCoordinatorAllowAllViaObjectReference(permissions.BasePermission):
+    """
+    Custom permission to only allow coordinators the API based on the query parameters in the URL
+    """
+
+    def has_permission(self, request, view):
+        course_evaluation_id = view.kwargs["course_evaluation_id"]
+
+        # Check whether the user has a course_evaluation that is desired
+        course_evaluations = request.user.course_evaluation_coordinator.all()
+        if course_evaluations.filter(id=course_evaluation_id).exists():
+            return True