maleo-identity 0.0.28__py3-none-any.whl → 0.0.30__py3-none-any.whl

maleo_identity/client/services/user.py

@@ -3,25 +3,45 @@ from maleo_foundation.managers.client.base import ClientService
 from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_identity.client.controllers import MaleoIdentityUserControllers
 from maleo_identity.enums.general import MaleoIdentityGeneralEnums
-from maleo_identity.models.transfers.parameters.general.user import MaleoIdentityUserGeneralParametersTransfers
-from maleo_identity.models.transfers.parameters.general.user_organization import MaleoIdentityUserOrganizationGeneralParametersTransfers
-from maleo_identity.models.transfers.parameters.general.user_system_role import MaleoIdentityUserSystemRoleGeneralParametersTransfers
-from maleo_identity.models.transfers.parameters.general.user_organization_role import MaleoIdentityUserOrganizationRoleGeneralParametersTransfers
-from maleo_identity.models.transfers.parameters.client.user import MaleoIdentityUserClientParametersTransfers
-from maleo_identity.models.transfers.parameters.client.user_organization import MaleoIdentityUserOrganizationClientParametersTransfers
-from maleo_identity.models.transfers.parameters.client.user_system_role import MaleoIdentityUserSystemRoleClientParametersTransfers
-from maleo_identity.models.transfers.parameters.client.user_organization_role import MaleoIdentityUserOrganizationRoleClientParametersTransfers
-from maleo_identity.models.transfers.results.client.user import MaleoIdentityUserClientResultsTransfers
-from maleo_identity.models.transfers.results.client.user_organization import MaleoIdentityUserOrganizationClientResultsTransfers
-from maleo_identity.models.transfers.results.client.user_system_role import MaleoIdentityUserSystemRoleClientResultsTransfers
-from maleo_identity.models.transfers.results.client.user_organization_role import MaleoIdentityUserOrganizationRoleClientResultsTransfers
-from maleo_identity.types.results.client.user import MaleoIdentityUserClientResultsTypes
-from maleo_identity.types.results.client.user_organization import MaleoIdentityUserOrganizationClientResultsTypes
-from maleo_identity.types.results.client.user_system_role import MaleoIdentityUserSystemRoleClientResultsTypes
-from maleo_identity.types.results.client.user_organization_role import MaleoIdentityUserOrganizationRoleClientResultsTypes
+from maleo_identity.models.transfers.parameters.general.user \
+    import MaleoIdentityUserGeneralParametersTransfers
+from maleo_identity.models.transfers.parameters.general.user_organization \
+    import MaleoIdentityUserOrganizationGeneralParametersTransfers
+from maleo_identity.models.transfers.parameters.general.user_system_role \
+    import MaleoIdentityUserSystemRoleGeneralParametersTransfers
+from maleo_identity.models.transfers.parameters.general.user_organization_role \
+    import MaleoIdentityUserOrganizationRoleGeneralParametersTransfers
+from maleo_identity.models.transfers.parameters.client.user \
+    import MaleoIdentityUserClientParametersTransfers
+from maleo_identity.models.transfers.parameters.client.user_organization \
+    import MaleoIdentityUserOrganizationClientParametersTransfers
+from maleo_identity.models.transfers.parameters.client.user_system_role \
+    import MaleoIdentityUserSystemRoleClientParametersTransfers
+from maleo_identity.models.transfers.parameters.client.user_organization_role \
+    import MaleoIdentityUserOrganizationRoleClientParametersTransfers
+from maleo_identity.models.transfers.results.client.user \
+    import MaleoIdentityUserClientResultsTransfers
+from maleo_identity.models.transfers.results.client.user_organization \
+    import MaleoIdentityUserOrganizationClientResultsTransfers
+from maleo_identity.models.transfers.results.client.user_system_role \
+    import MaleoIdentityUserSystemRoleClientResultsTransfers
+from maleo_identity.models.transfers.results.client.user_organization_role \
+    import MaleoIdentityUserOrganizationRoleClientResultsTransfers
+from maleo_identity.types.results.client.user \
+    import MaleoIdentityUserClientResultsTypes
+from maleo_identity.types.results.client.user_organization \
+    import MaleoIdentityUserOrganizationClientResultsTypes
+from maleo_identity.types.results.client.user_system_role \
+    import MaleoIdentityUserSystemRoleClientResultsTypes
+from maleo_identity.types.results.client.user_organization_role \
+    import MaleoIdentityUserOrganizationRoleClientResultsTypes
 
 class MaleoIdentityUserClientService(ClientService):
-    def __init__(self, logger, controllers:MaleoIdentityUserControllers):
+    def __init__(
+        self,
+        logger,
+        controllers:MaleoIdentityUserControllers
+    ):
         super().__init__(logger)
         self._controllers = controllers
 
@@ -42,25 +62,49 @@ class MaleoIdentityUserClientService(ClientService):
         )
         async def _impl():
             #* Validate chosen controller type
-            if not isinstance(controller_type, MaleoIdentityGeneralEnums.ClientControllerType):
+            if not isinstance(
+                controller_type,
+                MaleoIdentityGeneralEnums.ClientControllerType
+            ):
                 message = "Invalid controller type"
                 description = "The provided controller type did not exists"
-                return MaleoIdentityUserClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Retrieve users using chosen controller
             if controller_type == MaleoIdentityGeneralEnums.ClientControllerType.HTTP:
-                controller_result = await self._controllers.http.get_users(parameters=parameters)
+                controller_result = (
+                    await self._controllers.http
+                    .get_users(parameters=parameters)
+                )
             else:
                 message = "Invalid controller type"
                 description = "The provided controller type has not been implemented"
-                return MaleoIdentityUserClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Return proper response
             if not controller_result.success:
-                return MaleoIdentityUserClientResultsTransfers.Fail.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserClientResultsTransfers
+                    .Fail
+                    .model_validate(controller_result.content)
+                )
             else:
                 if controller_result.content["data"] is None:
-                    return MaleoIdentityUserClientResultsTransfers.NoData.model_validate(controller_result.content)
+                    return (
+                        MaleoIdentityUserClientResultsTransfers
+                        .NoData
+                        .model_validate(controller_result.content)
+                    )
                 else:
-                    return MaleoIdentityUserClientResultsTransfers.MultipleData.model_validate(controller_result.content)
+                    return (
+                        MaleoIdentityUserClientResultsTransfers
+                        .MultipleData
+                        .model_validate(controller_result.content)
+                    )
         return await _impl()
 
     async def get_user(
@@ -76,22 +120,42 @@ class MaleoIdentityUserClientService(ClientService):
         )
         async def _impl():
             #* Validate chosen controller type
-            if not isinstance(controller_type, MaleoIdentityGeneralEnums.ClientControllerType):
+            if not isinstance(
+                controller_type,
+                MaleoIdentityGeneralEnums.ClientControllerType
+            ):
                 message = "Invalid controller type"
                 description = "The provided controller type did not exists"
-                return MaleoIdentityUserClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Retrieve user using chosen controller
             if controller_type == MaleoIdentityGeneralEnums.ClientControllerType.HTTP:
-                controller_result = await self._controllers.http.get_user(parameters=parameters)
+                controller_result = (
+                    await self._controllers.http
+                    .get_user(parameters=parameters)
+                )
             else:
                 message = "Invalid controller type"
                 description = "The provided controller type has not been implemented"
-                return MaleoIdentityUserClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Return proper response
             if not controller_result.success:
-                return MaleoIdentityUserClientResultsTransfers.Fail.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserClientResultsTransfers
+                    .Fail
+                    .model_validate(controller_result.content)
+                )
             else:
-                return MaleoIdentityUserClientResultsTransfers.SingleData.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserClientResultsTransfers
+                    .SingleData
+                    .model_validate(controller_result.content)
+                )
         return await _impl()
 
     async def create(
@@ -107,22 +171,42 @@ class MaleoIdentityUserClientService(ClientService):
         )
         async def _impl():
             #* Validate chosen controller type
-            if not isinstance(controller_type, MaleoIdentityGeneralEnums.ClientControllerType):
+            if not isinstance(
+                controller_type,
+                MaleoIdentityGeneralEnums.ClientControllerType
+            ):
                 message = "Invalid controller type"
                 description = "The provided controller type did not exists"
-                return MaleoIdentityUserClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Create a new user using chosen controller
             if controller_type == MaleoIdentityGeneralEnums.ClientControllerType.HTTP:
-                controller_result = await self._controllers.http.create(parameters=parameters)
+                controller_result = (
+                    await self._controllers.http
+                    .create(parameters=parameters)
+                )
             else:
                 message = "Invalid controller type"
                 description = "The provided controller type has not been implemented"
-                return MaleoIdentityUserClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Return proper response
             if not controller_result.success:
-                return MaleoIdentityUserClientResultsTransfers.Fail.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserClientResultsTransfers
+                    .Fail
+                    .model_validate(controller_result.content)
+                )
             else:
-                return MaleoIdentityUserClientResultsTransfers.SingleData.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserClientResultsTransfers
+                    .SingleData
+                    .model_validate(controller_result.content)
+                )
         return await _impl()
 
     async def update(
@@ -138,22 +222,42 @@ class MaleoIdentityUserClientService(ClientService):
         )
         async def _impl():
             #* Validate chosen controller type
-            if not isinstance(controller_type, MaleoIdentityGeneralEnums.ClientControllerType):
+            if not isinstance(
+                controller_type,
+                MaleoIdentityGeneralEnums.ClientControllerType
+            ):
                 message = "Invalid controller type"
                 description = "The provided controller type did not exists"
-                return MaleoIdentityUserClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Update user's data using chosen controller
             if controller_type == MaleoIdentityGeneralEnums.ClientControllerType.HTTP:
-                controller_result = await self._controllers.http.update(parameters=parameters)
+                controller_result = (
+                    await self._controllers.http
+                    .update(parameters=parameters)
+                )
             else:
                 message = "Invalid controller type"
                 description = "The provided controller type has not been implemented"
-                return MaleoIdentityUserClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Return proper response
             if not controller_result.success:
-                return MaleoIdentityUserClientResultsTransfers.Fail.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserClientResultsTransfers
+                    .Fail
+                    .model_validate(controller_result.content)
+                )
             else:
-                return MaleoIdentityUserClientResultsTransfers.SingleData.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserClientResultsTransfers
+                    .SingleData
+                    .model_validate(controller_result.content)
+                )
         return await _impl()
 
     async def get_password(
@@ -169,22 +273,42 @@ class MaleoIdentityUserClientService(ClientService):
         )
         async def _impl():
             #* Validate chosen controller type
-            if not isinstance(controller_type, MaleoIdentityGeneralEnums.ClientControllerType):
+            if not isinstance(
+                controller_type,
+                MaleoIdentityGeneralEnums.ClientControllerType
+            ):
                 message = "Invalid controller type"
                 description = "The provided controller type did not exists"
-                return MaleoIdentityUserClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Retrieve user's password using chosen controller
             if controller_type == MaleoIdentityGeneralEnums.ClientControllerType.HTTP:
-                controller_result = await self._controllers.http.get_password(parameters=parameters)
+                controller_result = (
+                    await self._controllers.http
+                    .get_password(parameters=parameters)
+                )
             else:
                 message = "Invalid controller type"
                 description = "The provided controller type has not been implemented"
-                return MaleoIdentityUserClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Return proper response
             if not controller_result.success:
-                return MaleoIdentityUserClientResultsTransfers.Fail.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserClientResultsTransfers
+                    .Fail
+                    .model_validate(controller_result.content)
+                )
             else:
-                return MaleoIdentityUserClientResultsTransfers.SinglePassword.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserClientResultsTransfers
+                    .SinglePassword
+                    .model_validate(controller_result.content)
+                )
         return await _impl()
 
     async def get_user_organizations(
@@ -200,25 +324,49 @@ class MaleoIdentityUserClientService(ClientService):
         )
         async def _impl():
             #* Validate chosen controller type
-            if not isinstance(controller_type, MaleoIdentityGeneralEnums.ClientControllerType):
+            if not isinstance(
+                controller_type,
+                MaleoIdentityGeneralEnums.ClientControllerType
+            ):
                 message = "Invalid controller type"
                 description = "The provided controller type did not exists"
-                return MaleoIdentityUserOrganizationClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserOrganizationClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Retrieve user's organizations using chosen controller
             if controller_type == MaleoIdentityGeneralEnums.ClientControllerType.HTTP:
-                controller_result = await self._controllers.http.get_user_organizations(parameters=parameters)
+                controller_result = (
+                    await self._controllers.http
+                    .get_user_organizations(parameters=parameters)
+                )
             else:
                 message = "Invalid controller type"
                 description = "The provided controller type has not been implemented"
-                return MaleoIdentityUserOrganizationClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserOrganizationClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Return proper response
             if not controller_result.success:
-                return MaleoIdentityUserOrganizationClientResultsTransfers.Fail.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserOrganizationClientResultsTransfers
+                    .Fail
+                    .model_validate(controller_result.content)
+                )
             else:
                 if controller_result.content["data"] is None:
-                    return MaleoIdentityUserOrganizationClientResultsTransfers.NoData.model_validate(controller_result.content)
+                    return (
+                        MaleoIdentityUserOrganizationClientResultsTransfers
+                        .NoData
+                        .model_validate(controller_result.content)
+                    )
                 else:
-                    return MaleoIdentityUserOrganizationClientResultsTransfers.MultipleData.model_validate(controller_result.content)
+                    return (
+                        MaleoIdentityUserOrganizationClientResultsTransfers
+                        .MultipleData.
+                        model_validate(controller_result.content)
+                    )
         return await _impl()
 
     async def get_user_organization(
@@ -234,22 +382,42 @@ class MaleoIdentityUserClientService(ClientService):
         )
         async def _impl():
             #* Validate chosen controller type
-            if not isinstance(controller_type, MaleoIdentityGeneralEnums.ClientControllerType):
+            if not isinstance(
+                controller_type,
+                MaleoIdentityGeneralEnums.ClientControllerType
+            ):
                 message = "Invalid controller type"
                 description = "The provided controller type did not exists"
-                return MaleoIdentityUserOrganizationClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserOrganizationClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Retrieve user's organization using chosen controller
             if controller_type == MaleoIdentityGeneralEnums.ClientControllerType.HTTP:
-                controller_result = await self._controllers.http.get_user_organization(parameters=parameters)
+                controller_result = (
+                    await self._controllers.http
+                    .get_user_organization(parameters=parameters)
+                )
             else:
                 message = "Invalid controller type"
                 description = "The provided controller type has not been implemented"
-                return MaleoIdentityUserOrganizationClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserOrganizationClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Return proper response
             if not controller_result.success:
-                return MaleoIdentityUserOrganizationClientResultsTransfers.Fail.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserOrganizationClientResultsTransfers
+                    .Fail
+                    .model_validate(controller_result.content)
+                )
             else:
-                return MaleoIdentityUserOrganizationClientResultsTransfers.SingleData.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserOrganizationClientResultsTransfers
+                    .SingleData
+                    .model_validate(controller_result.content)
+                )
         return await _impl()
 
     async def get_user_system_roles(
@@ -265,25 +433,49 @@ class MaleoIdentityUserClientService(ClientService):
         )
         async def _impl():
             #* Validate chosen controller type
-            if not isinstance(controller_type, MaleoIdentityGeneralEnums.ClientControllerType):
+            if not isinstance(
+                controller_type,
+                MaleoIdentityGeneralEnums.ClientControllerType
+            ):
                 message = "Invalid controller type"
                 description = "The provided controller type did not exists"
-                return MaleoIdentityUserSystemRoleClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserSystemRoleClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Retrieve user's system roles using chosen controller
             if controller_type == MaleoIdentityGeneralEnums.ClientControllerType.HTTP:
-                controller_result = await self._controllers.http.get_user_system_roles(parameters=parameters)
+                controller_result = (
+                    await self._controllers.http
+                    .get_user_system_roles(parameters=parameters)
+                )
             else:
                 message = "Invalid controller type"
                 description = "The provided controller type has not been implemented"
-                return MaleoIdentityUserSystemRoleClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserSystemRoleClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Return proper response
             if not controller_result.success:
-                return MaleoIdentityUserSystemRoleClientResultsTransfers.Fail.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserSystemRoleClientResultsTransfers
+                    .Fail
+                    .model_validate(controller_result.content)
+                )
             else:
                 if controller_result.content["data"] is None:
-                    return MaleoIdentityUserSystemRoleClientResultsTransfers.NoData.model_validate(controller_result.content)
+                    return (
+                        MaleoIdentityUserSystemRoleClientResultsTransfers
+                        .NoData
+                        .model_validate(controller_result.content)
+                    )
                 else:
-                    return MaleoIdentityUserSystemRoleClientResultsTransfers.MultipleData.model_validate(controller_result.content)
+                    return (
+                        MaleoIdentityUserSystemRoleClientResultsTransfers
+                        .MultipleData
+                        .model_validate(controller_result.content)
+                    )
         return await _impl()
 
     async def get_user_system_role(
@@ -299,22 +491,41 @@ class MaleoIdentityUserClientService(ClientService):
         )
         async def _impl():
             #* Validate chosen controller type
-            if not isinstance(controller_type, MaleoIdentityGeneralEnums.ClientControllerType):
+            if not isinstance(
+                controller_type,
+                MaleoIdentityGeneralEnums.ClientControllerType):
                 message = "Invalid controller type"
                 description = "The provided controller type did not exists"
-                return MaleoIdentityUserSystemRoleClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserSystemRoleClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Retrieve user's system role using chosen controller
             if controller_type == MaleoIdentityGeneralEnums.ClientControllerType.HTTP:
-                controller_result = await self._controllers.http.get_user_system_role(parameters=parameters)
+                controller_result = (
+                    await self._controllers.http
+                    .get_user_system_role(parameters=parameters)
+                )
             else:
                 message = "Invalid controller type"
                 description = "The provided controller type has not been implemented"
-                return MaleoIdentityUserSystemRoleClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserSystemRoleClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Return proper response
             if not controller_result.success:
-                return MaleoIdentityUserSystemRoleClientResultsTransfers.Fail.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserSystemRoleClientResultsTransfers
+                    .Fail
+                    .model_validate(controller_result.content)
+                )
             else:
-                return MaleoIdentityUserSystemRoleClientResultsTransfers.SingleData.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserSystemRoleClientResultsTransfers
+                    .SingleData
+                    .model_validate(controller_result.content)
+                )
         return await _impl()
 
     async def get_user_organization_roles(
@@ -330,25 +541,49 @@ class MaleoIdentityUserClientService(ClientService):
         )
         async def _impl():
             #* Validate chosen controller type
-            if not isinstance(controller_type, MaleoIdentityGeneralEnums.ClientControllerType):
+            if not isinstance(
+                controller_type,
+                MaleoIdentityGeneralEnums.ClientControllerType
+            ):
                 message = "Invalid controller type"
                 description = "The provided controller type did not exists"
-                return MaleoIdentityUserOrganizationRoleClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserOrganizationRoleClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Retrieve user's organization roles using chosen controller
             if controller_type == MaleoIdentityGeneralEnums.ClientControllerType.HTTP:
-                controller_result = await self._controllers.http.get_user_organization_roles(parameters=parameters)
+                controller_result = (
+                    await self._controllers.http
+                    .get_user_organization_roles(parameters=parameters)
+                )
             else:
                 message = "Invalid controller type"
                 description = "The provided controller type has not been implemented"
-                return MaleoIdentityUserOrganizationRoleClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserOrganizationRoleClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Return proper response
             if not controller_result.success:
-                return MaleoIdentityUserOrganizationRoleClientResultsTransfers.Fail.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserOrganizationRoleClientResultsTransfers
+                    .Fail
+                    .model_validate(controller_result.content)
+                )
             else:
                 if controller_result.content["data"] is None:
-                    return MaleoIdentityUserOrganizationRoleClientResultsTransfers.NoData.model_validate(controller_result.content)
+                    return (
+                        MaleoIdentityUserOrganizationRoleClientResultsTransfers
+                        .NoData
+                        .model_validate(controller_result.content)
+                    )
                 else:
-                    return MaleoIdentityUserOrganizationRoleClientResultsTransfers.MultipleData.model_validate(controller_result.content)
+                    return (
+                        MaleoIdentityUserOrganizationRoleClientResultsTransfers
+                        .MultipleData
+                        .model_validate(controller_result.content)
+                    )
         return await _impl()
 
     async def get_user_organization_role(
@@ -364,20 +599,40 @@ class MaleoIdentityUserClientService(ClientService):
         )
         async def _impl():
             #* Validate chosen controller type
-            if not isinstance(controller_type, MaleoIdentityGeneralEnums.ClientControllerType):
+            if not isinstance(
+                controller_type,
+                MaleoIdentityGeneralEnums.ClientControllerType
+            ):
                 message = "Invalid controller type"
                 description = "The provided controller type did not exists"
-                return MaleoIdentityUserOrganizationRoleClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserOrganizationRoleClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Retrieve user's organization role using chosen controller
             if controller_type == MaleoIdentityGeneralEnums.ClientControllerType.HTTP:
-                controller_result = await self._controllers.http.get_user_organization_role(parameters=parameters)
+                controller_result = (
+                    await self._controllers.http
+                    .get_user_organization_role(parameters=parameters)
+                )
             else:
                 message = "Invalid controller type"
                 description = "The provided controller type has not been implemented"
-                return MaleoIdentityUserOrganizationRoleClientResultsTransfers.Fail(message=message, description=description)
+                return MaleoIdentityUserOrganizationRoleClientResultsTransfers.Fail(
+                    message=message,
+                    description=description
+                )
             #* Return proper response
             if not controller_result.success:
-                return MaleoIdentityUserOrganizationRoleClientResultsTransfers.Fail.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserOrganizationRoleClientResultsTransfers
+                    .Fail
+                    .model_validate(controller_result.content)
+                )
             else:
-                return MaleoIdentityUserOrganizationRoleClientResultsTransfers.SingleData.model_validate(controller_result.content)
+                return (
+                    MaleoIdentityUserOrganizationRoleClientResultsTransfers
+                    .SingleData
+                    .model_validate(controller_result.content)
+                )
         return await _impl()

maleo_identity/models/schemas/general/user.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel, Field
 from typing import Optional, List
+from maleo_foundation.types import BaseTypes
 from maleo_identity.enums.user import MaleoIdentityUserEnums
 
 class MaleoIdentityUserGeneralSchemas:
@@ -12,11 +13,20 @@ class MaleoIdentityUserGeneralSchemas:
     class Username(BaseModel):
         username:str = Field(..., max_length=50, description="User's username")
 
+    class Usernames(BaseModel):
+        usernames:BaseTypes.OptionalListOfStrings = Field(None, description="Specific usernames")
+
     class Email(BaseModel):
         email:str = Field(..., max_length=255, description="User's email")
 
+    class Emails(BaseModel):
+        emails:BaseTypes.OptionalListOfStrings = Field(None, description="Specific emails")
+
     class Phone(BaseModel):
         phone:str = Field(..., max_length=15, description="User's username")
 
+    class Phones(BaseModel):
+        phones:BaseTypes.OptionalListOfStrings = Field(None, description="Specific phones")
+
     class Password(BaseModel):
         password:str = Field(..., max_length=255, description="User's password")