• Add new makefile included in main one "Makefile_test"
• Propose new commands test-cov, test-fast, test-lf, test-lf-pdb
• Update makefile documentation
• Include makefile documentation in README or project documentation

The actual generated documentation doesn't build and deploy.

Also documentation don't use skii package with project apps.

The mozilla MPL 2 look appropriate.

https://www.mozilla.org/en-US/MPL/2.0/FAQ/

Needs to integrate correctly that license in all the project repository and add contributor on and on README

Any opinion, advice, about license issue is welcome.
The goal is to give the most good safety for authors and contributor of this project about not fair commercial use of them software production but let them the possibility to commercialise parts, plugins, frontend, vue widget.

The license itself
https://www.mozilla.org/en-US/MPL/2.0/

Customize readme for skii school platform and add basic setup makefile commands to install/run/test and use of pycheck/quality tools.
May use isort also ?
Also illustration picture needs to be updated

• Verify the link at api creation to version
• Verify we can reverse a route without and with version
• update unittest

Have to put timezone internationalization. It's a need by the EventEntity abstract.
Actually we having:
E TypeError: can't compare offset-naive and offset-aware times
This software may be use by people from different timezone. So we need to support them and use them.

Needs automated way to update version/release in project and documentation with tagged release and package.

We will also use it for docker build

Agenda view contains actually route to fetch lesson by a teacher or student point of view.
We now needs endpoint to

• Teacher can create lesson and be assigned to
• Teacher can create lesson and assign another teacher to
• Teacher can do subscription for a student to a lesson
• Student can subscribe lesson

Split skii.platform.factories.factories in python module and permit them import by all at package init level.

Actually we mostly use guid: UUID fields to provide models primary keys.

Django provide a nice way to also manage natural FK.

The goal will be to ban id/uuid from backend/frontend data exchange, and use these natural key to create/update records.

We need an automated CI to build/run/test/quality/deploy the project

We already have 4 REST likes routes (student/teacher/location/lesson) with create/read/list/update/delete endpoints.

We want now a route to link AgendaController (actually named AgendaInterface) methods.

This AgendaController have been started here:
skii-platform-interfaces

This controller will be the main entrypoint for planning management.

This project needs Dockerfile to be builded with podman or docker.

Actual

We provide a fixtures file in skii.platform with 5 teacher and 25 students + a superuser.
They are stored on test case property:

def setUp(self) -> None:
    super().setUp()
    self.profile_to_model["student"] = StudentAgent.objects.all()
    self.profile_to_model["teacher"] = TeacherAgent.objects.all()

profile_to_model: Dict[str, Iterable[AgentEntity]] = {
    "student": [],
    "teacher": [],
}

Looks to much for most of case.

Proposition

The project use actually django factories of factoryboy package.

Import all project factory on testcase setup and provide python generator with them wrap.

The actual pycheck score is low because of pyright check. Need to adapt and check all project type.

Django ninja use for route url reverse the name of the method/view or a provided named arg on view decorateur args.

@router.get(
    path="/fetch/{pk}/",
    response={
        200: RouterContract,
        422: FormInvalidResponseContract,
    },
)
def record_read(request: HttpRequest, pk: IntStrUUID4):

In this case the reverse url of format "api_name:view_name" will be "skii:record_read"

If we have many view with record_read view function name, it's will be impossible to determine which road needs to provide the url resolver.

We need to check all endpoints and use unique name for all of them.
For our example it's will be:

@router.get(
    path="/fetch/{pk}/",
    response={
        200: RouterContract,
        422: FormInvalidResponseContract,
    },
)
def lesson_read(request: HttpRequest, pk: IntStrUUID4):

With unique route name skii:lesson_read

Code score: 45/100

• Formatting: 10/10
• Codestyle: 35/60
• Typing: 0/30

Running quality checks

Not famous :P