square-authentication 1.0.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

square_authentication/routes/core.py

@@ -1,22 +1,28 @@
 from datetime import datetime, timedelta, timezone
-from typing import Annotated, Union
+from typing import Annotated, List
 
 import bcrypt
 import jwt
-from fastapi import APIRouter, status, Header
+from fastapi import APIRouter, status, Header, HTTPException
 from fastapi.responses import JSONResponse
-from requests.exceptions import HTTPError
+from square_commons import get_api_output_in_standard_format
+from square_database.pydantic_models.pydantic_models import (
+    FiltersV0,
+    FilterConditionsV0,
+)
 from square_database_helper.main import SquareDatabaseHelper
-from square_database_structure.square.authentication.enums import UserLogEventEnum
+from square_database_structure.square import global_string_database_name
+from square_database_structure.square.authentication import global_string_schema_name
 from square_database_structure.square.authentication.tables import (
-    local_string_database_name,
-    local_string_schema_name,
     User,
-    UserLog,
     UserCredential,
-    UserProfile,
     UserSession,
+    UserApp,
+)
+from square_database_structure.square.public import (
+    global_string_schema_name as global_string_public_schema_name,
 )
+from square_database_structure.square.public.tables import App
 
 from square_authentication.configuration import (
     global_object_square_logger,
@@ -28,6 +34,13 @@ from square_authentication.configuration import (
     config_int_square_database_port,
     config_str_square_database_protocol,
 )
+from square_authentication.messages import messages
+from square_authentication.pydantic_models.core import (
+    RegisterUsernameV0,
+    LoginUsernameV0,
+    DeleteUserV0,
+    UpdatePasswordV0,
+)
 from square_authentication.utils.token import get_jwt_payload
 
 router = APIRouter(
@@ -41,66 +54,541 @@ global_object_square_database_helper = SquareDatabaseHelper(
 )
 
 
-@router.get("/register_username/")
+@router.post("/register_username/v0")
 @global_object_square_logger.async_auto_logger
-async def register_username(username: str, password: str):
+async def register_username_v0(
+    body: RegisterUsernameV0,
+):
+    username = body.username
+    password = body.password
+    app_id = body.app_id
+
     local_str_user_id = None
+    local_str_access_token = None
+    local_str_refresh_token = None
+
+    username = username.lower()
     try:
-        # ======================================================================================
+        """
+        validation
+        """
+
+        # validation for username
+        local_list_response_user_creds = global_object_square_database_helper.get_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
+            table_name=UserCredential.__tablename__,
+            filters=FiltersV0(
+                {
+                    UserCredential.user_credential_username.name: FilterConditionsV0(
+                        eq=username
+                    )
+                }
+            ),
+        )[
+            "data"
+        ][
+            "main"
+        ]
+        if len(local_list_response_user_creds) > 0:
+            output_content = get_api_output_in_standard_format(
+                message=messages["USERNAME_ALREADY_EXISTS"],
+                log=f"an account with the username {username} already exists.",
+            )
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT,
+                detail=output_content,
+            )
+
+        """
+        main process
+        """
         # entry in user table
-        local_list_response_user = global_object_square_database_helper.insert_rows(
+        local_list_response_user = global_object_square_database_helper.insert_rows_v0(
             data=[{}],
-            database_name=local_string_database_name,
-            schema_name=local_string_schema_name,
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
             table_name=User.__tablename__,
-        )
+        )["data"]["main"]
         local_str_user_id = local_list_response_user[0][User.user_id.name]
-        # ======================================================================================
 
-        # ======================================================================================
-        # entry in user log
-        local_list_response_user_log = global_object_square_database_helper.insert_rows(
+        # entry in credential table
+
+        # hash password
+        local_str_hashed_password = bcrypt.hashpw(
+            password.encode("utf-8"), bcrypt.gensalt()
+        ).decode("utf-8")
+
+        global_object_square_database_helper.insert_rows_v0(
             data=[
                 {
-                    UserLog.user_id.name: local_str_user_id,
-                    UserLog.user_log_event.name: UserLogEventEnum.CREATED.value,
+                    UserCredential.user_id.name: local_str_user_id,
+                    UserCredential.user_credential_username.name: username,
+                    UserCredential.user_credential_hashed_password.name: local_str_hashed_password,
                 }
             ],
-            database_name=local_string_database_name,
-            schema_name=local_string_schema_name,
-            table_name=UserLog.__tablename__,
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
+            table_name=UserCredential.__tablename__,
         )
-        # ======================================================================================
+        if app_id is not None:
+            # assign app to user
+            global_object_square_database_helper.insert_rows_v0(
+                database_name=global_string_database_name,
+                schema_name=global_string_schema_name,
+                table_name=UserApp.__tablename__,
+                data=[
+                    {
+                        UserApp.user_id.name: local_str_user_id,
+                        UserApp.app_id.name: app_id,
+                    }
+                ],
+            )
 
-        # ======================================================================================
-        # entry in user profile
-        local_list_response_user_profile = (
-            global_object_square_database_helper.insert_rows(
-                data=[{UserProfile.user_id.name: local_str_user_id}],
-                database_name=local_string_database_name,
-                schema_name=local_string_schema_name,
-                table_name=UserProfile.__tablename__,
+            # return new access token and refresh token
+            # create access token
+            local_dict_access_token_payload = {
+                "app_id": app_id,
+                "user_id": local_str_user_id,
+                "exp": datetime.now(timezone.utc)
+                + timedelta(minutes=config_int_access_token_valid_minutes),
+            }
+            local_str_access_token = jwt.encode(
+                local_dict_access_token_payload,
+                config_str_secret_key_for_access_token,
+            )
+
+            # create refresh token
+            local_object_refresh_token_expiry_time = datetime.now(
+                timezone.utc
+            ) + timedelta(minutes=config_int_refresh_token_valid_minutes)
+
+            local_dict_refresh_token_payload = {
+                "app_id": app_id,
+                "user_id": local_str_user_id,
+                "exp": local_object_refresh_token_expiry_time,
+            }
+            local_str_refresh_token = jwt.encode(
+                local_dict_refresh_token_payload,
+                config_str_secret_key_for_refresh_token,
+            )
+            # entry in user session table
+            global_object_square_database_helper.insert_rows_v0(
+                data=[
+                    {
+                        UserSession.user_id.name: local_str_user_id,
+                        UserSession.app_id.name: app_id,
+                        UserSession.user_session_refresh_token.name: local_str_refresh_token,
+                        UserSession.user_session_expiry_time.name: local_object_refresh_token_expiry_time.strftime(
+                            "%Y-%m-%d %H:%M:%S.%f+00"
+                        ),
+                    }
+                ],
+                database_name=global_string_database_name,
+                schema_name=global_string_schema_name,
+                table_name=UserSession.__tablename__,
+            )
+        """
+        return value
+        """
+        output_content = get_api_output_in_standard_format(
+            message=messages["REGISTRATION_SUCCESSFUL"],
+            data={
+                "main": {
+                    "user_id": local_str_user_id,
+                    "username": username,
+                    "app_id": app_id,
+                    "access_token": local_str_access_token,
+                    "refresh_token": local_str_refresh_token,
+                },
+            },
+        )
+        return JSONResponse(
+            status_code=status.HTTP_201_CREATED,
+            content=output_content,
+        )
+    except HTTPException as http_exception:
+        return JSONResponse(
+            status_code=http_exception.status_code, content=http_exception.detail
+        )
+    except Exception as e:
+        global_object_square_logger.logger.error(e, exc_info=True)
+        """
+        rollback logic
+        """
+        if local_str_user_id:
+            global_object_square_database_helper.delete_rows_v0(
+                database_name=global_string_database_name,
+                schema_name=global_string_schema_name,
+                table_name=User.__tablename__,
+                filters=FiltersV0(
+                    {User.user_id.name: FilterConditionsV0(eq=local_str_user_id)}
+                ),
             )
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_500"],
+            log=str(e),
+        )
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=output_content
         )
 
-        # ======================================================================================
 
-        # ======================================================================================
-        # entry in credential table
+@router.get("/get_user_details/v0")
+@global_object_square_logger.async_auto_logger
+async def get_user_details_v0(
+    access_token: Annotated[str, Header()],
+):
+    try:
+        """
+        validation
+        """
+        # validate access token
+        try:
+            local_dict_access_token_payload = get_jwt_payload(
+                access_token, config_str_secret_key_for_access_token
+            )
+        except Exception as error:
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_ACCESS_TOKEN"], log=str(error)
+            )
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content=output_content,
+            )
+        user_id = local_dict_access_token_payload["user_id"]
+        """
+        main process
+        """
+        local_list_response_user_app = global_object_square_database_helper.get_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
+            table_name=UserApp.__tablename__,
+            filters=FiltersV0({UserApp.user_id.name: FilterConditionsV0(eq=user_id)}),
+        )["data"]["main"]
+        local_list_response_user_credentials = (
+            global_object_square_database_helper.get_rows_v0(
+                database_name=global_string_database_name,
+                schema_name=global_string_schema_name,
+                table_name=UserCredential.__tablename__,
+                filters=FiltersV0(
+                    {UserCredential.user_id.name: FilterConditionsV0(eq=user_id)}
+                ),
+            )["data"]["main"]
+        )
+        # not putting filter for expiry refresh tokens
+        local_list_response_user_sessions = (
+            global_object_square_database_helper.get_rows_v0(
+                database_name=global_string_database_name,
+                schema_name=global_string_schema_name,
+                table_name=UserSession.__tablename__,
+                filters=FiltersV0(
+                    {
+                        UserSession.user_id.name: FilterConditionsV0(eq=user_id),
+                    }
+                ),
+            )["data"]["main"]
+        )
+        """
+        return value
+        """
+        return_this = {
+            "user_id": user_id,
+            "credentials": {
+                "username": local_list_response_user_credentials[0][
+                    UserCredential.user_credential_username.name
+                ],
+            },
+            "apps": [x[UserApp.app_id.name] for x in local_list_response_user_app],
+            "sessions": [
+                {
+                    "app_id": x[UserApp.app_id.name],
+                    "sessions": len(
+                        [
+                            y
+                            for y in local_list_response_user_sessions
+                            if y[UserSession.app_id.name] == x[UserApp.app_id.name]
+                        ]
+                    ),
+                }
+                for x in local_list_response_user_app
+            ],
+        }
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_READ_SUCCESSFUL"],
+            data={"main": return_this},
+        )
+        return JSONResponse(
+            status_code=status.HTTP_200_OK,
+            content=output_content,
+        )
+    except HTTPException as http_exception:
+        return JSONResponse(
+            status_code=http_exception.status_code, content=http_exception.detail
+        )
+    except Exception as e:
+        """
+        rollback logic
+        """
+        global_object_square_logger.logger.error(e, exc_info=True)
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_500"],
+            log=str(e),
+        )
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content=output_content,
+        )
 
-        # hash password
-        local_str_hashed_password = bcrypt.hashpw(
-            password.encode("utf-8"), bcrypt.gensalt()
-        ).decode("utf-8")
+
+@router.patch("/update_user_app_ids/v0")
+@global_object_square_logger.async_auto_logger
+async def update_user_app_ids_v0(
+    access_token: Annotated[str, Header()],
+    app_ids_to_add: List[int],
+    app_ids_to_remove: List[int],
+):
+    try:
+
+        """
+        validation
+        """
+        # validate access token
+        try:
+            local_dict_access_token_payload = get_jwt_payload(
+                access_token, config_str_secret_key_for_access_token
+            )
+        except Exception as error:
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_ACCESS_TOKEN"], log=str(error)
+            )
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content=output_content,
+            )
+        user_id = local_dict_access_token_payload["user_id"]
+
+        app_ids_to_add = list(set(app_ids_to_add))
+        app_ids_to_remove = list(set(app_ids_to_remove))
+
+        # check if app_ids_to_add and app_ids_to_remove don't have common ids.
+        local_list_common_app_ids = set(app_ids_to_add) & set(app_ids_to_remove)
+        if len(local_list_common_app_ids) > 0:
+            output_content = get_api_output_in_standard_format(
+                message=messages["GENERIC_400"],
+                log=f"invalid app_ids: {list(local_list_common_app_ids)}, present in both add list and remove list.",
+            )
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=output_content,
+            )
+
+        # check if all app_ids are valid
+        local_list_all_app_ids = [*app_ids_to_add, *app_ids_to_remove]
+        local_list_response_app = global_object_square_database_helper.get_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_public_schema_name,
+            table_name=App.__tablename__,
+            apply_filters=False,
+            filters=FiltersV0({}),
+        )["data"]["main"]
+        local_list_invalid_ids = [
+            x
+            for x in local_list_all_app_ids
+            if x not in [y[App.app_id.name] for y in local_list_response_app]
+        ]
+        if len(local_list_invalid_ids) > 0:
+            output_content = get_api_output_in_standard_format(
+                message=messages["GENERIC_400"],
+                log=f"invalid app_ids: {local_list_invalid_ids}.",
+            )
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=output_content,
+            )
+        """
+        main process
+        """
+        # logic for adding new app_ids
+        local_list_response_user_app = global_object_square_database_helper.get_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
+            table_name=UserApp.__tablename__,
+            filters=FiltersV0({UserApp.user_id.name: FilterConditionsV0(eq=user_id)}),
+        )["data"]["main"]
+        local_list_new_app_ids = [
+            {
+                UserApp.user_id.name: user_id,
+                UserApp.app_id.name: x,
+            }
+            for x in app_ids_to_add
+            if x not in [y[UserApp.app_id.name] for y in local_list_response_user_app]
+        ]
+        if len(local_list_new_app_ids) > 0:
+            global_object_square_database_helper.insert_rows_v0(
+                database_name=global_string_database_name,
+                schema_name=global_string_schema_name,
+                table_name=UserApp.__tablename__,
+                data=local_list_new_app_ids,
+            )
+
+        # logic for removing app_ids
+        for app_id in app_ids_to_remove:
+            global_object_square_database_helper.delete_rows_v0(
+                database_name=global_string_database_name,
+                schema_name=global_string_schema_name,
+                table_name=UserApp.__tablename__,
+                filters=FiltersV0(
+                    {
+                        UserApp.user_id.name: FilterConditionsV0(eq=user_id),
+                        UserApp.app_id.name: FilterConditionsV0(eq=app_id),
+                    }
+                ),
+            )
+            # logout user from removed apps
+            global_object_square_database_helper.delete_rows_v0(
+                database_name=global_string_database_name,
+                schema_name=global_string_schema_name,
+                table_name=UserSession.__tablename__,
+                filters=FiltersV0(
+                    {
+                        UserSession.user_id.name: FilterConditionsV0(eq=user_id),
+                        UserSession.app_id.name: FilterConditionsV0(eq=app_id),
+                    }
+                ),
+            )
+
+        """
+        return value
+        """
+        # get latest app ids
+        local_list_response_user_app = global_object_square_database_helper.get_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
+            table_name=UserApp.__tablename__,
+            filters=FiltersV0({UserApp.user_id.name: FilterConditionsV0(eq=user_id)}),
+        )["data"]["main"]
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_UPDATE_SUCCESSFUL"],
+            data={
+                "main": [x[UserApp.app_id.name] for x in local_list_response_user_app]
+            },
+        )
+        return JSONResponse(
+            status_code=status.HTTP_200_OK,
+            content=output_content,
+        )
+    except HTTPException as http_exception:
+        return JSONResponse(
+            status_code=http_exception.status_code, content=http_exception.detail
+        )
+    except Exception as e:
+        """
+        rollback logic
+        """
+        global_object_square_logger.logger.error(e, exc_info=True)
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_500"],
+            log=str(e),
+        )
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content=output_content,
+        )
+
+
+@router.get("/login_username/v0")
+@global_object_square_logger.async_auto_logger
+async def login_username_v0(body: LoginUsernameV0):
+    username = body.username
+    password = body.password
+    app_id = body.app_id
+    username = username.lower()
+    try:
+        """
+        validation
+        """
+        # validation for username
+        local_list_authentication_user_response = global_object_square_database_helper.get_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
+            table_name=UserCredential.__tablename__,
+            filters=FiltersV0(
+                {
+                    UserCredential.user_credential_username.name: FilterConditionsV0(
+                        eq=username
+                    )
+                }
+            ),
+        )[
+            "data"
+        ][
+            "main"
+        ]
+        if len(local_list_authentication_user_response) != 1:
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_USERNAME"],
+                log=f"incorrect username {username}",
+            )
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST, content=output_content
+            )
+        # validate if app_id is assigned to user
+        # this will also validate if app_id is valid
+        local_dict_user = local_list_authentication_user_response[0]
+        local_str_user_id = local_dict_user[UserCredential.user_id.name]
+        local_list_user_app_response = global_object_square_database_helper.get_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
+            table_name=UserApp.__tablename__,
+            filters=FiltersV0(
+                {
+                    UserApp.user_id.name: FilterConditionsV0(eq=local_str_user_id),
+                    UserApp.app_id.name: FilterConditionsV0(eq=app_id),
+                }
+            ),
+        )["data"]["main"]
+        if len(local_list_user_app_response) != 1:
+            output_content = get_api_output_in_standard_format(
+                message=messages["GENERIC_400"],
+                log=f"user_id {local_str_user_id}({username}) not assigned to app {app_id}.",
+            )
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST, content=output_content
+            )
+
+        # validate password
+        if not (
+            bcrypt.checkpw(
+                password.encode("utf-8"),
+                local_dict_user[
+                    UserCredential.user_credential_hashed_password.name
+                ].encode("utf-8"),
+            )
+        ):
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_PASSWORD"],
+                log=f"incorrect password for user_id {local_str_user_id}({username}).",
+            )
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content=output_content,
+            )
+        """
+        main process
+        """
+        # return new access token and refresh token
 
         # create access token
         local_dict_access_token_payload = {
+            "app_id": app_id,
             "user_id": local_str_user_id,
             "exp": datetime.now(timezone.utc)
-                   + timedelta(minutes=config_int_access_token_valid_minutes),
+            + timedelta(minutes=config_int_access_token_valid_minutes),
         }
         local_str_access_token = jwt.encode(
-            local_dict_access_token_payload, config_str_secret_key_for_access_token
+            local_dict_access_token_payload,
+            config_str_secret_key_for_access_token,
         )
 
         # create refresh token
@@ -109,222 +597,189 @@ async def register_username(username: str, password: str):
         )
 
         local_dict_refresh_token_payload = {
+            "app_id": app_id,
             "user_id": local_str_user_id,
             "exp": local_object_refresh_token_expiry_time,
         }
         local_str_refresh_token = jwt.encode(
-            local_dict_refresh_token_payload, config_str_secret_key_for_refresh_token
+            local_dict_refresh_token_payload,
+            config_str_secret_key_for_refresh_token,
         )
-        try:
-            local_list_response_authentication_username = global_object_square_database_helper.insert_rows(
-                data=[
-                    {
-                        UserCredential.user_id.name: local_str_user_id,
-                        UserCredential.user_credential_username.name: username,
-                        UserCredential.user_credential_hashed_password.name: local_str_hashed_password,
-                    }
-                ],
-                database_name=local_string_database_name,
-                schema_name=local_string_schema_name,
-                table_name=UserCredential.__tablename__,
-            )
-        except HTTPError as http_error:
-            if http_error.response.status_code == 400:
-                return JSONResponse(
-                    status_code=status.HTTP_409_CONFLICT,
-                    content=f"an account with the username {username} already exists.",
-                )
-            else:
-                raise http_error
-        # ======================================================================================
-
-        # ======================================================================================
         # entry in user session table
-        local_list_response_user_session = global_object_square_database_helper.insert_rows(
+        global_object_square_database_helper.insert_rows_v0(
             data=[
                 {
                     UserSession.user_id.name: local_str_user_id,
+                    UserSession.app_id.name: app_id,
                     UserSession.user_session_refresh_token.name: local_str_refresh_token,
                     UserSession.user_session_expiry_time.name: local_object_refresh_token_expiry_time.strftime(
                         "%Y-%m-%d %H:%M:%S.%f+00"
                     ),
                 }
             ],
-            database_name=local_string_database_name,
-            schema_name=local_string_schema_name,
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
             table_name=UserSession.__tablename__,
         )
-        # ======================================================================================
+        """
+        return value
+        """
+        output_content = get_api_output_in_standard_format(
+            data={
+                "main": {
+                    "user_id": local_str_user_id,
+                    "access_token": local_str_access_token,
+                    "refresh_token": local_str_refresh_token,
+                }
+            },
+            message=messages["LOGIN_SUCCESSFUL"],
+        )
         return JSONResponse(
             status_code=status.HTTP_200_OK,
-            content={
-                "user_id": local_str_user_id,
-                "access_token": local_str_access_token,
-                "refresh_token": local_str_refresh_token,
-            },
+            content=output_content,
+        )
+    except HTTPException as http_exception:
+        return JSONResponse(
+            status_code=http_exception.status_code, content=http_exception.detail
         )
     except Exception as e:
+        """
+        rollback logic
+        """
         global_object_square_logger.logger.error(e, exc_info=True)
-        if local_str_user_id:
-            global_object_square_database_helper.delete_rows(
-                database_name=local_string_database_name,
-                schema_name=local_string_schema_name,
-                table_name=User.__tablename__,
-                filters={User.user_id.name: local_str_user_id},
-            )
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_500"],
+            log=str(e),
+        )
         return JSONResponse(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=str(e)
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=output_content
         )
 
 
-@router.get("/login_username/")
+@router.get("/generate_access_token/v0")
 @global_object_square_logger.async_auto_logger
-async def login_username(username: str, password: str):
+async def generate_access_token_v0(
+    refresh_token: Annotated[str, Header()],
+):
     try:
-        # ======================================================================================
-        # get entry from authentication_username table
-        local_list_authentication_user_response = (
-            global_object_square_database_helper.get_rows(
-                database_name=local_string_database_name,
-                schema_name=local_string_schema_name,
-                table_name=UserCredential.__tablename__,
-                filters={UserCredential.user_credential_username.name: username},
-            )
+        """
+        validation
+        """
+        # validate refresh token
+        # validating if a session refresh token exists in the database.
+        local_list_user_session_response = (
+            global_object_square_database_helper.get_rows_v0(
+                database_name=global_string_database_name,
+                schema_name=global_string_schema_name,
+                table_name=UserSession.__tablename__,
+                filters=FiltersV0(
+                    {
+                        UserSession.user_session_refresh_token.name: FilterConditionsV0(
+                            eq=refresh_token
+                        ),
+                    }
+                ),
+            )["data"]["main"]
         )
-        # ======================================================================================
 
-        # ======================================================================================
-        # validate username
-        # ======================================================================================
-        if len(local_list_authentication_user_response) != 1:
+        if len(local_list_user_session_response) != 1:
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_REFRESH_TOKEN"],
+                log=f"incorrect refresh token: {refresh_token}.",
+            )
             return JSONResponse(
-                status_code=status.HTTP_400_BAD_REQUEST, content="incorrect username."
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content=output_content,
             )
-        # ======================================================================================
-        # validate password
-        # ======================================================================================
-        else:
-            if not (
-                    bcrypt.checkpw(
-                        password.encode("utf-8"),
-                        local_list_authentication_user_response[0][
-                            UserCredential.user_credential_hashed_password.name
-                        ].encode("utf-8"),
-                    )
-            ):
-                return JSONResponse(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    content="incorrect password.",
-                )
-
-            # ======================================================================================
-            # return new access token and refresh token
-            # ======================================================================================
-            else:
-                local_str_user_id = local_list_authentication_user_response[0][
-                    UserCredential.user_id.name
-                ]
-                # create access token
-                local_dict_access_token_payload = {
-                    "user_id": local_str_user_id,
-                    "exp": datetime.now(timezone.utc)
-                           + timedelta(minutes=config_int_access_token_valid_minutes),
-                }
-                local_str_access_token = jwt.encode(
-                    local_dict_access_token_payload,
-                    config_str_secret_key_for_access_token,
-                )
-
-                # create refresh token
-                local_object_refresh_token_expiry_time = datetime.now(
-                    timezone.utc
-                ) + timedelta(minutes=config_int_refresh_token_valid_minutes)
-
-                local_dict_refresh_token_payload = {
-                    "user_id": local_str_user_id,
-                    "exp": local_object_refresh_token_expiry_time,
-                }
-                local_str_refresh_token = jwt.encode(
-                    local_dict_refresh_token_payload,
-                    config_str_secret_key_for_refresh_token,
-                )
-                # ======================================================================================
-                # entry in user session table
-                local_list_response_user_session = global_object_square_database_helper.insert_rows(
-                    data=[
-                        {
-                            UserSession.user_id.name: local_str_user_id,
-                            UserSession.user_session_refresh_token.name: local_str_refresh_token,
-                            UserSession.user_session_expiry_time.name: local_object_refresh_token_expiry_time.strftime(
-                                "%Y-%m-%d %H:%M:%S.%f+00"
-                            ),
-                        }
-                    ],
-                    database_name=local_string_database_name,
-                    schema_name=local_string_schema_name,
-                    table_name=UserSession.__tablename__,
-                )
-                # ======================================================================================
-                return JSONResponse(
-                    status_code=status.HTTP_200_OK,
-                    content={
-                        "user_id": local_str_user_id,
-                        "access_token": local_str_access_token,
-                        "refresh_token": local_str_refresh_token,
-                    },
-                )
-        # ======================================================================================
-
+        # validating if the refresh token is valid, active and of the same user.
+        try:
+            local_dict_refresh_token_payload = get_jwt_payload(
+                refresh_token, config_str_secret_key_for_refresh_token
+            )
+        except Exception as error:
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_REFRESH_TOKEN"], log=str(error)
+            )
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content=output_content,
+            )
+        """
+        main process
+        """
+        # create and send access token
+        local_dict_access_token_payload = {
+            "app_id": local_dict_refresh_token_payload["app_id"],
+            "user_id": local_dict_refresh_token_payload["user_id"],
+            "exp": datetime.now(timezone.utc)
+            + timedelta(minutes=config_int_access_token_valid_minutes),
+        }
+        local_str_access_token = jwt.encode(
+            local_dict_access_token_payload, config_str_secret_key_for_access_token
+        )
+        """
+        return value
+        """
+        output_content = get_api_output_in_standard_format(
+            data={"main": {"access_token": local_str_access_token}},
+            message=messages["GENERIC_CREATION_SUCCESSFUL"],
+        )
+        return JSONResponse(
+            status_code=status.HTTP_200_OK,
+            content=output_content,
+        )
+    except HTTPException as http_exception:
+        return JSONResponse(
+            status_code=http_exception.status_code, content=http_exception.detail
+        )
     except Exception as e:
+        """
+        rollback logic
+        """
         global_object_square_logger.logger.error(e, exc_info=True)
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_500"],
+            log=str(e),
+        )
         return JSONResponse(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=str(e)
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=output_content
         )
 
 
-@router.get("/generate_access_token/")
+@router.delete("/logout/v0")
 @global_object_square_logger.async_auto_logger
-async def generate_access_token(
-        user_id: str, refresh_token: Annotated[Union[str, None], Header()]
+async def logout_v0(
+    refresh_token: Annotated[str, Header()],
 ):
     try:
-        # ======================================================================================
-        # validate user_id
-        local_list_user_response = global_object_square_database_helper.get_rows(
-            database_name=local_string_database_name,
-            schema_name=local_string_schema_name,
-            table_name=User.__tablename__,
-            filters={User.user_id.name: user_id},
-        )
-
-        if len(local_list_user_response) != 1:
-            return JSONResponse(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                content=f"incorrect user_id: {user_id}.",
-            )
-        # ======================================================================================
-
-        # ======================================================================================
+        """
+        validation
+        """
         # validate refresh token
-
         # validating if a session refresh token exists in the database.
         local_list_user_session_response = (
-            global_object_square_database_helper.get_rows(
-                database_name=local_string_database_name,
-                schema_name=local_string_schema_name,
+            global_object_square_database_helper.get_rows_v0(
+                database_name=global_string_database_name,
+                schema_name=global_string_schema_name,
                 table_name=UserSession.__tablename__,
-                filters={
-                    UserSession.user_id.name: user_id,
-                    UserSession.user_session_refresh_token.name: refresh_token,
-                },
-            )
+                filters=FiltersV0(
+                    {
+                        UserSession.user_session_refresh_token.name: FilterConditionsV0(
+                            eq=refresh_token
+                        ),
+                    }
+                ),
+            )["data"]["main"]
         )
 
         if len(local_list_user_session_response) != 1:
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_REFRESH_TOKEN"],
+                log=f"incorrect refresh token: {refresh_token}.",
+            )
             return JSONResponse(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                content=f"incorrect refresh token: {refresh_token} for user_id: {user_id}."
-                        f"for user_id: {user_id}.",
+                content=output_content,
             )
         # validating if the refresh token is valid, active and of the same user.
         try:
@@ -332,133 +787,384 @@ async def generate_access_token(
                 refresh_token, config_str_secret_key_for_refresh_token
             )
         except Exception as error:
-            return JSONResponse(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                content=str(error),
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_REFRESH_TOKEN"],
+                log=str(error),
             )
-
-        if local_dict_refresh_token_payload["user_id"] != user_id:
             return JSONResponse(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                content=f"refresh token and user_id mismatch.",
+                content=output_content,
             )
-
         # ======================================================================================
+        # NOTE: if refresh token has expired no need to delete it during this call
         # ======================================================================================
-        # create and send access token
-        local_dict_access_token_payload = {
-            "user_id": user_id,
-            "exp": datetime.now(timezone.utc)
-                   + timedelta(minutes=config_int_access_token_valid_minutes),
-        }
-        local_str_access_token = jwt.encode(
-            local_dict_access_token_payload, config_str_secret_key_for_access_token
+        """
+        main process
+        """
+        # delete session for user
+        global_object_square_database_helper.delete_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
+            table_name=UserSession.__tablename__,
+            filters=FiltersV0(
+                {
+                    UserSession.user_session_refresh_token.name: FilterConditionsV0(
+                        eq=refresh_token
+                    ),
+                }
+            ),
         )
-
+        """
+        return value
+        """
+        output_content = get_api_output_in_standard_format(
+            message=messages["LOGOUT_SUCCESSFUL"],
+        )
+        return JSONResponse(status_code=status.HTTP_200_OK, content=output_content)
+    except HTTPException as http_exception:
         return JSONResponse(
-            status_code=status.HTTP_200_OK,
-            content={"access_token": local_str_access_token},
+            status_code=http_exception.status_code, content=http_exception.detail
         )
-        # ======================================================================================
-
     except Exception as e:
+        """
+        rollback logic
+        """
         global_object_square_logger.logger.error(e, exc_info=True)
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_500"],
+            log=str(e),
+        )
         return JSONResponse(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=str(e)
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=output_content
         )
 
 
-@router.delete("/logout/")
+@router.patch("/update_username/v0")
 @global_object_square_logger.async_auto_logger
-async def logout(
-        user_id: str,
-        access_token: Annotated[Union[str, None], Header()],
-        refresh_token: Annotated[Union[str, None], Header()],
+async def update_username_v0(
+    new_username: str,
+    access_token: Annotated[str, Header()],
 ):
     try:
-        # ======================================================================================
+        """
+        validation
+        """
+        # validate access token
+        try:
+            local_dict_access_token_payload = get_jwt_payload(
+                access_token, config_str_secret_key_for_access_token
+            )
+        except Exception as error:
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_ACCESS_TOKEN"], log=str(error)
+            )
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content=output_content,
+            )
+        user_id = local_dict_access_token_payload["user_id"]
+
         # validate user_id
-        local_list_user_response = global_object_square_database_helper.get_rows(
-            database_name=local_string_database_name,
-            schema_name=local_string_schema_name,
+        local_list_user_response = global_object_square_database_helper.get_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
             table_name=User.__tablename__,
-            filters={User.user_id.name: user_id},
-        )
+            filters=FiltersV0(
+                {
+                    User.user_id.name: FilterConditionsV0(eq=user_id),
+                }
+            ),
+        )["data"]["main"]
 
         if len(local_list_user_response) != 1:
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_USER_ID"],
+                log=f"incorrect user_id: {user_id}.",
+            )
             return JSONResponse(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                content=f"incorrect user_id: {user_id}.",
+                content=output_content,
             )
-        # ======================================================================================
 
-        # ======================================================================================
-        # validate refresh token
+        # validate new username
+        local_list_user_credentials_response = global_object_square_database_helper.get_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
+            table_name=UserCredential.__tablename__,
+            filters=FiltersV0(
+                {
+                    UserCredential.user_credential_username.name: FilterConditionsV0(
+                        eq=new_username
+                    ),
+                }
+            ),
+        )[
+            "data"
+        ][
+            "main"
+        ]
+        if len(local_list_user_credentials_response) != 0:
+            output_content = get_api_output_in_standard_format(
+                message=messages["USERNAME_ALREADY_EXISTS"],
+                log=f"{new_username} is taken.",
+            )
+            return JSONResponse(
+                status_code=status.HTTP_409_CONFLICT,
+                content=output_content,
+            )
+        """
+        main process
+        """
+        # edit the username
+        global_object_square_database_helper.edit_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
+            table_name=UserCredential.__tablename__,
+            filters=FiltersV0(
+                {
+                    UserCredential.user_id.name: FilterConditionsV0(eq=user_id),
+                }
+            ),
+            data={
+                UserCredential.user_credential_username.name: new_username,
+            },
+        )
+        """
+        return value
+        """
+        output_content = get_api_output_in_standard_format(
+            data={"main": {"user_id": user_id, "username": new_username}},
+            message=messages["GENERIC_UPDATE_SUCCESSFUL"],
+        )
+        return JSONResponse(status_code=status.HTTP_200_OK, content=output_content)
+    except HTTPException as http_exception:
+        return JSONResponse(
+            status_code=http_exception.status_code, content=http_exception.detail
+        )
+    except Exception as e:
+        """
+        rollback logic
+        """
+        global_object_square_logger.logger.error(e, exc_info=True)
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_500"],
+            log=str(e),
+        )
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=output_content
+        )
 
-        # validating if a session refresh token exists in the database.
-        local_list_user_session_response = (
-            global_object_square_database_helper.get_rows(
-                database_name=local_string_database_name,
-                schema_name=local_string_schema_name,
-                table_name=UserSession.__tablename__,
-                filters={
-                    UserSession.user_id.name: user_id,
-                    UserSession.user_session_refresh_token.name: refresh_token,
-                },
+
+@router.delete("/delete_user/v0")
+@global_object_square_logger.async_auto_logger
+async def delete_user_v0(
+    body: DeleteUserV0,
+    access_token: Annotated[str, Header()],
+):
+    password = body.password
+    try:
+        """
+        validation
+        """
+        # validate access token
+        try:
+            local_dict_access_token_payload = get_jwt_payload(
+                access_token, config_str_secret_key_for_access_token
             )
+        except Exception as error:
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_ACCESS_TOKEN"], log=str(error)
+            )
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content=output_content,
+            )
+        user_id = local_dict_access_token_payload["user_id"]
+
+        # validate user_id
+        local_list_authentication_user_response = (
+            global_object_square_database_helper.get_rows_v0(
+                database_name=global_string_database_name,
+                schema_name=global_string_schema_name,
+                table_name=UserCredential.__tablename__,
+                filters=FiltersV0(
+                    {UserCredential.user_id.name: FilterConditionsV0(eq=user_id)}
+                ),
+            )["data"]["main"]
         )
+        if len(local_list_authentication_user_response) != 1:
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_USER_ID"],
+                log=f"incorrect user_id: {user_id}.",
+            )
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST, content=output_content
+            )
 
-        if len(local_list_user_session_response) != 1:
+        # validate password
+        local_dict_user = local_list_authentication_user_response[0]
+        if not (
+            bcrypt.checkpw(
+                password.encode("utf-8"),
+                local_dict_user[
+                    UserCredential.user_credential_hashed_password.name
+                ].encode("utf-8"),
+            )
+        ):
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_PASSWORD"],
+                log=f"incorrect password for user_id {user_id}.",
+            )
             return JSONResponse(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                content=f"incorrect refresh token: {refresh_token} for user_id: {user_id}."
-                        f"for user_id: {user_id}.",
+                content=output_content,
             )
-        # not validating if the refresh token is valid, active and of the same user.
-        # ======================================================================================
+        """
+        main process
+        """
+        # delete the user.
+        global_object_square_database_helper.delete_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
+            table_name=User.__tablename__,
+            filters=FiltersV0(
+                {
+                    User.user_id.name: FilterConditionsV0(eq=user_id),
+                }
+            ),
+        )
+        """
+        return value
+        """
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_DELETE_SUCCESSFUL"],
+            log=f"user_id: {user_id} deleted successfully.",
+        )
+        return JSONResponse(status_code=status.HTTP_200_OK, content=output_content)
+    except HTTPException as http_exception:
+        return JSONResponse(
+            status_code=http_exception.status_code, content=http_exception.detail
+        )
+    except Exception as e:
+        """
+        rollback logic
+        """
+        global_object_square_logger.logger.error(e, exc_info=True)
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_500"],
+            log=str(e),
+        )
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=output_content
+        )
 
-        # ======================================================================================
+
+@router.patch("/update_password/v0")
+@global_object_square_logger.async_auto_logger
+async def update_password_v0(
+    body: UpdatePasswordV0,
+    access_token: Annotated[str, Header()],
+):
+    old_password = body.old_password
+    new_password = body.new_password
+    try:
+        """
+        validation
+        """
         # validate access token
-        # validating if the access token is valid, active and of the same user.
         try:
             local_dict_access_token_payload = get_jwt_payload(
                 access_token, config_str_secret_key_for_access_token
             )
         except Exception as error:
-            return JSONResponse(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                content=str(error),
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_ACCESS_TOKEN"], log=str(error)
             )
-        if local_dict_access_token_payload["user_id"] != user_id:
             return JSONResponse(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                content=f"access token and user_id mismatch.",
+                content=output_content,
             )
+        user_id = local_dict_access_token_payload["user_id"]
 
-        # ======================================================================================
-
-        # NOTE: if both access token and refresh token have expired for a user,
-        # it can be assumed that user session only needs to be removed from the front end.
+        # validate user_id
+        local_list_authentication_user_response = (
+            global_object_square_database_helper.get_rows_v0(
+                database_name=global_string_database_name,
+                schema_name=global_string_schema_name,
+                table_name=UserCredential.__tablename__,
+                filters=FiltersV0(
+                    {UserCredential.user_id.name: FilterConditionsV0(eq=user_id)}
+                ),
+            )["data"]["main"]
+        )
+        if len(local_list_authentication_user_response) != 1:
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_USER_ID"],
+                log=f"incorrect user_id: {user_id}.",
+            )
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST, content=output_content
+            )
 
-        # ======================================================================================
-        # delete session for user
-        global_object_square_database_helper.delete_rows(
-            database_name=local_string_database_name,
-            schema_name=local_string_schema_name,
-            table_name=UserSession.__tablename__,
-            filters={
-                UserSession.user_id.name: user_id,
-                UserSession.user_session_refresh_token.name: refresh_token,
+        # validate password
+        local_dict_user = local_list_authentication_user_response[0]
+        if not (
+            bcrypt.checkpw(
+                old_password.encode("utf-8"),
+                local_dict_user[
+                    UserCredential.user_credential_hashed_password.name
+                ].encode("utf-8"),
+            )
+        ):
+            output_content = get_api_output_in_standard_format(
+                message=messages["INCORRECT_PASSWORD"],
+                log=f"incorrect password for user_id {user_id}.",
+            )
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content=output_content,
+            )
+        """
+        main process
+        """
+        # delete the user.
+        local_str_hashed_password = bcrypt.hashpw(
+            new_password.encode("utf-8"), bcrypt.gensalt()
+        ).decode("utf-8")
+        global_object_square_database_helper.edit_rows_v0(
+            database_name=global_string_database_name,
+            schema_name=global_string_schema_name,
+            table_name=UserCredential.__tablename__,
+            filters=FiltersV0(
+                {
+                    UserCredential.user_id.name: FilterConditionsV0(eq=user_id),
+                }
+            ),
+            data={
+                UserCredential.user_credential_hashed_password.name: local_str_hashed_password,
             },
         )
-
+        """
+        return value
+        """
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_UPDATE_SUCCESSFUL"],
+            log=f"password for user_id: {user_id} updated successfully.",
+        )
+        return JSONResponse(status_code=status.HTTP_200_OK, content=output_content)
+    except HTTPException as http_exception:
         return JSONResponse(
-            status_code=status.HTTP_200_OK, content="Log out successful."
+            status_code=http_exception.status_code, content=http_exception.detail
         )
-        # ======================================================================================
-
     except Exception as e:
+        """
+        rollback logic
+        """
         global_object_square_logger.logger.error(e, exc_info=True)
+        output_content = get_api_output_in_standard_format(
+            message=messages["GENERIC_500"],
+            log=str(e),
+        )
         return JSONResponse(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=str(e)
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=output_content
         )