Move user input's validation from services to resource/cog

bot/application/student/student_service.py

@@ -8,55 +8,26 @@
 from bot.application.discord.event.student_registered.student_registered_observable import (
     StudentRegisteredObservable,
 )
-from bot.application.student.exceptions.invalid_discord_id_format_exception import (
-    InvalidDiscordIdFormatException,
-)
-from bot.application.student.exceptions.invalid_name_format_exception import (
-    InvalidNameFormatException,
-)
-from bot.application.student.exceptions.invalid_ni_format_exception import (
-    InvalidNIFormatException,
-)
-from bot.application.student.exceptions.missing_program_code_exception import (
-    MissingProgramCodeException,
-)
 from bot.application.student.exceptions.student_already_exist import (
     StudentAlreadyExistsException,
 )
 from bot.application.student.exceptions.student_already_registered_exception import (
     StudentAlreadyRegisteredException,
 )
-from bot.application.student.validators.discord_id_validator import DiscordIdValidator
-from bot.application.student.validators.name_validator import NameValidator
-from bot.application.student.validators.ni_validator import NIValidator
-from bot.application.student.validators.program_code_validator import (
-    ProgramCodeValidator,
-)
 from bot.config.logger.logger import Logger
 from bot.config.service_locator import ServiceLocator
+from bot.domain.student.attribut.firstname import Firstname
+from bot.domain.student.attribut.lastname import Lastname
+from bot.domain.student.attribut.program_code import ProgramCode
 from bot.domain.utility import Utility
-from bot.resource.cog.registration.request.add_student_request import AddStudentRequest
-from bot.resource.cog.registration.request.force_register_student_request import (
-    ForceRegisterStudentRequest,
-)
-from bot.resource.cog.registration.request.register_student_request import (
-    RegisterStudentRequest,
-)
-from bot.resource.cog.registration.request.force_unregister_student_request import (
-    ForceUnregisterStudentRequest,
-)
 from bot.domain.student.attribut.discord_user_id import DiscordUserId
 from bot.domain.student.attribut.ni import NI
-from bot.domain.student.factory.ni_factory import NIFactory
 from bot.domain.student.factory.student_factory import StudentFactory
 from bot.domain.student.student import Student
 from bot.domain.student.student_repository import StudentRepository
 from bot.infra.student.exception.student_not_found_exception import (
     StudentNotFoundException,
 )
-from bot.resource.cog.registration.request.unregister_student_request import (
-    UnregisterStudentRequest,
-)
 from bot.resource.exception.user_not_in_server_exception import UserNotInServerException
 
 
@@ -68,13 +39,7 @@ def __init__(self, student_repository: StudentRepository):
         self.__logger: Logger = ServiceLocator.get_dependency(Logger)
         self.__student_repository = student_repository
 
-        self.__ni_validator = NIValidator()
-        self.__name_validator = NameValidator()
-        self.__discord_id_validator = DiscordIdValidator()
-        self.__program_code_validator = ProgramCodeValidator()
-
-        self.__ni_factory = NIFactory()
-        self.__student_factory = StudentFactory(self.__ni_factory)
+        self.__student_factory = StudentFactory()
 
     def __does_student_registered(self, ni: NI) -> bool:
         try:
@@ -97,28 +62,18 @@ def __does_discord_user_id_already_registered_an_account(
         )
         return len(students) >= 1
 
-    async def add_student(self, add_student_request: AddStudentRequest):
-        self.__logger.info(
-            f"Réception de la requête {repr(add_student_request)}", method="add_student"
-        )
-
-        if not self.__name_validator.validate(add_student_request.firstname):
-            raise InvalidNameFormatException(add_student_request.firstname)
-
-        if not self.__name_validator.validate(add_student_request.lastname):
-            raise InvalidNameFormatException(add_student_request.lastname)
-
-        if not self.__ni_validator.validate(add_student_request.ni):
-            raise InvalidNIFormatException(add_student_request.ni)
-
-        if not self.__program_code_validator.validate(add_student_request.program_code):
-            raise MissingProgramCodeException(add_student_request.program_code)
-
+    async def add_student(
+        self,
+        ni: NI,
+        firstname: Firstname,
+        lastname: Lastname,
+        program_code: ProgramCode,
+    ):
         student = self.__student_factory.create(
-            add_student_request.ni,
-            add_student_request.firstname,
-            add_student_request.lastname,
-            add_student_request.program_code,
+            ni,
+            firstname,
+            lastname,
+            program_code,
         )
 
         if self.__does_student_registered(student.ni):
@@ -129,108 +84,52 @@ async def add_student(self, add_student_request: AddStudentRequest):
 
         self.__student_repository.add_student(student)
 
-    async def register_student(self, register_student_request: RegisterStudentRequest):
-        self.__logger.info(
-            f"Réception de la requête {repr(register_student_request)}",
-            method="register_student",
-        )
-
-        if not self.__ni_validator.validate(register_student_request.ni):
-            raise InvalidNIFormatException(register_student_request.ni)
-
-        student_ni = self.__ni_factory.create(register_student_request.ni)
-        discord_user_id = DiscordUserId(register_student_request.discord_id)
-
-        if not self.__does_student_exists(student_ni):
+    async def register_student(self, ni: NI, discord_id: DiscordUserId):
+        if not self.__does_student_exists(ni):
             raise StudentNotFoundException()
 
         if self.__does_student_registered(
-            student_ni
-        ) or self.__does_discord_user_id_already_registered_an_account(discord_user_id):
-            raise StudentAlreadyRegisteredException(ni=student_ni)
-
-        self.__student_repository.register_student(student_ni, discord_user_id)
-        await self.notify_on_student_registered(student_ni)
-
-    async def force_register_student(
-        self, force_register_student_request: ForceRegisterStudentRequest
-    ):
-        self.__logger.info(
-            f"Réception de la requête {repr(force_register_student_request)}",
-            method="force_register_student",
-        )
-
-        if not self.__ni_validator.validate(force_register_student_request.ni):
-            raise InvalidNIFormatException(force_register_student_request.ni)
-
-        if not self.__discord_id_validator.validate(
-            force_register_student_request.discord_id
-        ):
-            raise InvalidDiscordIdFormatException(
-                force_register_student_request.discord_id
-            )
+            ni
+        ) or self.__does_discord_user_id_already_registered_an_account(discord_id):
+            raise StudentAlreadyRegisteredException(ni=ni)
 
-        if not Utility.does_user_exist_on_server(
-            force_register_student_request.discord_id
-        ):
-            raise UserNotInServerException(force_register_student_request.discord_id)
+        self.__student_repository.register_student(ni, discord_id)
+        await self.notify_on_student_registered(ni)
 
-        student_ni = self.__ni_factory.create(force_register_student_request.ni)
-        discord_user_id = DiscordUserId(force_register_student_request.discord_id)
+    async def force_register_student(self, ni: NI, discord_id: DiscordUserId):
+        if not Utility.does_user_exist_on_server(discord_id.value):
+            raise UserNotInServerException(discord_id)
 
-        if not self.__does_student_exists(student_ni):
+        if not self.__does_student_exists(ni):
             raise StudentNotFoundException()
 
         if self.__does_student_registered(
-            student_ni
-        ) or self.__does_discord_user_id_already_registered_an_account(discord_user_id):
-            raise StudentAlreadyRegisteredException(ni=student_ni)
+            ni
+        ) or self.__does_discord_user_id_already_registered_an_account(discord_id):
+            raise StudentAlreadyRegisteredException(ni=ni)
 
-        self.__student_repository.register_student(student_ni, discord_user_id)
-        await self.notify_on_student_registered(student_ni)
+        self.__student_repository.register_student(ni, discord_id)
+        await self.notify_on_student_registered(ni)
 
-    async def unregister_student(
-        self, unregister_student_request: UnregisterStudentRequest
-    ):
-        self.__logger.info(
-            f"Réception de la requête {repr(unregister_student_request)}",
-            method="unregister_student",
-        )
-
-        discord_user_id = DiscordUserId(unregister_student_request.discord_id)
-
-        if not self.__does_discord_user_id_already_registered_an_account(
-            discord_user_id
-        ):
+    async def unregister_student(self, discord_id: DiscordUserId):
+        if not self.__does_discord_user_id_already_registered_an_account(discord_id):
             raise StudentNotFoundException()
 
-        student = self.__student_repository.find_student_by_discord_user_id(
-            discord_user_id
-        )
+        student = self.__student_repository.find_student_by_discord_user_id(discord_id)
 
         self.__student_repository.unregister_student(
             student.ni, DiscordUserId(DiscordUserId.INVALID_DISCORD_ID)
         )
 
         await self.notify_on_student_unregistered(student.discord_user_id)
 
-    async def force_unregister_student(
-        self, force_unregister_student_request: ForceUnregisterStudentRequest
-    ):
-        self.__logger.info(
-            f"Réception de la requête {repr(force_unregister_student_request)}",
-            method="force_unregister_student",
-        )
-
-        if not self.__ni_validator.validate(force_unregister_student_request.ni):
-            raise InvalidNIFormatException(force_unregister_student_request.ni)
-
-        student_ni = self.__ni_factory.create(force_unregister_student_request.ni)
+    async def force_unregister_student(self, ni: NI):
 
-        student = self.__student_repository.find_student_by_ni(student_ni)
+        student = self.__student_repository.find_student_by_ni(ni)
 
         self.__student_repository.unregister_student(
-            student_ni, DiscordUserId(DiscordUserId.INVALID_DISCORD_ID)
+            ni,
+            DiscordUserId(DiscordUserId.INVALID_DISCORD_ID),
         )
 
         await self.notify_on_student_unregistered(student.discord_user_id)

bot/domain/student/factory/student_factory.py

@@ -1,29 +1,25 @@
 from bot.domain.student.attribut.discord_user_id import DiscordUserId
 from bot.domain.student.attribut.firstname import Firstname
 from bot.domain.student.attribut.lastname import Lastname
+from bot.domain.student.attribut.ni import NI
 from bot.domain.student.attribut.program_code import ProgramCode
-from bot.domain.student.factory.ni_factory import NIFactory
 from bot.domain.student.student import Student
 
 
 class StudentFactory:
 
     INVALID_DISCORD_USER_ID: int = -1
 
-    def __init__(self, ni_factory: NIFactory):
-        self.__ni_factory = ni_factory
+    def __init__(self):
+        pass
 
     def create(
         self,
-        ni: str,
-        firstname: str,
-        lastname: str,
-        program_code: str,
+        ni: NI,
+        firstname: Firstname,
+        lastname: Lastname,
+        program_code: ProgramCode,
     ) -> Student:
-        ni = self.__ni_factory.create(ni)
-        firstname = Firstname(firstname)
-        lastname = Lastname(lastname)
-        program_code = ProgramCode(program_code.upper())
         discord_user_id = DiscordUserId(self.INVALID_DISCORD_USER_ID)
 
         return Student(

bot/resource/cog/registration/factory/add_student_request_factory.py

@@ -1,5 +1,25 @@
 import re
+from typing import Tuple
 
+from bot.application.student.exceptions.invalid_name_format_exception import (
+    InvalidNameFormatException,
+)
+from bot.application.student.exceptions.invalid_ni_format_exception import (
+    InvalidNIFormatException,
+)
+from bot.application.student.exceptions.missing_program_code_exception import (
+    MissingProgramCodeException,
+)
+from bot.application.student.validators.discord_id_validator import DiscordIdValidator
+from bot.application.student.validators.name_validator import NameValidator
+from bot.application.student.validators.ni_validator import NIValidator
+from bot.application.student.validators.program_code_validator import (
+    ProgramCodeValidator,
+)
+from bot.domain.student.attribut.firstname import Firstname
+from bot.domain.student.attribut.lastname import Lastname
+from bot.domain.student.attribut.program_code import ProgramCode
+from bot.domain.student.factory.ni_factory import NIFactory
 from bot.resource.cog.registration.factory.request_factory import RequestFactory
 from bot.resource.cog.registration.request.add_student_request import AddStudentRequest
 from bot.resource.utility.sanitizer_utility import SanitizerUtility
@@ -12,14 +32,43 @@ class AddStudentRequestFactory(RequestFactory):
     def __init__(self):
         super().__init__(self.REQUIRED_ARGUMENTS)
 
+        self.__ni_validator: NIValidator = NIValidator()
+        self.__name_validator: NameValidator = NameValidator()
+        self.__discord_id_validator: DiscordIdValidator = DiscordIdValidator()
+        self.__program_code_validator: ProgramCodeValidator = ProgramCodeValidator()
+
+        self.__ni_factory: NIFactory = NIFactory()
+
     def __remove_extra_spaces(self, input_string: str) -> str:
         return re.sub(r"\s+", " ", input_string).strip()
 
+    def _validate_arguments(self, content: str) -> Tuple[any, ...] or any:
+        ni, firstname, lastname, program_code = self._get_arguments(content)
+
+        ni = SanitizerUtility.sanitize_ni(ni)
+        firstname = self.__remove_extra_spaces(firstname)
+        lastname = self.__remove_extra_spaces(lastname)
+
+        if not self.__ni_validator.validate(ni):
+            raise InvalidNIFormatException(ni)
+
+        if not self.__name_validator.validate(firstname):
+            raise InvalidNameFormatException(firstname)
+
+        if not self.__name_validator.validate(lastname):
+            raise InvalidNameFormatException(lastname)
+
+        if not self.__program_code_validator.validate(program_code):
+            raise MissingProgramCodeException(program_code)
+
+        return ni, firstname, lastname, program_code
+
     def create(self, content: str) -> AddStudentRequest:
-        ni, firstname, lastname, program = self._get_arguments(content)
+        ni, firstname, lastname, program_code = self._validate_arguments(content)
+
         return AddStudentRequest(
-            SanitizerUtility.sanitize_ni(ni),
-            self.__remove_extra_spaces(firstname),
-            self.__remove_extra_spaces(lastname),
-            program,
+            self.__ni_factory.create(ni),
+            Firstname(firstname),
+            Lastname(lastname),
+            ProgramCode(program_code.upper()),
         )