Plugg update

.devcontainer/Dockerfile

@@ -25,13 +25,17 @@ ENV TEST_REDIS_URL="redis://localhost:6379/0"
 ENV TEST_DATABASE_URL="postgresql+psycopg://postgres:password@localhost:5432/postgres_test"
 ENV USER_MANAGER_SECRET="debug_secret_dont_use_in_prod"
 ENV DOCUMENT_BASE_PATH="/workspaces/WebWebWeb/test-assets/documents"
+ENV COURSE_DOCUMENT_BASE_PATH="/workspaces/WebWebWeb/test-assets/course_documents"
 ENV ALBUM_BASE_PATH="/workspaces/WebWebWeb/test-assets/albums"
 ENV ASSETS_BASE_PATH="/workspaces/WebWebWeb/test-assets/assets"
+ENV ASSOCIATED_IMG_BASE_PATH="/workspaces/WebWebWeb/test-assets/associated_images"
 ENV MOOSE_GAME_TOKEN="sad_secret_key"
 
 RUN mkdir -p "$DOCUMENT_BASE_PATH" \
+              "$COURSE_DOCUMENT_BASE_PATH" \
              "$ALBUM_BASE_PATH" \
-             "$ASSETS_BASE_PATH"
+             "$ASSETS_BASE_PATH" \
+             "$ASSOCIATED_IMG_BASE_PATH"
 
 # In prod we must NOT run our container with root user, security risk. 
 # In the future I think we should use non-root user event in dev to make environment similar to prod

api_schemas/associated_img_schema.py

@@ -0,0 +1,15 @@
+from fastapi import UploadFile
+from api_schemas.base_schema import BaseSchema
+
+
+class AssociatedImgRead(BaseSchema):
+    associated_img_id: int
+    path: str
+
+
+class AssociatedImgCreate(BaseSchema):
+    file: UploadFile
+    program_id: int | None = None
+    program_year_id: int | None = None
+    course_id: int | None = None
+    specialisation_id: int | None = None

api_schemas/course_document_schema.py

@@ -0,0 +1,51 @@
+from typing import Annotated
+from fastapi import Form
+from pydantic import StringConstraints
+from api_schemas.base_schema import BaseSchema
+from helpers.constants import MAX_COURSE_DOC_AUTHOR, MAX_COURSE_DOC_SUB_CATEGORY, MAX_DOC_FILE_NAME, MAX_DOC_TITLE
+from helpers.types import COURSE_DOCUMENT_CATEGORIES, datetime_utc
+
+
+class CourseDocumentRead(BaseSchema):
+    course_document_id: int
+    title: str
+    file_name: str
+    course_id: int
+    created_course_code: str
+    author: str
+    category: COURSE_DOCUMENT_CATEGORIES
+    sub_category: str | None
+    created_at: datetime_utc
+    updated_at: datetime_utc
+
+
+class CourseDocumentCreate(BaseSchema):
+    title: Annotated[str, StringConstraints(max_length=MAX_DOC_TITLE)]
+    course_id: int
+    author: Annotated[str, StringConstraints(max_length=MAX_COURSE_DOC_AUTHOR)]
+    category: COURSE_DOCUMENT_CATEGORIES = "Other"
+    sub_category: Annotated[str, StringConstraints(max_length=MAX_COURSE_DOC_SUB_CATEGORY)] | None = None
+
+
+# Apparently I have to do this to be able to send JSON forms at the same time as files in the POST course document router
+def course_document_create_form(
+    title: str = Form(...),
+    course_id: int = Form(...),
+    author: str = Form(...),
+    category: COURSE_DOCUMENT_CATEGORIES = Form("Other"),
+    sub_category: str | None = Form(None),
+) -> CourseDocumentCreate:
+    return CourseDocumentCreate(
+        title=title,
+        course_id=course_id,
+        author=author,
+        category=category,
+        sub_category=sub_category,
+    )
+
+
+class CourseDocumentUpdate(BaseSchema):
+    title: Annotated[str, StringConstraints(max_length=MAX_DOC_TITLE)]
+    author: Annotated[str, StringConstraints(max_length=MAX_COURSE_DOC_AUTHOR)]
+    category: COURSE_DOCUMENT_CATEGORIES = "Other"
+    sub_category: Annotated[str, StringConstraints(max_length=MAX_COURSE_DOC_SUB_CATEGORY)] | None = None

api_schemas/course_schema.py

@@ -0,0 +1,42 @@
+from typing import Annotated
+from pydantic import StringConstraints
+from api_schemas.base_schema import BaseSchema
+from api_schemas.course_document_schema import CourseDocumentRead
+from api_schemas.program_year_schema import SimpleProgramYearRead
+from api_schemas.specialisation_schema import SimpleSpecialisationRead
+from helpers.constants import MAX_COURSE_CODE, MAX_COURSE_DESC, MAX_COURSE_TITLE
+from helpers.types import datetime_utc
+
+
+class SimpleCourseRead(BaseSchema):
+    course_id: int
+    title: str
+    course_code: str | None
+    short_identifier: str | None  # Kept so we can search for it
+
+
+class CourseRead(BaseSchema):
+    course_id: int
+    title: str
+    course_code: str | None
+    short_identifier: str | None
+    description: str | None
+    associated_img_id: int | None
+    documents: list[CourseDocumentRead] = []
+    updated_at: datetime_utc
+    program_years: list[SimpleProgramYearRead] = []
+    specialisations: list[SimpleSpecialisationRead] = []
+
+
+class CourseCreate(BaseSchema):
+    title: Annotated[str, StringConstraints(max_length=MAX_COURSE_TITLE)]
+    course_code: Annotated[str, StringConstraints(max_length=MAX_COURSE_CODE)]
+    short_identifier: Annotated[str, StringConstraints(max_length=MAX_COURSE_TITLE)] | None = None
+    description: Annotated[str, StringConstraints(max_length=MAX_COURSE_DESC)] | None = None
+
+
+class CourseUpdate(BaseSchema):
+    title: Annotated[str, StringConstraints(max_length=MAX_COURSE_TITLE)]
+    course_code: Annotated[str, StringConstraints(max_length=MAX_COURSE_CODE)]
+    short_identifier: Annotated[str, StringConstraints(max_length=MAX_COURSE_TITLE)] | None = None
+    description: Annotated[str, StringConstraints(max_length=MAX_COURSE_DESC)] | None = None

api_schemas/document_schema.py

@@ -1,5 +1,5 @@
 from typing import Annotated
-from fastapi import Form, UploadFile
+from fastapi import Form
 from pydantic import StringConstraints
 from api_schemas.base_schema import BaseSchema
 from api_schemas.user_schemas import SimpleUserRead

api_schemas/program_schema.py

@@ -0,0 +1,44 @@
+from typing import Annotated
+from pydantic import StringConstraints
+from api_schemas.base_schema import BaseSchema
+from helpers.constants import MAX_PROGRAM_DESC, MAX_PROGRAM_TITLE
+from api_schemas.program_year_schema import ProgramYearRead
+from api_schemas.course_schema import (
+    CourseRead,  # type: ignore
+)  # Needed for pydantic forward references in ProgramYearRead and SpecialisationRead
+from api_schemas.specialisation_schema import (
+    SpecialisationRead,
+)
+
+
+class SimpleProgramRead(BaseSchema):
+    program_id: int
+    title_sv: str
+    title_en: str
+
+
+class ProgramRead(BaseSchema):
+    program_id: int
+    title_sv: str
+    title_en: str
+    description_sv: str | None
+    description_en: str | None
+    associated_img_id: int | None
+    program_years: list[ProgramYearRead] = []
+    specialisations: list["SpecialisationRead"] = []
+
+
+class ProgramCreate(BaseSchema):
+    title_sv: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_TITLE)]
+    title_en: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_TITLE)]
+    description_sv: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_DESC)] | None = None
+    description_en: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_DESC)] | None = None
+    specialisation_ids: list[int] = []
+
+
+class ProgramUpdate(BaseSchema):
+    title_sv: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_TITLE)]
+    title_en: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_TITLE)]
+    description_sv: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_DESC)] | None = None
+    description_en: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_DESC)] | None = None
+    specialisation_ids: list[int] = []

api_schemas/program_year_schema.py

@@ -0,0 +1,43 @@
+from typing import Annotated, TYPE_CHECKING
+from pydantic import StringConstraints
+from api_schemas.base_schema import BaseSchema
+from helpers.constants import MAX_PROGRAM_YEAR_DESC, MAX_PROGRAM_YEAR_TITLE
+
+if TYPE_CHECKING:
+    from api_schemas.course_schema import CourseRead
+
+
+class SimpleProgramYearRead(BaseSchema):
+    program_year_id: int
+    title_sv: str
+    title_en: str
+    program_id: int
+
+
+class ProgramYearRead(BaseSchema):
+    program_year_id: int
+    title_sv: str
+    title_en: str
+    program_id: int
+    description_sv: str | None
+    description_en: str | None
+    associated_img_id: int | None
+    courses: list["CourseRead"] = []
+
+
+class ProgramYearCreate(BaseSchema):
+    title_sv: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_YEAR_TITLE)]
+    title_en: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_YEAR_TITLE)]
+    program_id: int
+    course_ids: list[int] = []
+    description_sv: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_YEAR_DESC)] | None = None
+    description_en: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_YEAR_DESC)] | None = None
+
+
+class ProgramYearUpdate(BaseSchema):
+    title_sv: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_YEAR_TITLE)]
+    title_en: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_YEAR_TITLE)]
+    program_id: int
+    course_ids: list[int] = []
+    description_sv: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_YEAR_DESC)] | None = None
+    description_en: Annotated[str, StringConstraints(max_length=MAX_PROGRAM_YEAR_DESC)] | None = None

api_schemas/specialisation_schema.py

@@ -0,0 +1,41 @@
+from typing import Annotated, TYPE_CHECKING
+from pydantic import StringConstraints
+from api_schemas.base_schema import BaseSchema
+from helpers.constants import MAX_SPECIALISATION_DESC, MAX_SPECIALISATION_TITLE
+
+if TYPE_CHECKING:
+    from api_schemas.program_schema import SimpleProgramRead
+    from api_schemas.course_schema import CourseRead
+
+
+class SimpleSpecialisationRead(BaseSchema):
+    specialisation_id: int
+    title_sv: str
+    title_en: str
+
+
+class SpecialisationRead(BaseSchema):
+    specialisation_id: int
+    title_sv: str
+    title_en: str
+    programs: list["SimpleProgramRead"] = []
+    description_sv: str | None
+    description_en: str | None
+    associated_img_id: int | None
+    courses: list["CourseRead"] = []
+
+
+class SpecialisationCreate(BaseSchema):
+    title_sv: Annotated[str, StringConstraints(max_length=MAX_SPECIALISATION_TITLE)]
+    title_en: Annotated[str, StringConstraints(max_length=MAX_SPECIALISATION_TITLE)]
+    course_ids: list[int] = []
+    description_sv: Annotated[str, StringConstraints(max_length=MAX_SPECIALISATION_DESC)] | None = None
+    description_en: Annotated[str, StringConstraints(max_length=MAX_SPECIALISATION_DESC)] | None = None
+
+
+class SpecialisationUpdate(BaseSchema):
+    title_sv: Annotated[str, StringConstraints(max_length=MAX_SPECIALISATION_TITLE)]
+    title_en: Annotated[str, StringConstraints(max_length=MAX_SPECIALISATION_TITLE)]
+    course_ids: list[int] = []
+    description_sv: Annotated[str, StringConstraints(max_length=MAX_SPECIALISATION_DESC)] | None = None
+    description_en: Annotated[str, StringConstraints(max_length=MAX_SPECIALISATION_DESC)] | None = None

db_models/associated_img_model.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy import String
+
+from helpers.constants import MAX_PATH_LENGTH
+from .base_model import BaseModel_DB
+from sqlalchemy.orm import relationship, Mapped, mapped_column
+
+if TYPE_CHECKING:
+    from .program_model import Program_DB
+    from .program_year_model import ProgramYear_DB
+    from .course_model import Course_DB
+    from .specialisation_model import Specialisation_DB
+
+
+class AssociatedImg_DB(BaseModel_DB):
+    __tablename__ = "associated_img_table"
+
+    associated_img_id: Mapped[int] = mapped_column(primary_key=True, init=False)
+
+    path: Mapped[str] = mapped_column(String(MAX_PATH_LENGTH))
+
+    program: Mapped[Optional["Program_DB"]] = relationship(back_populates="associated_img", init=False, uselist=False)
+
+    program_year: Mapped[Optional["ProgramYear_DB"]] = relationship(
+        back_populates="associated_img", init=False, uselist=False
+    )
+
+    course: Mapped[Optional["Course_DB"]] = relationship(back_populates="associated_img", init=False, uselist=False)
+
+    specialisation: Mapped[Optional["Specialisation_DB"]] = relationship(
+        back_populates="associated_img", init=False, uselist=False
+    )

db_models/course_document_model.py

@@ -0,0 +1,35 @@
+from typing import TYPE_CHECKING, Optional
+from sqlalchemy.orm import mapped_column, Mapped, relationship
+from sqlalchemy import String, ForeignKey
+
+from helpers.constants import MAX_DOC_FILE_NAME, MAX_DOC_TITLE, MAX_COURSE_DOC_AUTHOR, MAX_COURSE_DOC_SUB_CATEGORY
+from .base_model import BaseModel_DB
+from helpers.db_util import created_at_column, latest_modified_column
+from helpers.types import COURSE_DOCUMENT_CATEGORIES, datetime_utc
+
+if TYPE_CHECKING:
+    from .course_model import Course_DB
+
+
+class CourseDocument_DB(BaseModel_DB):
+    __tablename__ = "course_document_table"
+    course_document_id: Mapped[int] = mapped_column(primary_key=True, init=False)
+
+    title: Mapped[str] = mapped_column(String(MAX_DOC_TITLE), nullable=False)
+    file_name: Mapped[str] = mapped_column(String(MAX_DOC_FILE_NAME), nullable=False)
+
+    course_id: Mapped[int] = mapped_column(ForeignKey("course_table.course_id"))
+
+    course: Mapped["Course_DB"] = relationship(back_populates="documents", init=False)
+
+    created_course_code: Mapped[str] = mapped_column(String, nullable=False)
+
+    author: Mapped[str] = mapped_column(String(MAX_COURSE_DOC_AUTHOR), nullable=False)
+
+    category: Mapped[COURSE_DOCUMENT_CATEGORIES] = mapped_column(default="Other")
+
+    # Can be used to separate lecture notes from different authors or years, for example.
+    sub_category: Mapped[Optional[str]] = mapped_column(String(MAX_COURSE_DOC_SUB_CATEGORY), default=None)
+
+    created_at: Mapped[datetime_utc] = created_at_column()
+    updated_at: Mapped[datetime_utc] = latest_modified_column()