Merge branch '1-arun-uday-asset-manager-v1-0' into 'master'

1 arun uday asset manager v1 0

See merge request !5

.env

@@ -19,10 +19,11 @@ EMAIL_PORT=465
 EMAIL_PASSWORD=gpphuiweedqukchf
 HTML_LINK=scripts/utils/link_email.html
 RESET_ENDPOINT=http://localhost:8671/asset_manager_api/v1/login/reset?token
+REDIRECT_URL_RESET=http://192.168.2.102/iLens_UI/#/l/login
 
 CLIENT_ID=1060631831358-a21djaa3hm165a8976fnmo1lerujs5p6.apps.googleusercontent.com
 
 LOG_PATH=log
 LOG_LEVEL=INFO
-BACKUP_COUNT=100
-MAX_BYTES=5
+BACKUP_COUNT=5
+MAX_BYTES=10000000

app.py

@@ -38,5 +38,5 @@ if __name__ == "__main__":
         # starting the app
         uvicorn.run("main:app", host=arguments["bind"], port=int(arguments["port"]))
     except Exception as e:
-        logger.exception(f'Services Failed with error {e}')
+        logger.exception(f'Services Failed with error from app {e}')
 

log/AssetManager.log

-2023-04-04 20:12:33 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-05 19:15:09 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-05 19:15:29 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-06 10:07:03 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-06 11:15:22 - ERROR  - [MainThread:db_password_matching(): 76] - Services Failed with error from process login db password matching hash could not be identified
+2023-04-06 11:16:06 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-06 11:16:09 - ERROR  - [MainThread:db_password_matching(): 76] - Services Failed with error from process login db password matching hash could not be identified
+2023-04-06 11:16:56 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-06 11:17:02 - ERROR  - [MainThread:db_password_matching(): 77] - Services Failed with error from process login db password matching hash could not be identified
+2023-04-06 11:17:37 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-06 11:17:39 - ERROR  - [MainThread:db_password_matching(): 77] - Services Failed with error from process login db password matching hash could not be identified
+2023-04-06 11:18:13 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-06 11:18:16 - ERROR  - [MainThread:db_password_matching(): 77] - Services Failed with error from process login db password matching hash could not be identified
+2023-04-06 11:18:39 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-06 11:18:47 - ERROR  - [MainThread:db_password_matching(): 77] - Services Failed with error from process login db password matching hash could not be identified
+2023-04-06 12:15:33 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-06 14:43:59 - ERROR  - [MainThread:reset_password(): 318] - Services Failed with error from reset user password 'password'
+Traceback (most recent call last):
+  File "E:\Git\meta-services\scripts\core\handlers\user_management_handler.py", line 278, in reset_password
+    db_user_data["password"]):
+KeyError: 'password'
+2023-04-06 14:58:17 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-06 15:23:00 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-06 15:23:06 - ERROR  - [MainThread:fetch_user_details(): 257] - Services Failed with error from fetch user details unhashable type: 'dict'
+Traceback (most recent call last):
+  File "E:\Git\meta-services\scripts\core\handlers\user_management_handler.py", line 237, in fetch_user_details
+    cursor_data = obj_mongo_user.fetch_all_user_details({"user_id": {obj_stage.not_equal(request.user_id)}},
+TypeError: unhashable type: 'dict'
+2023-04-06 15:23:41 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671
+2023-04-06 15:53:28 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671

log/AssetManager.log.1

-2023-04-04 20:08:30 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671

log/AssetManager.log.2

-2023-04-04 20:07:39 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671

log/AssetManager.log.3

-2023-04-04 20:06:55 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671

log/AssetManager.log.4

-2023-04-04 20:06:23 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671

log/AssetManager.log.5

-2023-04-04 20:06:10 - INFO   - [MainThread:<module>(): 37] - App Starting at 0.0.0.0:8671

main.py

@@ -37,4 +37,4 @@ if __name__ == "__main__":
                 allow_headers=ServiceConf.CORS_ALLOW_HEADERS,
             )
     except Exception as e:
-        logger.error(e)
+        logger.error(f'Services Failed with error from main {e}')

scripts/config/__init__.py

-import pathlib
-from typing import Literal
-
 from pydantic import BaseSettings, Field
 
 
@@ -24,6 +21,7 @@ class _Services(BaseSettings):
     EMAIL_PASSWORD: str
     HTML_LINK: str
     RESET_ENDPOINT: str
+    REDIRECT_URL_RESET: str
     DATE_TIME = '%Y-%m-%d %H:%M:%S'
 
 

scripts/core/handlers/dashboard_handler.py

@@ -42,4 +42,5 @@ class DashboardManagement:
                                         data=data).dict(),
                 status_code=status.HTTP_200_OK)
         except Exception as e:
-            logger.exception(e)
+            logger.error(f'Services Failed with error from download header {e}')
+            return None

scripts/core/handlers/login_handler.py

@@ -33,6 +33,7 @@ class LoginHandlers:
         self.login_type = ""
 
     def general_login(self, user_data, request):
+        try:
             self.login_type = "general_login"
             # decrypting the password from the UI
             decrypted_password = self.pass_decrypt.password_decrypt(user_data.password)
@@ -74,9 +75,17 @@ class LoginHandlers:
                 status_code=status.HTTP_200_OK, headers={"Content-Type": "application/json"})
             response.set_cookie(key="login-token", value=responses, expires=exp)
             return response
+        except Exception as e:
+            logger.error(f'Services Failed with error from general_login {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_LOGIN).dict(),
+                status_code=status.HTTP_200_OK)
 
     def google_login(self, user_data, request):
-        user_data_remove_none = {key: value for key, value in user_data if key != 'login_type' and value is not None}
+        try:
+            user_data_remove_none = {key: value for key, value in user_data if
+                                     key != 'login_type' and value is not None}
             req = requests.Request()
             try:
                 id_info = id_token.verify_oauth2_token(
@@ -115,6 +124,12 @@ class LoginHandlers:
                 status_code=status.HTTP_200_OK, headers={"Content-Type": "application/json"})
             response.set_cookie(key="login-token", value=responses, expires=exp)
             return response
+        except Exception as e:
+            logger.error(f'Services Failed with error from google login {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_LOGIN).dict(),
+                status_code=status.HTTP_200_OK)
 
     # v2
     def microsoft_login(self, request):
@@ -143,7 +158,6 @@ class LoginHandlers:
             expire = datetime.utcnow() + timedelta(minutes=Secrets.TOKEN_EXPIRE_TIME)
             to_encode.update({"exp": expire})
             jwt_token = jwt.encode(to_encode)
-            html = ''
             # Load the HTML file
             try:
                 with open(Services.HTML_LINK, "r") as f:
@@ -151,7 +165,9 @@ class LoginHandlers:
                 html = html.replace("{{ message }}", "Please click the link to reset your password:").replace(
                     "{{ link }}", Services.RESET_ENDPOINT + "=" + str(jwt_token))
             except Exception as e:
-                logger.exception(e)
+                logger.exception(logger.error(f'Services Failed sending email {e}'))
+                return
+
             html_body = MIMEText(html, "html")
             mail.attach(html_body)
             context = ssl.create_default_context()
@@ -164,7 +180,11 @@ class LoginHandlers:
                 content=DefaultSuccessResponse(status="success", message="Email Send Successfully").dict(),
                 status_code=status.HTTP_200_OK)
         except Exception as e:
-            logger.exception(e)
+            logger.error(f'Services Failed with error from forgot password handler {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_SENDING_MAIL).dict(),
+                status_code=status.HTTP_200_OK)
 
     @staticmethod
     def validate_jwt(request):
@@ -182,12 +202,16 @@ class LoginHandlers:
                                                        message=ErrorMessages.ERROR_USER_ID_DOESNT_EXIST).dict(),
                         status_code=status.HTTP_200_OK)
                 jwt_token_new = jwt.encode({"email": decoded_token['email']})
-                return RedirectResponse('http://192.168.2.102/iLens_UI/#/l/login?user_id=' + jwt_token_new)
+                return RedirectResponse(Services.REDIRECT_URL_RESET + '?user_id=' + jwt_token_new)
             except ExpiredSignatureError:
                 return RedirectResponse(
-                    'http://192.168.2.102/iLens_UI/#/l/login?error=' + "true")
+                    Services.REDIRECT_URL_RESET + '?error=' + "true")
         except Exception as e:
-            logger.exception(e)
+            logger.error(f'Services Failed with error from validate jwt {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_RESETTING_PASSWORD).dict(),
+                status_code=status.HTTP_200_OK)
 
     @staticmethod
     def reset_user_password(reset_data):
@@ -210,13 +234,19 @@ class LoginHandlers:
                         content=DefaultFailureResponse(status="failed",
                                                        message=ErrorMessages.ERROR_USER_ID_DOESNT_EXIST).dict(),
                         status_code=status.HTTP_200_OK)
-                response = EncryptDecryptPassword().password_encrypt(reset_data.password)
+                response, password_encrypted = EncryptDecryptPassword().check_password_mismatch(
+                    reset_data.new_password, reset_data.confirm_password)
                 if not response:
+                    return JSONResponse(
+                        content=DefaultFailureResponse(status="failed",
+                                                       message=password_encrypted).dict(),
+                        status_code=status.HTTP_200_OK)
+                if not password_encrypted:
                     return JSONResponse(
                         content=DefaultFailureResponse(status="failed",
                                                        message=ErrorMessages.ERROR_AUTH_FAILED).dict(),
                         status_code=status.HTTP_200_OK)
-                response = obj_mongo_user.update_user({"email": decoded_token['email']}, {"password": response})
+                response = obj_mongo_user.update_user({"email": decoded_token['email']}, {"password": password_encrypted})
                 if not response:
                     return JSONResponse(
                         content=DefaultFailureResponse(status="failed",
@@ -226,6 +256,13 @@ class LoginHandlers:
                     content=DefaultSuccessResponse(status="success", message="Reset Successful").dict(),
                     status_code=status.HTTP_200_OK)
             except ExpiredSignatureError:
-                return "Password Reset Token Expired"
+                return JSONResponse(
+                    content=DefaultFailureResponse(status="failed",
+                                                   message=ErrorMessages.ERROR_INVALID_TOKEN).dict(),
+                    status_code=status.HTTP_200_OK)
         except Exception as e:
-            logger.exception(e)
+            logger.error(f'Services Failed with error from reset user password {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_RESETTING_PASSWORD).dict(),
+                status_code=status.HTTP_200_OK)

scripts/core/handlers/process_login_data.py

@@ -31,7 +31,8 @@ class NormalLogin:
                 return ErrorMessages.ERROR_INVALID_PASSWORD
             return None
         except Exception as e:
-            logger.exception(e)
+            logger.error(f'Services Failed with error from process login user data validation {e}')
+            return None
 
     # db validation
     def db_data_validation(self, login_type, email):
@@ -47,7 +48,7 @@ class NormalLogin:
             try:
                 response = {"user_id": self.db_user_data["user_id"], "name": self.db_user_data["name"],
                             "email": email,
-                            "user_role": self.db_user_data["user_role"]}
+                            "user_role": self.db_user_data["user_role"], "login_type": self.db_user_data["login_type"]}
             except KeyError:
                 response = {"user_id": self.db_user_data["user_id"],
                             "email": email,
@@ -55,7 +56,8 @@ class NormalLogin:
             # if the user exist
             return None, response
         except Exception as e:
-            logger.exception(e)
+            logger.error(f'Services Failed with error from process login db data validation {e}')
+            return True, "Exception"
 
     # matching the password
     def db_password_matching(self, login_type, user_data, password):
@@ -71,14 +73,19 @@ class NormalLogin:
             # if the password is correct
             return None, message
         except Exception as e:
-            logger.exception(e)
+            logger.error(f'Services Failed with error from process login db password matching {e}')
+            return True, "Exception"
 
     @staticmethod
     def update_pic(obj_mongo_user, info_data):
+        try:
             if not obj_mongo_user.update_user({"email": info_data["email"]},
                                               {"name": info_data["name"], "pic_url": info_data["picture"]}):
                 return None
             return True
+        except Exception as e:
+            logger.error(f'Services Failed with error from process login update pic {e}')
+            return None
 
     # cookie and token creation
     @staticmethod
@@ -95,4 +102,5 @@ class NormalLogin:
             else:
                 return None
         except Exception as e:
-            logger.exception(e)
+            logger.error(f'Services Failed with error from process login cookie tokens {e}')
+            return None

scripts/core/handlers/user_management_handler.py

 import datetime
 import uuid
 
+from fastapi import status
+from fastapi.responses import JSONResponse
 from passlib.context import CryptContext
 
 from scripts.database.mongo.mongo_db import MongoUser
 from scripts.database.redis.redis_conn import login_db
 from scripts.errors import ErrorMessages
 from scripts.logging.logger import logger
-from fastapi.responses import JSONResponse
-from fastapi import status
 from scripts.schemas.default_responses import DefaultResponse, DefaultFailureResponse, DefaultSuccessResponse
 from scripts.utils.mongo_utils import MongoStageCreator
 from scripts.utils.response_utils import ResponseData
+from scripts.utils.security.authorize_access import AuthorizeAccess
 from scripts.utils.security.password_util import EncryptDecryptPassword
 from scripts.utils.validations_util import UserDataValidations
 
 obj_mongo_user = MongoUser()
 obj_response_data = ResponseData()
 obj_stage = MongoStageCreator()
+obj_authorize = AuthorizeAccess()
 
 
 # user management
@@ -34,7 +36,7 @@ class UserManagement:
             if not response:
                 return JSONResponse(
                     content=DefaultFailureResponse(status="failed",
-                                                   message=message["message"]).dict(),
+                                                   message=message).dict(),
                     status_code=status.HTTP_200_OK)
             # fetching the data based on the username
             db_user_data = obj_mongo_user.fetch_one_user_details({"email": user_data.email})
@@ -71,7 +73,11 @@ class UserManagement:
                 content=DefaultSuccessResponse(status="success", message="User Registration Successful").dict(),
                 status_code=status.HTTP_200_OK)
         except Exception as e:
-            logger.exception(e)
+            logger.exception(f'Services Failed with error from general register {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_REGISTERING).dict(),
+                status_code=status.HTTP_200_OK)
 
     @staticmethod
     # for Google registration using gmail
@@ -104,7 +110,11 @@ class UserManagement:
                 content=DefaultSuccessResponse(status="success", message="User Registration Successful").dict(),
                 status_code=status.HTTP_200_OK)
         except Exception as e:
-            logger.exception(e)
+            logger.exception(f'Services Failed with error from google register {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_REGISTERING).dict(),
+                status_code=status.HTTP_200_OK)
 
     @staticmethod
     # for microsoft registration using microsoft account
@@ -112,7 +122,11 @@ class UserManagement:
         try:
             return {"message": "Not available"}
         except Exception as e:
-            logger.exception(e)
+            logger.exception(f'Services Failed with error from microsoft register {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_REGISTERING).dict(),
+                status_code=status.HTTP_200_OK)
 
     # update user details
     def update_user_details(self, update_data):
@@ -137,15 +151,8 @@ class UserManagement:
                         status_code=status.HTTP_404_NOT_FOUND)
             # creating the filter data
             filter_data_updated = {"user_id": update_data.user_id}
-            encrypted = EncryptDecryptPassword().password_encrypt(update_data.password)
-            if encrypted is None:
-                return JSONResponse(
-                    content=DefaultFailureResponse(status="failed",
-                                                   message=ErrorMessages.ERROR_INVALID_PASSWORD).dict(),
-                    status_code=status.HTTP_200_OK)
             # encrypting the password
-            update_data_removed = {key: (encrypted
-                                         if key == "password" else value) for key, value in update_data if
+            update_data_removed = {key: value for key, value in update_data if
                                    key != 'action' and value is not None}
             # validating the data
             response, message = UserDataValidations.update_data_validation(update_data)
@@ -162,11 +169,16 @@ class UserManagement:
                 content=DefaultSuccessResponse(status="success", message="Updated Successfully").dict(),
                 status_code=status.HTTP_200_OK)
         except Exception as e:
-            logger.exception(e)
+            logger.exception(f'Services Failed with error from update user {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_UPDATING).dict(),
+                status_code=status.HTTP_200_OK)
 
     # delete user
     @staticmethod
     def delete_user_details(user_id):
+        try:
             # fetching and validating the user id
             db_user_data = obj_mongo_user.fetch_one_user_details({"user_id": user_id})
             # if the user is not available
@@ -187,6 +199,8 @@ class UserManagement:
             return JSONResponse(
                 content=DefaultSuccessResponse(status="success", message="Deleted Successfully").dict(),
                 status_code=status.HTTP_200_OK)
+        except Exception as e:
+            logger.exception(f'Services Failed with error from delete user {e}')
 
     @staticmethod
     def fetch_view_header():
@@ -203,20 +217,24 @@ class UserManagement:
                                                message=ErrorMessages.ERROR_IN_FETCHING).dict(),
                 status_code=status.HTTP_404_NOT_FOUND)
         except Exception as e:
-            logger.exception(e)
+            logger.exception(f'Services Failed with error from fetch user header {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_FETCHING_HEADER).dict(),
+                status_code=status.HTTP_200_OK)
 
     @staticmethod
     def fetch_user_details():
         try:
             # defining the filter values
             filter_data = {'_id': 0,
-                           "login_type": 0,
                            "is_alive": 0,
                            "password": 0,
                            "created_at": 0,
                            "updated_at": 0}
             # filtering the users and getting all the details
-            cursor_data = obj_mongo_user.fetch_all_user_details({}, filter_data)
+            cursor_data = obj_mongo_user.fetch_all_user_details({},
+                                                                filter_data)
             cursor_data_count = cursor_data.explain()
             # counting the total records in the query
             if cursor_data_count["executionStats"]["nReturned"] <= 0:
@@ -235,10 +253,21 @@ class UserManagement:
                                                message=ErrorMessages.ERROR_IN_FETCHING).dict(),
                 status_code=status.HTTP_404_NOT_FOUND)
         except Exception as e:
-            logger.exception(e)
+            logger.exception(f'Services Failed with error from fetch user details {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_FETCHING).dict(),
+                status_code=status.HTTP_200_OK)
 
     # user change password
-    def reset_password(self, reset_data):
+    def reset_password(self, request, reset_data):
+        try:
+            response = obj_authorize.login_authorize(request, reset_data)
+            if not response:
+                return JSONResponse(
+                    content=DefaultFailureResponse(status="failed",
+                                                   message=ErrorMessages.ERROR_UNAUTHORIZED_ACCESS).dict(),
+                    status_code=status.HTTP_200_OK)
             db_user_data = obj_mongo_user.fetch_one_user_details({"user_id": reset_data.user_id})
             # if the user is not available
             if db_user_data is None:
@@ -246,17 +275,30 @@ class UserManagement:
                     content=DefaultFailureResponse(status="failed",
                                                    message=ErrorMessages.ERROR_USER_ID_DOESNT_EXIST).dict(),
                     status_code=status.HTTP_404_NOT_FOUND)
+            if not self.pwd_context.verify(self.pass_decrypt.password_decrypt(reset_data.old_password).split("\"")[1],
+                                           db_user_data["password"]):
+                return JSONResponse(
+                    content=DefaultFailureResponse(status="failed",
+                                                   message=ErrorMessages.ERROR_PASSWORD_MISMATCH).dict(),
+                    status_code=status.HTTP_200_OK)
             try:
-            decrypted_password = self.pass_decrypt.password_decrypt(reset_data.new_password)
-        except TypeError:
+                response, password_encrypted = self.pass_decrypt.check_password_mismatch(reset_data.new_password,
+                                                                                         reset_data.confirm_password,
+                                                                                         reset_data.old_password)
+                if not response:
                     return JSONResponse(
                         content=DefaultFailureResponse(status="failed",
-                                               message=ErrorMessages.ERROR_INVALID_PASSWORD).dict(),
+                                                       message=password_encrypted).dict(),
                         status_code=status.HTTP_200_OK)
-        if not self.pwd_context.verify(decrypted_password.split("\"")[1], db_user_data["password"]):
+                if not password_encrypted:
                     return JSONResponse(
                         content=DefaultFailureResponse(status="failed",
-                                                       message=ErrorMessages.ERROR_PASSWORD_MISMATCH).dict(),
+                                                       message=ErrorMessages.ERROR_AUTH_FAILED).dict(),
+                        status_code=status.HTTP_200_OK)
+            except TypeError:
+                return JSONResponse(
+                    content=DefaultFailureResponse(status="failed",
+                                                   message=ErrorMessages.ERROR_INVALID_PASSWORD).dict(),
                     status_code=status.HTTP_200_OK)
             response = EncryptDecryptPassword().password_encrypt(reset_data.new_password)
             if not response:
@@ -273,6 +315,12 @@ class UserManagement:
             return JSONResponse(
                 content=DefaultSuccessResponse(status="success", message="Password Changed Successfully").dict(),
                 status_code=status.HTTP_200_OK)
+        except Exception as e:
+            logger.exception(f'Services Failed with error from reset user password {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_RESETTING_PASSWORD).dict(),
+                status_code=status.HTTP_200_OK)
 
     # user logout
     @staticmethod
@@ -295,4 +343,8 @@ class UserManagement:
             response.delete_cookie("login-token")
             return response
         except Exception as e:
-            logger.exception(e)
+            logger.exception(f'Services Failed with error from user logout {e}')
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_LOGOUT).dict(),
+                status_code=status.HTTP_200_OK)

scripts/database/mongo/mongo_db.py

@@ -58,9 +58,3 @@ class MongoUser(CollectionBaseClass):
         if user := self.delete_one(query=query):
             return user
         return None
-
-    # for filtering
-    def filter_data_aggregate(self, pipeline):
-        if user := self.aggregate(pipelines=pipeline):
-            return user
-        return None

scripts/errors/__init__.py

@@ -6,6 +6,7 @@ class ErrorMessages:
     ERROR_INVALID_LOGIN = "Your are not authorized to view this website."
     ERROR_ACCOUNT_DOESNT_EXIST = "Account Does Not Exist"
     ERROR_UNAUTHORIZED_USER_LOGIN = "Account is not available"
+    ERROR_IN_LOGIN = "Login Error"
     ERROR_UNAUTHORIZED_ACCESS = "Your are not authorized to view this page"
     ERROR_ACCESS_DENIED = "Access Denied!"
     ERROR_USER_NOT_REGISTERED = "Account is not registered in the portal."
@@ -18,6 +19,13 @@ class ErrorMessages:
     ERROR_INVALID_REQUEST = "Invalid Request"
     ERROR_USER_SESSION = "Not The Users Session"
     ERROR_TOKEN_EXPIRED = "Google Token Expired"
+    ERROR_IN_SENDING_MAIL = "Error In Sending Mail"
+    ERROR_IN_RESETTING_PASSWORD = "Password Reset Failed"
+    ERROR_IN_REGISTERING = "User Cannot Be Added"
+    ERROR_IN_DELETING = "User Deletion Error"
+    ERROR_IN_FETCHING_HEADER = "Header Fetch Failed"
+    ERROR_IN_LOGOUT = "Logout Failed"
+    ERROR_PASSWORD_FAILED = "Password Validation Failed"
 
     # Data Validation
     ERROR_INVALID_PASSWORD = "Invalid Password"
@@ -28,3 +36,6 @@ class ErrorMessages:
     ERROR_USER_ID_DOESNT_EXIST = "User Id doesn't exist"
     ERROR_USER_ID = "User Id Not Required"
     ERROR_INVALID_TOKEN = "Invalid Token"
+    ERROR_IN_VALIDATION = "Validation Failed"
+    ERROR_MISMATCH_CONFIRM = "New Password and Confirm Password Must Be Same"
+    ERROR_PASSWORD_EMPTY = "Password Cannot be Empty"

scripts/schemas/project_schema.py

@@ -25,7 +25,7 @@ class UserActions(BaseModel):
     user_id: Optional[str] = None
     name: Optional[str] = None
     email: Optional[str] = None
-    password: Optional[str]
+    password: Optional[str] = None
     phone_number: Optional[str] = None
     login_type: Optional[str] = None
     user_role: Optional[str] = None
@@ -41,6 +41,7 @@ class ResetPassword(BaseModel):
     user_id: str
     old_password: Optional[str] = None
     new_password: str
+    confirm_password: str
 
 
 class UserIDValidation(BaseModel):

scripts/services/v1/iot_manager_services.py

@@ -43,7 +43,7 @@ async def login_default_api(
                 detail=ErrorMessages.ERROR_INVALID_REQUEST)
 
     except Exception as e:
-        logger.exception(e)
+        logger.exception(f'Services Failed with error from login_default_api {e}')
         return JSONResponse(
             content=DefaultFailureResponse(status="failed",
                                            message=ErrorMessages.OP_FAILED).dict(),
@@ -58,9 +58,14 @@ async def forgot_password(
     try:
         # forgot password
         response = obj_login_handler.forgot_password_handler(validation_data.email)
+        if not response:
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_SENDING_MAIL).dict(),
+                status_code=status.HTTP_200_OK)
         return response
     except Exception as e:
-        logger.exception(e)
+        logger.exception(f'Services Failed with error from forgot password api {e}')
         return JSONResponse(
             content=DefaultFailureResponse(status="failed",
                                            message=ErrorMessages.OP_FAILED).dict(),
@@ -75,9 +80,14 @@ async def reset_password(
     try:
         # Get the JWT token from the query parameters
         response = obj_login_handler.validate_jwt(request)
+        if not response:
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_RESETTING_PASSWORD).dict(),
+                status_code=status.HTTP_200_OK)
         return response
     except Exception as e:
-        logger.exception(e)
+        logger.exception(f'Services Failed with error from get reset password api {e}')
         return JSONResponse(
             content=DefaultFailureResponse(status="failed",
                                            message=ErrorMessages.OP_FAILED).dict(),
@@ -92,9 +102,14 @@ async def reset_password(
     try:
         # Get the JWT token from the query parameters
         response = obj_login_handler.reset_user_password(reset_data)
+        if not response:
+            return JSONResponse(
+                content=DefaultFailureResponse(status="failed",
+                                               message=ErrorMessages.ERROR_IN_RESETTING_PASSWORD).dict(),
+                status_code=status.HTTP_200_OK)
         return response
     except Exception as e:
-        logger.exception(e)
+        logger.exception(f'Services Failed with error from post reset password api {e}')
         return JSONResponse(
             content=DefaultFailureResponse(status="failed",
                                            message=ErrorMessages.OP_FAILED).dict(),
@@ -135,7 +150,7 @@ async def user_management(
                 status_code=status.HTTP_403_FORBIDDEN,
                 detail=ErrorMessages.ERROR_INVALID_REQUEST)
     except Exception as e:
-        logger.exception(e)
+        logger.exception(f'Services Failed with error from user management api {e}')
         return JSONResponse(
             content=DefaultFailureResponse(status="failed",
                                            message=ErrorMessages.OP_FAILED).dict(),
@@ -163,7 +178,7 @@ async def user_view_header(
                 detail=ErrorMessages.ERROR_IN_FETCHING)
         return response
     except Exception as e:
-        logger.exception(e)
+        logger.exception(f'Services Failed with error from view users header api {e}')
         return JSONResponse(
             content=DefaultFailureResponse(status="failed",
                                            message=ErrorMessages.OP_FAILED).dict(),
@@ -190,7 +205,7 @@ async def user_view_data(
                 detail=ErrorMessages.ERROR_IN_FETCHING)
         return response
     except Exception as e:
-        logger.exception(e)
+        logger.exception(f'Services Failed with error from view users data api {e}')
         return JSONResponse(
             content=DefaultFailureResponse(status="failed",
                                            message=ErrorMessages.OP_FAILED).dict(),
@@ -211,14 +226,14 @@ async def user_change_password(
                 content=DefaultFailureResponse(status="failed",
                                                message=ErrorMessages.ERROR_UNAUTHORIZED_ACCESS).dict(),
                 status_code=status.HTTP_200_OK)
-        response = obj_user_handler.reset_password(reset_data)
+        response = obj_user_handler.reset_password(request, reset_data)
         if not response:
             return HTTPException(
                 status_code=status.HTTP_403_FORBIDDEN,
                 detail=ErrorMessages.ERROR_IN_FETCHING)
         return response
     except Exception as e:
-        logger.exception(f"From user change password - {e}")
+        logger.exception(f'Services Failed with error from change password api {e}')
         return JSONResponse(
             content=DefaultFailureResponse(status="failed",
                                            message=ErrorMessages.OP_FAILED).dict(),
@@ -245,7 +260,7 @@ async def dashboard_download_files(
                 detail=ErrorMessages.ERROR_IN_FETCHING)
         return response
     except Exception as e:
-        logger.exception(e)
+        logger.exception(f'Services Failed with error from download button api {e}')
         return JSONResponse(
             content=DefaultFailureResponse(status="failed",
                                            message=ErrorMessages.OP_FAILED).dict(),
@@ -268,7 +283,7 @@ async def user_logout(
                 detail=ErrorMessages.ERROR_IN_FETCHING)
         return response
     except Exception as e:
-        logger.exception(e)
+        logger.exception(f'Services Failed with error from logout api {e}')
         return JSONResponse(
             content=DefaultFailureResponse(status="failed",
                                            message=ErrorMessages.OP_FAILED).dict(),

scripts/utils/mongo_utils.py

@@ -60,3 +60,6 @@ class MongoStageCreator:
 
     def regex_stage(self, stage: dict) -> dict:
         return self.add_stage("$regex", stage)
+
+    def not_equal(self, stage: dict) -> dict:
+        return self.add_stage("$ne", stage)

scripts/utils/regex_validations.py

@@ -11,7 +11,8 @@ class RegexValidation:
             regex = re.fullmatch(r'^([A-Za-z]+)*$', str(name))
             return regex
         except Exception as e:
-            logger.error(f'An Error While listing the home plans {str(e)}')
+            logger.error(f'Error in name regex {str(e)}')
+            return None
 
     @staticmethod
     def phone_number_validation(phone_number):
@@ -19,7 +20,8 @@ class RegexValidation:
             regex = re.fullmatch('([0-9]{1,20})', str(phone_number))
             return regex
         except Exception as e:
-            logger.error(f'An Error While listing the home plans {str(e)}')
+            logger.error(f'An Error in phone number regex {str(e)}')
+            return None
 
     @staticmethod
     def password_validation(password):
@@ -29,4 +31,5 @@ class RegexValidation:
                 return False
 
         except Exception as e:
-            logger.error(f'An Error While listing the home plans {str(e)}')
+            logger.error(f'Error in password regex {str(e)}')
+            return None

scripts/utils/security/authorize_access.py

 from typing import Optional
 
 from scripts.database.mongo.mongo_db import MongoUser
+from scripts.logging.logger import logger
 from scripts.schemas.project_schema import ResetPassword
 
 obj_mongo_user = MongoUser()
@@ -18,9 +19,13 @@ class AuthorizeAccess:
             return True
         except TypeError:
             return False
+        except Exception as e:
+            logger.error(f'Services Failed with error from authorize access {e}')
+            return False
 
     @staticmethod
     def login_authorize(request, reset_data: Optional[ResetPassword] = None):
+        try:
             if reset_data is not None:
                 if reset_data.user_id != request.user_id:
                     return False
@@ -28,3 +33,6 @@ class AuthorizeAccess:
             if request.user_id:
                 return True
             return False
+        except Exception as e:
+            logger.error(f'Services Failed with error from login authorize {e}')
+            return False

scripts/utils/security/jwt_util.py

@@ -20,11 +20,7 @@ class JWT:
 
     # decoding the payload
     def decode(self, token):
-        try:
         return jwt.decode(token, self.key, algorithms=self.alg)
-        except Exception as e:
-            logging.exception(f"Exception while encoding JWT: {str(e)}")
-            raise
 
     # validate the payload
     def validate(self, token):
@@ -39,3 +35,4 @@ class JWT:
 
         except Exception as e:
             logging.exception(f"Exception while validating JWT: {str(e)}")
+            raise

scripts/utils/security/password_util.py

 import base64
+from typing import Optional
+
 from Cryptodome.Cipher import AES
 from passlib.context import CryptContext
 
 from scripts.config import Secrets, Services
+from scripts.errors import ErrorMessages
 from scripts.logging.logger import logger
 
 
@@ -36,10 +39,12 @@ class EncryptDecryptPassword:
             data = self.un_pad(data)
             return data.decode(Services.ENCODING_TYPE)
         except Exception as e:
-            logger.exception(e)
+            logger.error(f'Services Failed with error from password util password decrypt {e}')
+            return None
 
     # encrypting the password
     def password_encrypt(self, password):
+        try:
             # decrypting the UI password
             decrypted_password = self.password_decrypt(password)
             # hashing the decrypted password
@@ -47,3 +52,24 @@ class EncryptDecryptPassword:
                 return None
             hashed_password = self.pwd_context.hash(decrypted_password.split("\"")[1])
             return hashed_password
+        except Exception as e:
+            logger.error(f'Services Failed with error from password util password encrypt {e}')
+            return None
+
+    def check_password_mismatch(self, new_password, confirm_password, old_password: Optional[str] = None):
+        try:
+            # decrypting the UI password
+            password_decrypted = self.password_decrypt(new_password)
+            confirm_decrypted = self.password_decrypt(confirm_password)
+            if password_decrypted != confirm_decrypted:
+                return None, ErrorMessages.ERROR_MISMATCH_CONFIRM
+            # hashing the decrypted password
+            if confirm_decrypted is None:
+                return None, ErrorMessages.ERROR_PASSWORD_EMPTY
+            if old_password is not None:
+                return True, confirm_decrypted
+            hashed_password = self.pwd_context.hash(confirm_decrypted.split("\"")[1])
+            return True, hashed_password
+        except Exception as e:
+            logger.error(f'Services Failed with error from password util check password mismatch {e}')
+            return None, ErrorMessages.ERROR_PASSWORD_FAILED

scripts/utils/validations_util.py

@@ -12,36 +12,33 @@ class UserDataValidations:
     def register_data_validation(user_data, method, feature):
         try:
             if user_data.name == "":
-                return False, {"message": ErrorMessages.ERROR_INVALID_NAME,
-                               "data": user_data.phone_number}
+                return False, ErrorMessages.ERROR_INVALID_NAME
             # checking for valid username
             if user_data.email == "" or validate_email(
                     user_data.email) is not True:
-                return False, {"message": ErrorMessages.ERROR_INVALID_EMAIL, "data": user_data.email}
+                return False, ErrorMessages.ERROR_INVALID_EMAIL
             # checking for valid password
             if method == 'general':
                 if user_data.password == "" or user_data.password == "string":
-                    return False, {"message": ErrorMessages.ERROR_INVALID_PASSWORD, "data": user_data.password}
+                    return False, ErrorMessages.ERROR_INVALID_PASSWORD
                 # Validate phone number
                 if user_data.phone_number == "":
-                    return False, {"message": ErrorMessages.ERROR_INVALID_PHONE_NUMBER,
-                                   "data": user_data.phone_number}
+                    return False, ErrorMessages.ERROR_INVALID_PHONE_NUMBER
             if user_data.user_role == "" and method == 'general' and feature == 'register':
-                return False, {"message": ErrorMessages.ERROR_INVALID_USER_ROLE,
-                               "data": user_data.phone_number}
+                return False, ErrorMessages.ERROR_INVALID_USER_ROLE
             return True, None
         except Exception as e:
-            logger.exception(e)
+            logger.error(f'Register data validation error {e}')
+            return False, ErrorMessages.ERROR_IN_VALIDATION
 
     @staticmethod
     def update_data_validation(user_data):
         try:
             if user_data.name == "":
-                return False, {"message": ErrorMessages.ERROR_INVALID_NAME,
-                               "data": user_data.phone_number}
+                return False, ErrorMessages.ERROR_INVALID_NAME
             if user_data.user_role == "":
-                return False, {"message": ErrorMessages.ERROR_INVALID_USER_ROLE,
-                               "data": user_data.phone_number}
+                return False, ErrorMessages.ERROR_INVALID_USER_ROLE
             return True, None
         except Exception as e:
-            logger.exception(e)
+            logger.error(f'Update data validation error {e}')
+            return False, ErrorMessages.ERROR_IN_VALIDATION