updated including new file

.env

 MONGO_URI=mongodb://localhost:27017
+DB_NAME=userDB
 SERVICE_HOST=0.0.0.0
 SERVICE_PORT=8671

requirements.txt

@@ -3,4 +3,5 @@ python-dotenv~=1.0.0
 pydantic~=1.10.6
 fastapi~=0.94.1
 passlib~=1.7.4
-pymongo~=4.3.3
+pymongo~=4.3.3
\ No newline at end of file
+bcrypt~=4.0.1
\ No newline at end of file

scripts/config/__init__.py

@@ -16,16 +16,13 @@ class _Services(BaseSettings):
     CORS_ALLOW_CREDENTIALS: bool = True
     CORS_ALLOW_METHODS: list[str] = ["GET", "POST", "DELETE", "PUT"]
     CORS_ALLOW_HEADERS: list[str] = ["*"]
-    SELF_PROXY: Optional[str] = Field(None, env="DIGITAL_SIGNATURE_PROXY")
     LOG_LEVEL: Literal["INFO", "DEBUG", "ERROR", "QTRACE"] = "INFO"
     ENABLE_FILE_LOGGING: bool = False
-    SECRET_KEY = "a8f3e3ed5f0dd73bca711df807b1141e15a499bc5e555d44fcab501c4147ee23"
-    ALGORITHM = "HS256"
-    ACCESS_TOKEN_EXPIRES_MINUTES = 800
 
 
 class _Databases(BaseSettings):
     MONGO_URI: str
+    DB_NAME: str
 
 
 Services = _Services()

scripts/constants/api.py

 class ApiEndPoints:
+    # version
     version = "/v1"
-    asset_manager_login = "/login"
-    asset_manager_submit = "/nor-login"
+
+    #  common
+    asset_manager_submit: str = "/submit"
+
+    # login-management
+    asset_manager_login: str = "/login"

scripts/constants/db_constants.py

+class DatabaseConstants:
+    collection_user_details = "userDetails"
+    collection_user_roles = "userRoles"
+    collection_user_devices = "userDevices"

scripts/core/handlers/loginmanager.py

-from fastapi.security import OAuth2PasswordBearer
-from passlib.context import CryptContext
+import bcrypt
+
+from scripts.database.mongo.mongo_login import MongoUser
+from scripts.logging.logger import logger
 
 
 class LoginManager:
-    def __init__(self):
-        self.pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-        self.oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+    @staticmethod
+    def verify_password(encrypted_password, password):
+        pwd = password
+        decoded_pwd = pwd.encode('utf-8')
+        print(encrypted_password, password)
+        if bcrypt.checkpw(encrypted_password, decoded_pwd):
+            return True
+        return False
+
+    @staticmethod
+    def hashed_password(password):
+        try:
+            pwd = password
+            encode_pwd = pwd.encode('utf-8')
+            # Generate salt
+            salted = bcrypt.gensalt()
+
+            # Hash password
+            pwd_hash = bcrypt.hashpw(encode_pwd, salted)
 
-    def hashed_password(self, password):
-        return self.pwd_context.hash(password)
+            return pwd_hash
+        except Exception as e:
+            logger.exception(e)
 
-    # def get_data(self, username, hashed):
+    @staticmethod
+    def get_data(username):
+        data = MongoUser().fetch_user_details(username)
+        return data

scripts/core/handlers/validation_login.py

+from scripts.logging.logger import logger
+
+
+class ValidateUser:
+    @staticmethod
+    def valid_user(db_data, username, password):
+        try:
+            if db_data["email"] != username:
+                return False
+            if db_data["password"] != password:
+                print(db_data["password"], password)
+                return False
+            return True
+        except Exception as e:
+            logger.exception(e)

scripts/database/mongo/__init__.py

+from scripts.config import Databases
+from scripts.utils.mongo_utils import MongoConnect
+
+mongo_obj = MongoConnect(uri=Databases.MONGO_URI)
+
+mongo_client = mongo_obj()
+
+CollectionBaseClass = mongo_obj.get_base_class()

scripts/database/mongo/mongo_login.py

+from scripts.config import Databases
+from scripts.constants.db_constants import DatabaseConstants
+from scripts.database.mongo import CollectionBaseClass, mongo_client
+
+collection_name = DatabaseConstants.collection_user_details
+
+
+class UserDetailsKeys:
+    KEY_NAME = "name"
+    KEY_EMAIL = "email"
+    KEY_PASSWORD = "password"
+    KEY_USER_ROLE = "user_role"
+    KEY_IS_ALIVE = "is_alive"
+    KEY_CREATED_AT = "created_at"
+    KEY_UPDATED_AT = "updated_at"
+
+
+class MongoUser(CollectionBaseClass):
+    key_name = UserDetailsKeys.KEY_NAME
+    key_email = UserDetailsKeys.KEY_EMAIL
+    key_password = UserDetailsKeys.KEY_PASSWORD
+    key_user_role = UserDetailsKeys.KEY_USER_ROLE
+    key_is_alive = UserDetailsKeys.KEY_IS_ALIVE
+    key_created_at = UserDetailsKeys.KEY_CREATED_AT
+    key_updated_at = UserDetailsKeys.KEY_UPDATED_AT
+
+    def __init__(self):
+        super().__init__(mongo_client, Databases.DB_NAME, collection_name)
+
+    def fetch_user_details(self, email):
+        if user := self.find_one(query={self.key_email: email}):
+            return user
+        return None

scripts/services/__init__.py

 from fastapi import FastAPI
-from scripts.constants.api import ApiEndPoints
-from scripts.services import iot_manager_services
+from scripts.services import v1
 
-router = FastAPI(prefix=ApiEndPoints.version)
-router.include_router(iot_manager_services.router)
+router = FastAPI()
+router.include_router(v1.router)

scripts/services/v1/__init__.py

+from fastapi import APIRouter
+from scripts.constants.api import ApiEndPoints
+from scripts.services.v1 import iot_manager_services
+
+router = APIRouter(prefix=ApiEndPoints.asset_manager_login)
+router.include_router(iot_manager_services.router)

scripts/services/iot_manager_services.py → scripts/services/v1/iot_manager_services.py

@@ -2,18 +2,19 @@ from fastapi import APIRouter
 
 from scripts.constants.api import ApiEndPoints
 from scripts.core.handlers.loginmanager import LoginManager
+from scripts.logging.logger import logger
 from scripts.schemas.login_schema import NormalLogin
 
 router = APIRouter(prefix=ApiEndPoints.version)
 
 
-@router.post(ApiEndPoints.asset_manager_login)
-def login_default(login_data: NormalLogin):
-    obj_login_manager = LoginManager()
-    password_hashed = obj_login_manager.hashed_password(login_data.password)
-    return password_hashed
-
-
 @router.post(ApiEndPoints.asset_manager_submit)
-def submit_login_details():
-    return {"message": "its working"}
+def login_default(login_data: NormalLogin):
+    try:
+        obj_login_manager = LoginManager()
+        password_hashed = obj_login_manager.hashed_password(login_data.password)
+        cursor_user_data = obj_login_manager.get_data(login_data.username)
+        user_exists = obj_login_manager.verify_password(password_hashed, cursor_user_data["password"])
+        return user_exists
+    except Exception as e:
+        logger.exception(e)

scripts/utils/mongo_tools/mongo_sync.py

+from __future__ import annotations
+
 import logging
 from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Union
 
@@ -11,22 +13,17 @@ from pymongo.results import (
     UpdateResult,
 )
 
-from scripts.utils.db_name_util import get_db_name
-
 
 class MongoCollectionBaseClass:
     def __init__(
-        self,
-        mongo_client: MongoClient,
-        database: str,
-        collection: str,
-        project_id: Optional[str],
+            self,
+            mongo_client: MongoClient,
+            database: str,
+            collection: str,
     ) -> None:
         self.client = mongo_client
         self.database = database
         self.collection = collection
-        if project_id:
-            self.database = get_db_name(project_id=project_id, database=self.database)
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(database={self.database}, collection={self.collection})"
@@ -64,14 +61,14 @@ class MongoCollectionBaseClass:
             raise
 
     def find(
-        self,
-        query: dict,
-        filter_dict: Optional[dict] = None,
-        sort: Union[
-            None, str, Sequence[Tuple[str, Union[int, str, Mapping[str, Any]]]]
-        ] = None,
-        skip: int = 0,
-        limit: Optional[int] = None,
+            self,
+            query: dict,
+            filter_dict: Optional[dict] = None,
+            sort: Union[
+                None, str, Sequence[Tuple[str, Union[int, str, Mapping[str, Any]]]]
+            ] = None,
+            skip: int = 0,
+            limit: Optional[int] = None,
     ) -> Cursor:
         """
         The function is used to query documents from a given collection in a Mongo Database
@@ -126,11 +123,11 @@ class MongoCollectionBaseClass:
             raise
 
     def update_one(
-        self,
-        query: dict,
-        data: dict,
-        upsert: bool = False,
-        strategy: str = "$set",
+            self,
+            query: dict,
+            data: dict,
+            upsert: bool = False,
+            strategy: str = "$set",
     ) -> UpdateResult:
         """
 
@@ -151,7 +148,7 @@ class MongoCollectionBaseClass:
             raise
 
     def update_many(
-        self, query: dict, data: dict, upsert: bool = False
+            self, query: dict, data: dict, upsert: bool = False
     ) -> UpdateResult:
         """
 
@@ -217,8 +214,8 @@ class MongoCollectionBaseClass:
             raise
 
     def aggregate(
-        self,
-        pipelines: list,
+            self,
+            pipelines: list,
     ) -> CommandCursor:
         try:
             database_name = self.database