Upload 258 files

.gitattributes

@@ -38,3 +38,12 @@ tests/test_service/user_file/quangphuc@gmail.com/demo1.pdf filter=lfs diff=lfs m
 tests/user_file/quangphuc@gmail.com/demo1.pdf filter=lfs diff=lfs merge=lfs -text
 vector_database/vonhuy5112002@gmail.com/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
 vector_database/vonhuy777@gmail.com/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+user_file/20133118@student.hcmute.edu.vn/DEMO2.pdf filter=lfs diff=lfs merge=lfs -text
+user_file/vonhuy5112002@gmail.com/Nhom05_FinalProject3.docx filter=lfs diff=lfs merge=lfs -text
+user_file/vonhuy5112002@gmail.com/Report-ChatGPT.docx filter=lfs diff=lfs merge=lfs -text
+user_file/vonhuy777@gmail.com/DEMO2.pdf filter=lfs diff=lfs merge=lfs -text
+vector_database/20133118@student.hcmute.edu.vn/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+vector_database/20133118@student.hcmute.edu.vn/DEMO1.docx/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+vector_database/20133118@student.hcmute.edu.vn/DEMO2.pdf/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+vector_database/vonhuy5112002@gmail.com/Nhom05_FinalProject3.docx/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+vector_database/vonhuy777@gmail.com/DEMO2.pdf/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text

auth/authentication.py

@@ -0,0 +1,133 @@
+import time
+from typing import Dict
+import jwt
+import secrets
+import logging
+from fastapi import Depends, HTTPException
+import base64
+from datetime import datetime, timedelta
+from repository import UserRepository, UserLoginRepository
+import string, random
+
+def check_token_is_valid(token):
+    check = UserRepository.getEmailUserByAccessToken(token)
+    if check is None:
+        return False
+    return True
+
+def unique_string(byte: int = 8) -> str:
+    return secrets.token_urlsafe(byte)
+JWT_SECRET = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
+JWT_ALGORITHM = "HS512"
+SECRET_KEY= "8deadce9449770680910741063cd0a3fe0acb62a8978661f421bbcbb66dc41f1"
+
+def token_response(token: str):
+    return {
+        "access_token": token
+    }
+def str_encode(string: str) -> str:
+    return base64.b85encode(string.encode('ascii')).decode('ascii')
+
+def get_token_payload(token: str, secret: str, algo: str):
+    try:
+        payload = jwt.decode(token, secret, algorithms=algo)
+    except Exception as jwt_exec:
+        logging.debug(f"JWT Error: {str(jwt_exec)}")
+        payload = None
+    return payload
+
+from datetime import datetime
+def generate_token(payload: dict, secret: str, algo: str, expiry: timedelta):
+    expire = datetime.now() + expiry
+    payload.update({"exp": expire})
+    return jwt.encode(payload, secret, algorithm=algo)
+
+def str_decode(string: str) -> str:
+    return base64.b85decode(string.encode('ascii')).decode('ascii')
+
+def generate_random_string(length=12):
+    characters = string.ascii_letters + string.digits
+    random_string = ''.join(random.choice(characters) for i in range(length))
+    return random_string
+
+import pytz
+from datetime import datetime
+def signJWT(user_email: str) -> Dict[str, str]:
+    rt_expires = timedelta(days=3)
+    refresh_key = unique_string(100)
+    access_key = unique_string(50)
+    at_expires = timedelta(minutes=180)
+    at_payload = {
+        "sub": str_encode(str(user_email)),
+        'a': access_key,
+    }
+    access_token = generate_token(at_payload, JWT_SECRET, JWT_ALGORITHM, at_expires)
+    rt_payload = {"sub": str_encode(str(user_email)), "t": refresh_key, 'a': access_key}
+    refresh_token = generate_token(rt_payload, SECRET_KEY,JWT_ALGORITHM, rt_expires)
+    expires_in = at_expires.seconds
+    vn_timezone = pytz.timezone('Asia/Ho_Chi_Minh')
+    current_time = datetime.now().replace(tzinfo=pytz.utc).astimezone(vn_timezone) + timedelta(seconds=expires_in)
+    formatted_time = current_time.strftime('%Y-%m-%d %H:%M:%S ')
+    existing_user = UserRepository.getUserByEmail(user_email)
+    if existing_user is None:
+        UserRepository.addUser(user_email, access_token, refresh_token, formatted_time)
+    else:
+        UserRepository.updateUserLogin(user_email, access_token, refresh_token, formatted_time)
+    user_record = UserRepository.getUserByEmail(user_email)
+    session_id = ""
+    if user_record:
+        session_id = generate_random_string()
+        existing_userlogin = UserLoginRepository.getUserLogin(user_email)
+        if existing_userlogin is None:
+            UserLoginRepository.addUserLogin(user_email,session_id=session_id)
+        else:
+            UserLoginRepository.updateUserLogin(user_email, session_id)
+    return {
+        "access_token": access_token,
+        "refresh_token": refresh_token,
+        "expires_in": at_expires.seconds,
+        "session_id": session_id
+     }
+
+def returnAccessToken(user_email: str, refresh_token: str) -> Dict[str, str]:
+    access_key = unique_string(50)
+    at_expires = timedelta(minutes=180)
+    at_payload = {
+        "sub": str_encode(str(user_email)),
+        'a': access_key,
+    }
+    access_token = generate_token(at_payload, JWT_SECRET, JWT_ALGORITHM, at_expires)
+    user_record = UserRepository.getUserByEmail(user_email)
+    session_id = ""
+    if user_record:
+        email1 = user_record.email
+    if email1:
+        session_id = generate_random_string()
+        existing_userlogin = UserLoginRepository.getUserLogin(user_email)
+        if existing_userlogin is None:
+            UserLoginRepository.addUserLogin(user_email,session_id=session_id)
+        else:
+            UserLoginRepository.updateUserLogin(user_email,session_id)
+    return {
+        "access_token": access_token,
+        "refresh_token": refresh_token,
+        "expires_in": at_expires.seconds,
+        "session_id": session_id
+    }
+
+def decodeJWT(token: str) -> dict:
+    try:
+        decoded_token = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM])
+        return decoded_token if decoded_token["exp"] >= time.time() else None
+    except:
+        return {}
+    
+def get_refresh_token(refresh_token, email):
+    token_payload = get_token_payload(refresh_token, SECRET_KEY, JWT_ALGORITHM)
+    if not token_payload:
+        raise HTTPException(status_code=403, detail="Invalid Request.")
+    exp = token_payload.get('exp')
+    if exp >= time.time() and token_payload:
+       return returnAccessToken(email,refresh_token)
+    elif not token_payload:
+       return signJWT(email)

controller/AuthenticationController.py

@@ -0,0 +1,63 @@
+from fastapi import APIRouter, Query
+from request import RequestAuth
+from response import ResponseAuth as res
+from service import AuthService
+from function import support_function
+from fastapi import HTTPException
+router = APIRouter()
+
+@router.post('/login', tags=["Authentication"])
+async def login(request: RequestAuth.RequestLoginEmail):
+    email = request.email
+    check = support_function.check_value_email_controller(email)
+    if check is not True:
+        return check
+    password = request.password
+    if password is None or password.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Password is required."))
+    return await AuthService.login(request)
+
+@router.post('/login_google', tags=["Authentication"])
+async def login_google(request: RequestAuth.RequestLoginGoogle):
+    email = request.email
+    token_google = request.token_google
+    check = support_function.check_value_email_controller(email)
+    if check is not True:
+        return check
+    if token_google is None or token_google.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="token_google oauth2 is required."))
+    if token_google.isdigit():
+        return res.ReponseError(status=400,
+                                data=res.Message(message="token_google must be a string, not a number."))
+    return await AuthService.login_google(request)
+
+@router.post('/sign_up', tags=["Authentication"])
+async def signup(request: RequestAuth.RequestRegister):
+    email = request.email
+    check = support_function.check_value_email_controller(email)
+    if check is not True:
+        return check
+    password = request.password
+    confirm_password = request.confirm_password
+    if password is None or password.strip( )== "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Password is required."))
+    if confirm_password is None or confirm_password.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Confirm Password is required."))
+    return await AuthService.sign_up(request)
+
+
+@router.post('/refresh_token', tags=["Authentication"])
+async def refresh_token_account(request: RequestAuth.RequestRefreshTokenLogin):
+    token = request.refresh_token
+    if token is None or token.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="token is required."))
+    elif token.isdigit():
+        return res.ReponseError(status=400,
+                                data=res.Message(message="token must be string"))
+
+    return await AuthService.refresh_token(request)

controller/ChatController.py

@@ -0,0 +1,37 @@
+from fastapi import APIRouter, Form, Request
+from service import ChatService
+from request import RequestChat
+from typing import Optional
+from fastapi.requests import Request
+from function import support_function
+from response import ResponseChat as res
+from fastapi import  Path,Query
+router = APIRouter()
+
+@router.post("/chatbot/query", tags=["Chat"])
+async def handle_query2_upgrade_old(request: Request,
+                                    user_id: str = Form(None),
+                                    text_all: str = Form(...),
+                                    question: Optional[str] = Form(None),
+                                    chat_name: Optional[str] = Form(None)):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    request = RequestChat.RequestQuery2UpgradeOld(user_id=user_id, text_all=text_all, question=question, chat_name=chat_name)
+    return await ChatService.query2_upgrade_old(request)
+
+@router.get("/chatbot/extract_file/{user_id}", tags=["Chat"])
+async def extract_file(user_id: str):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    request = RequestChat.RequestExtractFile(user_id=user_id)
+    return await ChatService.extract_file(request)
+
+@router.get("/chatbot/generate_question/{user_id}",tags=["Chat"])
+async def generate_question(user_id: str):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    request = RequestChat.RequestGenerateQuestion(user_id=user_id)
+    return await ChatService.generate_question(request)

controller/DefaultController.py

@@ -0,0 +1,75 @@
+from fastapi import HTTPException, Depends, Query,APIRouter
+from service import DefaultService
+from request import RequestDefault
+from request import RequestDefault as req
+from function import support_function
+from auth.authentication import decodeJWT
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.responses import JSONResponse
+from auth import authentication
+from fastapi.requests import Request
+from response import ResponseDefault as res
+from fastapi import  File, UploadFile, Form
+router = APIRouter()
+
+@router.get("/is_me", tags=["Default"])
+async def is_me(token: str = Query(...)):
+    if token.strip() == "" or token is None:
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Token field is required."))
+    if token.lower() == "none":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Token cannot be None."))
+    if not isinstance(token, str):
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Token must be a non-empty string."))
+    try:
+        float(token)
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Token must be a string, not a number."))
+    except ValueError:
+        pass
+    request = RequestDefault.RequestIsMe(token=token)
+    return await DefaultService.is_me(request)
+
+@router.post('/create_firebase_user_google', tags=["Default"])
+async def get_or_create_firebase_user(request: RequestDefault.RequestCreateFireBaseUserGoogle):
+    email = request.email
+    check = support_function.check_value_email_controller(request.email)
+    if check is not True:
+        return check
+    token_google = request.token_google
+    if token_google == "" or token_google is None:
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Token field is required."))
+    if not isinstance(token_google, str):
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Token must be a non-empty string."))
+    try:
+        float(token_google)
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Token must be a string, not a number."))
+    except ValueError:
+        pass
+    return await DefaultService.create_firebase_user(request)
+
+@router.get("/info_user/{user_id}", tags=["Default"])
+async def get_user(user_id: str):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    request = RequestDefault.RequestInfoUser(user_id=user_id)
+    return await DefaultService.info_user(request)
+
+ALLOWED_IMAGE_EXTENSIONS = {"jpeg", "jpg", "png"}
+
+def allowed_file(filename: str) -> bool:
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_IMAGE_EXTENSIONS
+
+@router.post("/upload_image", tags=["Default"])
+async def upload_image(user_id: str = Form(None), file: UploadFile = File(...)):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    request = req.RequestUpLoadImage(user_id=user_id, files= file)
+    return await DefaultService.upload_image_service(request)

controller/FileController.py

@@ -0,0 +1,64 @@
+from fastapi import APIRouter, Form, File, UploadFile,Query
+from typing import List,Optional
+from service import FileService
+from function import support_function
+from fastapi import HTTPException
+from response import ResponseFile as res
+from request import RequestFile
+router = APIRouter()
+
+ALLOWED_EXTENSIONS = {'csv', 'txt', 'doc', 'docx', 'pdf', 'xlsx', 'pptx', 'json', 'html'}
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+@router.delete("/delete", tags=["File"])
+async def delete_folder(request: RequestFile.RequestDeleteAllFile):
+    check = support_function.check_value_user_id_controller(request.user_id)
+    if check is not True:
+        return check
+    # request = RequestFile.RequestDeleteAllFile(user_id=user_id)
+    return  await FileService.deleteAllFile(request)
+
+@router.get("/list_name_files", tags=["File"])
+async def get_name(user_id: str):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    request = RequestFile.RequestGetNameFile(user_id=user_id)
+    return await FileService.listNameFiles(request)
+
+@router.delete("/delete_file", tags=["File"])
+async def delete_one_file(request: RequestFile.RequestDeleteFile):
+    user_id = request.user_id
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    name_file = request.name_file
+    if name_file is None or name_file.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Name file is required."))
+    return await FileService.deleteFile(request)
+
+@router.post("/chatbot/download_folder", tags=["File"])
+async def download_folder_from_dropbox(request: RequestFile.RequestDownLoadFolder):
+    user_id = request.user_id
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    return await FileService.download_folder(request)
+
+@router.post("/chatbot/download_files", tags=["File"])
+async def download_file_by_id(request: RequestFile.RequestDownLoadFile):
+    user_id = request.user_id
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    return await FileService.download_file(request)
+
+@router.post("/upload_files", tags=["File"])
+async def upload_files_dropbox(user_id: str = Form(None), files: Optional[List[UploadFile]] = File(None)):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    request = RequestFile.RequestUploadFile(files=files, user_id=user_id)
+    return await FileService.upload_files(request)

controller/MySQLController.py

@@ -0,0 +1,94 @@
+from fastapi import Query, APIRouter
+from service import MySQLService
+from request import RequestMySQL
+from response import ResponseMySQL as res
+from typing import Optional
+from request import RequestMySQL as req
+from function import support_function
+from fastapi import HTTPException
+router = APIRouter()
+
+@router.get("/chat_history/{user_id}", tags=["MySQL"])
+async def render_chat(user_id: str):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    request = RequestMySQL.RequestRenderChatHistory(user_id=user_id)
+    return await MySQLService.render_chat_history(request)
+
+@router.get("/data_relevant/{detail_chat_id}", tags=["MySQL"])
+async def render_chat_1(detail_chat_id: str):
+    if detail_chat_id is None or detail_chat_id.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Id field is required."))
+    detail_chat_id = detail_chat_id.strip("'").strip('"')
+    try:
+        detail_chat_id_int = int(detail_chat_id)
+    except ValueError:
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Value must be an integer"))
+    if not support_function.is_positive_integer(detail_chat_id_int):
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Value must be greater than 0"))
+    request = req.RequestGetChatDetails(id=detail_chat_id)
+    return await MySQLService.get_detail_chat_by_chat_id(request)
+
+@router.get("/detail_chat/{user_id}/{chat_id}", tags=["MySQL"])
+async def load_chat(chat_id: str, user_id: str):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    if chat_id is None or chat_id.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Chat id field is required."))
+    chat_id = chat_id.strip("'").strip('"')
+    try:
+        chat_id_int = int(chat_id)
+    except ValueError:
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Value must be an integer"))
+    if not support_function.is_positive_integer(chat_id_int):
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Value must be greater than 0"))
+    request = req.RequestLoadChatHistory(chat_id=chat_id,user_id = user_id)
+    return await MySQLService.load_chat_history(request)
+
+@router.put("/edit_chat",  tags=["MySQL"])
+async def edit_chat(request: RequestMySQL.RequestEditNameChat):
+    user_id = request.user_id
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    return await MySQLService.edit_chat(request)
+
+@router.delete("/chat_history/delete",  tags=["MySQL"])
+async def delete_chat(request: RequestMySQL.RequestDeleteChat):
+    user_id = request.user_id
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    return await MySQLService.delete_chat(request)
+
+@router.delete("/detail_chat/delete",  tags=["MySQL"])
+async def delete_chat_detail(request: RequestMySQL.RequestDeleteDetailChat):
+    user_id = request.user_id
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    return await MySQLService.delete_chat_detail_by_id(request)
+
+@router.post("/chat_history/create", tags=["MySQL"])
+async def create_chat_history(request: RequestMySQL.RequestCreateChatHistory):
+    user_id = request.user_id
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    return await MySQLService.create_chat_history(request)
+
+@router.delete("/chat_history/delete_last_chat_record", tags=["MySQL"])
+async def delete_last_chat_record(request: RequestMySQL.RequestStopChat):
+    user_id = request.user_id
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    return await MySQLService.delete_last_chat_detail_by_chat_name(request)

controller/OTPController.py

@@ -0,0 +1,37 @@
+from fastapi import APIRouter
+from function import support_function
+from request import RequestOTP
+from service import OTPService
+from fastapi import HTTPException
+from pydantic.error_wrappers import ErrorWrapper
+from pydantic import BaseModel
+from response import ResponseOTP as res
+router = APIRouter()
+
+@router.post('/create_otp', tags=["OTP"])
+async def create_otp(request:  RequestOTP.RequestCreateOTP):
+    email = request.email
+    check = support_function.check_value_email_controller(email)
+    if check is not True:
+        return check
+    return await OTPService.createOTP(request)
+
+@router.post('/verify_otp', tags=["OTP"])
+async def verify_otp(request:  RequestOTP.RequestVerifyOTP):
+    check = support_function.check_value_email_controller(request.email)
+    if check is not True:
+        return check
+    check_otp = support_function.check_value_otp(request.otp)
+    if check_otp is not True:
+        return check_otp
+    return await OTPService.verifyOTP(request)
+
+@router.post('/verify_otp_reset_password', tags=["OTP"])
+async def verify_otp_reset(request: RequestOTP.RequestVerifyOTP):
+    check = support_function.check_value_email_controller(request.email)
+    if check is not True:
+        return check
+    check_otp = support_function.check_value_otp(request.otp)
+    if check_otp is not True:
+        return check_otp
+    return await OTPService.verifyOTPReset(request)

controller/UserController.py

@@ -0,0 +1,96 @@
+from fastapi import APIRouter, Query
+from request import RequestUser
+from response import ResponseUser as res
+from service import UserService
+from function import support_function
+from fastapi import HTTPException
+from response import ResponseUser as res
+router = APIRouter()
+
+@router.put("/update_user_info", tags=["User"])
+async def update_user_info(request: RequestUser.RequestUpdateUserInfo):
+    user_id = request.user_id
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    uid = request.uid
+    email = request.email
+    display_name = request.display_name
+    photo_url = request.photo_url
+    if uid is None or uid.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="uid field is required.")) 
+    if email is None or email.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="email field is required."))
+    if display_name is None or display_name.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="display_name field is required."))
+    if photo_url is None or photo_url.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="photo_url field is required."))
+    return await UserService.update_user_info(request)
+
+@router.get('/check_info_google', tags=["User"])
+async def check_info_google(user_id: str = Query(None)):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    request =RequestUser.RequestCheckInfoGoogle(user_id=user_id)
+    return await UserService.check_info_google(request)
+
+@router.get('/check_info_google_signup', tags=["User"])
+async def check_info_google_signup(email: str = None):
+    check = support_function.check_value_email_controller(email)
+    if check is not True:
+        return check
+    request =RequestUser.RequestCheckInfoGoogleEmail(email=email)
+    return await UserService.check_info_google_email(request)
+
+@router.get('/check_state_login', tags=["User"])
+async def check_state_login(user_id: str = Query(None), session_id_now: str = Query(None)):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    if session_id_now is None or session_id_now.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Session Id is required."))
+    try:
+        int(session_id_now)
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Session Id must be a string, not a number."))
+    except ValueError:
+        pass
+    request =RequestUser.RequestCheckStateLogin(user_id=user_id, session_id_now=session_id_now)
+    return await UserService.check_state_login(request)
+
+
+@router.post('/reset_password', tags=["User"])
+async def reset_password(request:RequestUser.RequestResetPassword):
+    email = request.email
+    check = support_function.check_value_email_controller(email)
+    if check is not True:
+        return check
+    return await UserService.reset_password(request)
+
+@router.put('/change_password', tags=["User"])
+async def reset_password_firebase(request:RequestUser.RequestChangePassword):
+    user_id = request.user_id
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    new_password = request.new_password
+    current_password = request.current_password
+    confirm_new_password = request.confirm_new_password
+    if confirm_new_password is None or confirm_new_password.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Confirm New password field is required."))
+    elif new_password is None or new_password.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="New password field is required."))
+    elif current_password is None or current_password.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Current password field is required."))
+    return await UserService.change_password(request)
+
+

controller/__pycache__/ChatController.py

@@ -0,0 +1,35 @@
+from fastapi import APIRouter, Form, Request
+from service import ChatService
+from request import RequestChat
+from typing import Optional
+from fastapi.requests import Request
+from function import support_function
+from response import ResponseChat as res
+router = APIRouter()
+
+@router.post("/chatbot/query/", tags=["Chat"])
+async def handle_query2_upgrade_old(request: Request,
+                                    user_id: str = Form(None),
+                                    text_all: str = Form(...), question: Optional[str] = Form(None),
+                                    chat_name: Optional[str] = Form(None)):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    request = RequestChat.RequestQuery2UpgradeOld(user_id=user_id, text_all=text_all, question=question, chat_name=chat_name)
+    return ChatService.query2_upgrade_old(request)
+
+@router.get("/chatbot/extract_file/", tags=["Chat"])
+async def extract_file(user_id: str):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    request = RequestChat.RequestExtractFile(user_id=user_id)
+    return ChatService.extract_file(request)
+
+@router.get("/chatbot/generate_question/",tags=["Chat"])
+async def generate_question(user_id: str):
+    check = support_function.check_value_user_id_controller(user_id)
+    if check is not True:
+        return check
+    request = RequestChat.RequestGenerateQuestion(user_id=user_id)
+    return ChatService.generate_question(request)

function/chatbot.py

@@ -0,0 +1,726 @@
+from langchain.text_splitter import CharacterTextSplitter
+import json
+import os
+import random
+import re
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import google.generativeai as genai
+import nltk
+import pandas as pd
+from groq import Groq
+from langchain.chains.summarize import load_summarize_chain
+from langchain.docstore.document import Document
+from langchain.prompts import PromptTemplate
+from langchain.retrievers import BM25Retriever, EnsembleRetriever
+from langchain.retrievers.contextual_compression import ContextualCompressionRetriever
+from langchain.text_splitter import CharacterTextSplitter
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_cohere import CohereRerank
+from langchain_community.document_loaders import Docx2txtLoader
+from langchain_community.document_loaders import TextLoader
+from langchain_community.document_loaders import UnstructuredCSVLoader
+from langchain_community.document_loaders import UnstructuredExcelLoader
+from langchain_community.document_loaders import UnstructuredHTMLLoader
+from langchain_community.document_loaders import UnstructuredMarkdownLoader
+from langchain_community.document_loaders import UnstructuredPDFLoader
+from langchain_community.document_loaders import UnstructuredPowerPointLoader
+from langchain_community.document_loaders import UnstructuredXMLLoader
+from langchain_community.document_loaders.csv_loader import CSVLoader
+from langchain_community.llms import Cohere
+from langchain_community.vectorstores import Chroma
+from langchain_core.output_parsers.openai_tools import PydanticToolsParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain_core.runnables import RunnablePassthrough
+from langchain_openai import ChatOpenAI
+from typing import List
+from nltk.corpus import stopwords
+from nltk.tokenize import word_tokenize
+nltk.download('punkt')
+
+def process_json_file(file_path):
+    json_data = []
+    with open(file_path, 'r') as file:
+        for line in file:
+            try:
+                data = json.loads(line)
+                json_data.append(data)
+            except json.JSONDecodeError:
+                try:
+                    data = json.loads(line[:-1])
+                    json_data.append(data)
+                except json.JSONDecodeError as e:
+                    print(f"Error decoding JSON: {e}")
+    return json_data
+
+from dotenv import load_dotenv
+import os
+load_dotenv()
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+COHERE_API_KEY = os.getenv("COHERE_API_KEY")
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+GOOGLE_API_KEY1= os.getenv("GOOGLE_API_KEY_1")
+GOOGLE_API_KEY= os.getenv("GOOGLE_API_KEY")
+os.environ["COHERE_API_KEY"] = COHERE_API_KEY
+os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+client = Groq(
+    api_key= GROQ_API_KEY,
+)
+genai.configure(api_key=GOOGLE_API_KEY1)
+os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
+from langchain_google_genai import GoogleGenerativeAIEmbeddings, ChatGoogleGenerativeAI
+embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001", task_type="retrieval_document")
+llm = ChatGoogleGenerativeAI(model='gemini-pro',
+                             max_output_tokens=2048,
+                             temperature=0.2,
+                             convert_system_message_to_human=True)
+def extract_multi_metadata_content(texts, tests):
+    extracted_content = []
+    precomputed_metadata = [x.metadata['source'].lower() for x in texts]
+    for idx, test in enumerate(tests):
+        temp_content = []
+        test_terms = set(test.lower().split())
+        for metadata_lower, x in zip(precomputed_metadata, texts):
+            if any(term in metadata_lower for term in test_terms):
+                temp_content.append(x.page_content)
+        if idx == 0:
+            extracted_content.append(f"Dữ liệu của {test}:\n{''.join(temp_content)}")
+        else:
+            extracted_content.append(''.join(temp_content))
+    return '\n'.join(extracted_content)
+import unicodedata
+def text_preprocessing(text):
+    text = text.lower()
+    emoji_pattern = re.compile("["
+                               u"\U0001F600-\U0001F64F"  # emoticons
+                               u"\U0001F300-\U0001F5FF"  # symbols & pictographs
+                               u"\U0001F680-\U0001F6FF"  # transport & map symbols
+                               u"\U0001F1E0-\U0001F1FF"  # flags (iOS)
+                               u"\U00002500-\U00002BEF"  # chinese char
+                               u"\U00002702-\U000027B0"
+                               u"\U000024C2-\U0001F251"
+                               u"\U0001f926-\U0001f937"
+                               u"\U00010000-\U0010ffff"
+                               u"\u2640-\u2642"
+                               u"\u2600-\u2B55"
+                               u"\u200d"
+                               u"\u23cf"
+                               u"\u23e9"
+                               u"\u231a"
+                               u"\ufe0f"  # dingbats
+                               u"\u3030"
+                               "]+", flags=re.UNICODE)
+    text = emoji_pattern.sub(r'', text)
+    text = unicodedata.normalize('NFC', text)
+    words = text.split()
+    text = ' '.join(words)
+    return text
+def find_matching_files_in_docs_12_id(text, id):
+    folder_path = f"./user_file/{id}"
+    search_terms = []
+    search_terms_old = []
+    matching_index = []
+    search_origin = re.findall(r'\b\w+\.\w+\b|\b\w+\b', text)
+    search_terms_origin = []
+    for word in search_origin:
+        if '.' in word:
+            search_terms_origin.append(word)
+        else:
+            search_terms_origin.extend(re.findall(r'\b\w+\b', word))
+
+    file_names_with_extension = re.findall(r'\b\w+\.\w+\b|\b\w+\b', text.lower())
+    file_names_with_extension_old = re.findall(r'\b(\w+\.\w+)\b', text)
+    for file_name in search_terms_origin:
+        if "." in file_name:
+            search_terms_old.append(file_name)
+    for file_name in file_names_with_extension_old:
+        if "." in file_name:
+            search_terms_old.append(file_name)
+    for file_name in file_names_with_extension:
+        search_terms.append(file_name)
+    clean_text_old = text
+    clean_text = text.lower()
+    for term in search_terms_old:
+        clean_text_old = clean_text_old.replace(term, '')
+    for term in search_terms:
+        clean_text = clean_text.replace(term, '')
+    words_old = re.findall(r'\b\w+\b', clean_text_old)
+    search_terms_old.extend(words_old)
+    matching_files = set()
+    for root, dirs, files in os.walk(folder_path):
+        for file in files:
+            for term in search_terms:
+                if term.lower() in file.lower():
+                    term_position = search_terms.index(term)
+                    matching_files.add(file)
+                    matching_index.append(term_position)
+                    break
+    matching_files_old1 = []
+    matching_index.sort()
+    for x in matching_index:
+        matching_files_old1.append(search_terms_origin[x])
+    return matching_files, matching_files_old1
+
+def convert_xlsx_to_csv(xlsx_file_path, csv_file_path):
+    df = pd.read_excel(xlsx_file_path)
+    df.to_csv(csv_file_path, index=False)
+
+def save_list_CSV_id(file_list, id):
+    text = ""
+    for x in file_list:
+        if x.endswith('.xlsx'):
+            old = f"./user_file/{id}/{x}"
+            new = old.replace(".xlsx", ".csv")
+            convert_xlsx_to_csv(old, new)
+            x = x.replace(".xlsx", ".csv")
+        loader1 = CSVLoader(f"./user_file/{id}/{x}")
+        docs1 = loader1.load()
+        text += f"Dữ liệu file {x}:\n"
+        for z in docs1:
+            text += z.page_content + "\n"
+    return text
+
+def merge_files(file_set, file_list):
+    """Hàm này ghép lại các tên file dựa trên điều kiện đã cho."""
+    merged_files = {}
+    for file_name in file_list:
+        name = file_name.split('.')[0]
+        for f in file_set:
+            if name in f:
+                merged_files[name] = f
+                break
+    return merged_files
+
+def replace_keys_with_values(original_dict, replacement_dict):
+    new_dict = {}
+    for key, value in original_dict.items():
+        if key in replacement_dict:
+            new_key = replacement_dict[key]
+            new_dict[new_key] = value
+        else:
+            new_dict[key] = value
+    return new_dict
+
+def aws1_csv_id(new_dict_csv, id):
+    text = ""
+    query_all = ""
+    keyword = []
+    for key, value in new_dict_csv.items():
+        print(key, value)
+        query_all += value
+        keyword.append(key)
+        test = save_list_CSV_id(keyword, id)
+        text += test
+    sources = ",".join(keyword)
+    return text, query_all, sources
+
+def chat_llama3(prompt_query):
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {
+                    "role": "system",
+                    "content": "Bạn là một trợ lý trung thưc, trả lời dựa trên nội dung tài liệu được cung cấp. Chỉ trả lời liên quan đến câu hỏi một cách đầy đủ chính xác, không bỏ sót thông tin."
+                },
+                {
+
+                    "role": "user",
+                    "content": f"{prompt_query}",
+                }
+            ],
+            model="llama3-70b-8192",
+            temperature=0.0,
+            max_tokens=9000,
+            stop=None,
+            stream=False,
+        )
+        return chat_completion.choices[0].message.content
+    except Exception as error:
+        return False
+
+def chat_gemini(prompt):
+    generation_config = {
+        "temperature": 0.0,
+        "top_p": 0.0,
+        "top_k": 0,
+        "max_output_tokens": 8192,
+    }
+    safety_settings = [
+        {
+            "category": "HARM_CATEGORY_HARASSMENT",
+            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+        },
+        {
+            "category": "HARM_CATEGORY_HATE_SPEECH",
+            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+        },
+        {
+            "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+        },
+        {
+            "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+        },
+    ]
+    model = genai.GenerativeModel(model_name="gemini-1.5-pro-latest",
+                                  generation_config=generation_config,
+                                  safety_settings=safety_settings)
+    convo = model.start_chat(history=[])
+    convo.send_message(prompt)
+    return convo.last.text
+
+def question_answer(question):
+    completion = chat_llama3(question)
+    if completion:
+        return completion
+    else:
+        answer = chat_gemini(question)
+        return answer
+
+def check_persist_directory(id, file_name):
+    directory_path = f"./vector_database/{id}/{file_name}"
+    return os.path.exists(directory_path)
+
+from langchain_community.vectorstores import FAISS
+
+def check_path_exists(path):
+    return os.path.exists(path)
+def aws1_all_id(new_dict, text_alls, id, thread_id):
+    answer = ""
+    COHERE_API_KEY1 = os.getenv("COHERE_API_KEY_1")
+    os.environ["COHERE_API_KEY"] = COHERE_API_KEY1
+    answer_relevant = ""
+    directory = ""
+    for key, value in new_dict.items():
+        query = value
+        query = text_preprocessing(query)
+        keyword, keyword2 = find_matching_files_in_docs_12_id(query, id)
+        data = extract_multi_metadata_content(text_alls, keyword)
+        if keyword:
+            file_name = next(iter(keyword))
+            text_splitter = CharacterTextSplitter(chunk_size=3200, chunk_overlap=1500)
+            texts_data = text_splitter.split_text(data)
+
+            if check_persist_directory(id, file_name):
+                vectordb_query = Chroma(persist_directory=f"./vector_database/{id}/{file_name}", embedding_function=embeddings)
+            else:
+                vectordb_query = Chroma.from_texts(texts_data,
+                                                   embedding=embeddings,
+                                                   persist_directory=f"./vector_database/{id}/{file_name}")
+
+            k_1 = len(texts_data)
+            retriever = vectordb_query.as_retriever(search_kwargs={f"k": k_1})
+            bm25_retriever = BM25Retriever.from_texts(texts_data)
+            bm25_retriever.k = k_1
+            ensemble_retriever = EnsembleRetriever(retrievers=[bm25_retriever, retriever],
+                                                   weights=[0.6, 0.4])
+            docs = ensemble_retriever.get_relevant_documents(f"{query}")
+
+            path = f"./vector_database/FAISS/{id}/{file_name}"
+            if check_path_exists(path):
+                docsearch = FAISS.load_local(path, embeddings, allow_dangerous_deserialization=True)
+            else:
+                docsearch = FAISS.from_documents(docs, embeddings)
+                docsearch.save_local(f"./vector_database/FAISS/{id}/{file_name}")
+                docsearch = FAISS.load_local(path, embeddings, allow_dangerous_deserialization=True)
+
+            k_2 = len(docs)
+            compressor = CohereRerank(top_n=3)
+            retrieve3 = docsearch.as_retriever(search_kwargs={f"k": k_2})
+            compression_retriever = ContextualCompressionRetriever(
+                base_compressor=compressor, base_retriever=retrieve3
+            )
+            compressed_docs = compression_retriever.get_relevant_documents(f"{query}")
+
+            if compressed_docs:
+                data = compressed_docs[0].page_content
+                text = ''.join(map(lambda x: x.page_content, compressed_docs))
+                prompt_document = f"Dựa vào nội dung sau:{text}. Hãy trả lời câu hỏi sau đây: {query}. Mà không thay đổi nội dung mà mình đã cung cấp. Cuối cùng nếu câu hỏi sử dụng tiếng Việt thì phải trả lời bằng Vietnamese. Nếu câu hỏi sử dụng tiếng Anh phải trả lời bằng English"
+                answer_for = question_answer(prompt_document)
+                answer += answer_for + "\n"
+                answer_relevant = data
+                directory = file_name
+
+    return answer, answer_relevant, directory
+
+
+def extract_content_between_keywords(query, keywords):
+    contents = {}
+    num_keywords = len(keywords)
+    keyword_positions = []
+    for i in range(num_keywords):
+        keyword = keywords[i]
+        keyword_position = query.find(keyword)
+        keyword_positions.append(keyword_position)
+        if keyword_position == -1:
+            continue
+        next_keyword_position = len(query)
+        for j in range(i + 1, num_keywords):
+            next_keyword = keywords[j]
+            next_keyword_position = query.find(next_keyword)
+            if next_keyword_position != -1:
+                break
+        if i == 0:
+            content_before = query[:keyword_position].strip()
+        else:
+            content_before = query[keyword_positions[i - 1] + len(keywords[i - 1]):keyword_position].strip()
+        if i == num_keywords - 1:
+            content_after = query[keyword_position + len(keyword):].strip()
+        else:
+            content_after = query[keyword_position + len(keyword):next_keyword_position].strip()
+        content = f"{content_before} {keyword} {content_after}"
+        contents[keyword] = content
+    return contents
+
+def generate_random_questions(filtered_ques_list):
+    if len(filtered_ques_list) >= 2:
+        random_questions = random.sample(filtered_ques_list, 2)
+    else:
+        random_questions = filtered_ques_list
+    return random_questions
+
+def generate_question_main(loader, name_file):
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=4500, chunk_overlap=2500)
+    texts = text_splitter.split_documents(loader)
+    question_gen = f"nội dung {name_file} : \n"
+    question_gen += texts[0].page_content
+    splitter_ques_gen = RecursiveCharacterTextSplitter(
+        chunk_size=4500,
+        chunk_overlap=2200
+    )
+    chunks_ques_gen = splitter_ques_gen.split_text(question_gen)
+    document_ques_gen = [Document(page_content=t) for t in chunks_ques_gen]
+    llm_ques_gen_pipeline = llm
+    prompt_template_vn = """
+    Bạn là một chuyên gia tạo câu hỏi dựa trên tài liệu và tài liệu hướng dẫn.
+    Bạn làm điều này bằng cách đặt các câu hỏi về đoạn văn bản dưới đây:
+
+    ------------
+    {text}
+    ------------
+
+    Hãy tạo ra các câu hỏi từ đoạn văn bản này.Nếu đoạn văn là tiếng Việt hãy tạo câu hỏi tiếng Việt. Nếu đoạn văn là tiếng Anh hãy tạo câu hỏi tiếng Anh.
+    Hãy chắc chắn không bỏ sót bất kỳ thông tin quan trọng nào. Và chỉ tạo với đoạn tài liệu đó tối đa 5 câu hỏi liên quan tới tài liệu cung cấp nhất.Nếu trong đoạn tài liệu có các tên liên quan đến file như demo1.pdf( nhiều file khác) thì phải kèm nó vào nội dung câu hỏi bạn tạo ra.
+
+    CÁC CÂU HỎI:
+    """
+
+    PROMPT_QUESTIONS_VN = PromptTemplate(template=prompt_template_vn, input_variables=["text"])
+    refine_template_vn = ("""
+    Bạn là một chuyên gia tạo câu hỏi thực hành dựa trên tài liệu và tài liệu hướng dẫn.
+    Mục tiêu của bạn là giúp người học chuẩn bị cho một kỳ thi.
+    Chúng tôi đã nhận được một số câu hỏi thực hành ở mức độ nào đó: {existing_answer}.
+    Chúng tôi có thể tinh chỉnh các câu hỏi hiện có hoặc thêm câu hỏi mới
+    (chỉ khi cần thiết) với một số ngữ cảnh bổ sung dưới đây.
+    ------------
+    {text}
+    ------------
+
+    Dựa trên ngữ cảnh mới, hãy tinh chỉnh các câu hỏi bằng tiếng Việt nếu đoạn văn đó cung cấp tiếng Việt. Nếu không hãy tinh chỉnh câu hỏi bằng tiếng Anh nếu đoạn đó cung cấp tiếng Anh.
+    Nếu ngữ cảnh không hữu ích, vui lòng cung cấp các câu hỏi gốc. Và chỉ tạo với đoạn tài liệu đó tối đa 5 câu hỏi liên quan tới tài liệu cung cấp nhất. Nếu trong đoạn tài liệu có các tên file thì phải kèm nó vào câu hỏi.
+    CÁC CÂU HỎI:
+    """
+                          )
+
+    REFINE_PROMPT_QUESTIONS = PromptTemplate(
+        input_variables=["existing_answer", "text"],
+        template=refine_template_vn,
+    )
+    ques_gen_chain = load_summarize_chain(llm=llm_ques_gen_pipeline,
+                                          chain_type="refine",
+                                          verbose=True,
+                                          question_prompt=PROMPT_QUESTIONS_VN,
+                                          refine_prompt=REFINE_PROMPT_QUESTIONS)
+    ques = ques_gen_chain.run(document_ques_gen)
+    ques_list = ques.split("\n")
+    filtered_ques_list = ["{}: {}".format(name_file, re.sub(r'^\d+\.\s*', '', element)) for element in ques_list if
+                          element.endswith('?') or element.endswith('.')]
+    return generate_random_questions(filtered_ques_list)
+
+def load_file(loader):
+    return loader.load()
+
+def extract_data2(id):
+    documents = []
+    directory_path = f"./user_file/{id}"
+    if not os.path.exists(directory_path) or not any(
+            os.path.isfile(os.path.join(directory_path, f)) for f in os.listdir(directory_path)):
+        return False
+    tasks = []
+    with ThreadPoolExecutor() as executor:
+        for file in os.listdir(directory_path):
+            if file.endswith(".pdf"):
+                pdf_path = os.path.join(directory_path, file)
+                loader = UnstructuredPDFLoader(pdf_path)
+                tasks.append(executor.submit(load_file, loader))
+            elif file.endswith('.docx') or file.endswith('.doc'):
+                doc_path = os.path.join(directory_path, file)
+                loader = Docx2txtLoader(doc_path)
+                tasks.append(executor.submit(load_file, loader))
+            elif file.endswith('.txt'):
+                txt_path = os.path.join(directory_path, file)
+                loader = TextLoader(txt_path, encoding="utf8")
+                tasks.append(executor.submit(load_file, loader))
+            elif file.endswith('.pptx'):
+                ppt_path = os.path.join(directory_path, file)
+                loader = UnstructuredPowerPointLoader(ppt_path)
+                tasks.append(executor.submit(load_file, loader))
+            elif file.endswith('.csv'):
+                csv_path = os.path.join(directory_path, file)
+                loader = UnstructuredCSVLoader(csv_path)
+                tasks.append(executor.submit(load_file, loader))
+            elif file.endswith('.xlsx'):
+                excel_path = os.path.join(directory_path, file)
+                loader = UnstructuredExcelLoader(excel_path)
+                tasks.append(executor.submit(load_file, loader))
+            elif file.endswith('.json'):
+                json_path = os.path.join(directory_path, file)
+                loader = TextLoader(json_path)
+                tasks.append(executor.submit(load_file, loader))
+            elif file.endswith('.md'):
+                md_path = os.path.join(directory_path, file)
+                loader = UnstructuredMarkdownLoader(md_path)
+                tasks.append(executor.submit(load_file, loader))
+        for future in as_completed(tasks):
+            result = future.result()
+            documents.extend(result)
+    text_splitter = CharacterTextSplitter(chunk_size=4500, chunk_overlap=2500
+                                          )
+    texts = text_splitter.split_documents(documents)
+    Chroma.from_documents(documents=texts,
+                          embedding=embeddings,
+                          persist_directory=f"./vector_database/{id}")
+    return texts
+
+def generate_question(id):
+    directory_path = f"./user_file/{id}"
+    if not os.path.exists(directory_path) or not any(
+            os.path.isfile(os.path.join(directory_path, f)) for f in os.listdir(directory_path)):
+        return False
+    all_questions = []
+    tasks = []
+    with ThreadPoolExecutor() as executor:
+        for file in os.listdir(directory_path):
+            if file.endswith(".pdf"):
+                pdf_path = os.path.join(directory_path, file)
+                loader = UnstructuredPDFLoader(pdf_path).load()
+                tasks.append(executor.submit(generate_question_main, loader, file))
+            elif file.endswith('.docx') or file.endswith('.doc'):
+                doc_path = os.path.join(directory_path, file)
+                loader = Docx2txtLoader(doc_path).load()
+                tasks.append(executor.submit(generate_question_main, loader, file))
+            elif file.endswith('.txt'):
+                txt_path = os.path.join(directory_path, file)
+                loader = TextLoader(txt_path, encoding="utf8").load()
+                tasks.append(executor.submit(generate_question_main, loader, file))
+            elif file.endswith('.pptx'):
+                ppt_path = os.path.join(directory_path, file)
+                loader = UnstructuredPowerPointLoader(ppt_path).load()
+                tasks.append(executor.submit(generate_question_main, loader, file))
+            elif file.endswith('.json'):
+                json_path = os.path.join(directory_path, file)
+                loader = TextLoader(json_path, encoding="utf8").load()
+                tasks.append(executor.submit(generate_question_main, loader, file))
+            elif file.endswith('.md'):
+                md_path = os.path.join(directory_path, file)
+                loader = UnstructuredMarkdownLoader(md_path).load()
+                tasks.append(executor.submit(generate_question_main, loader, file))
+        for future in as_completed(tasks):
+            result = future.result()
+            all_questions.extend(result)
+    return all_questions
+
+class Search(BaseModel):
+    queries: List[str] = Field(
+        ...,
+        description="Truy vấn riêng biệt để tìm kiếm, giữ nguyên ý chính câu hỏi riêng biệt",
+    )
+
+def query_analyzer(query):
+    output_parser = PydanticToolsParser(tools=[Search])
+    system = """Bạn có khả năng đưa ra các truy vấn tìm kiếm chính xác để lấy thông tin giúp trả lời các yêu cầu của người dùng. Các truy vấn của bạn phải chính xác, không được bỏ ngắn rút gọn.
+     Nếu bạn cần tra cứu hai ho���c nhiều thông tin riêng biệt, bạn có thể làm điều đó!. Trả lời câu hỏi bằng tiếng Việt(Vietnamese), không được dùng ngôn ngữ khác"""
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", system),
+            ("human", "{question}"),
+        ]
+    )
+    llm = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0.0)
+    structured_llm = llm.with_structured_output(Search)
+    query_analyzer = {"question": RunnablePassthrough()} | prompt | structured_llm
+    text = query_analyzer.invoke(query)
+    return text
+
+def handle_query(question, text_all, compression_retriever, id, thread_id):
+        COHERE_API_KEY_3 = os.environ["COHERE_API_KEY_3"]
+        os.environ["COHERE_API_KEY"] = COHERE_API_KEY_3
+        query = question
+        x = query
+        keyword, key_words_old = find_matching_files_in_docs_12_id(query, id)
+        # if keyword == set() or key_words_old == list():
+        #     return "Not found file" 
+        file_list = keyword
+
+        if file_list:
+            list_keywords2 = list(key_words_old)
+            contents1 = extract_content_between_keywords(query, list_keywords2)
+            merged_result = merge_files(keyword, list_keywords2)
+            original_dict = contents1
+            replacement_dict = merged_result
+            new_dict = replace_keys_with_values(original_dict, replacement_dict)
+            files_to_remove = [filename for filename in new_dict.keys() if
+                               filename.endswith('.xlsx') or filename.endswith('.csv')]
+            removed_files = {}
+            for filename in files_to_remove:
+                removed_files[filename] = new_dict[filename]
+            for filename in files_to_remove:
+                new_dict.pop(filename)
+            test_csv = ""
+            text_csv, query_csv, source = aws1_csv_id(removed_files, id)
+            prompt_csv = ""
+            answer_csv = ""
+            if test_csv:
+                prompt_csv = f"Dựa vào nội dung sau: {text_csv}. Hãy trả lời câu hỏi sau đây: {query_csv}.Bằng tiếng Việt"
+                answer_csv = question_answer(prompt_csv)
+            answer_document, data_relevant, source = aws1_all_id(new_dict, text_all, id, thread_id)
+            answer_all1 = answer_document + answer_csv
+            return answer_all1, data_relevant, source
+        else:
+            compressed_docs = compression_retriever.get_relevant_documents(f"{query}")
+            relevance_score_float = float(compressed_docs[0].metadata['relevance_score'])
+            print(relevance_score_float)
+            if relevance_score_float <= 0.12:
+                documents1 = []
+                for file in os.listdir(f"./user_file/{id}"):
+                    if file.endswith('.csv'):
+                        csv_path = f"./user_file/{id}/" + file
+                        loader = UnstructuredCSVLoader(csv_path)
+                        documents1.extend(loader.load())
+                    elif file.endswith('.xlsx'):
+                        excel_path = f"./user_file/{id}/" + file
+                        loader = UnstructuredExcelLoader(excel_path)
+                        documents1.extend(loader.load())
+                text_splitter_csv = CharacterTextSplitter.from_tiktoken_encoder(chunk_size=2200, chunk_overlap=1500)
+                texts_csv = text_splitter_csv.split_documents(documents1)
+                vectordb_csv = Chroma.from_documents(documents=texts_csv,
+                                                     embedding=embeddings, persist_directory=f'./vector_database/csv/{thread_id}')
+                k = len(texts_csv)
+                retriever_csv = vectordb_csv.as_retriever(search_kwargs={"k": k})
+                llm = Cohere(temperature=0)
+                compressor_csv = CohereRerank(top_n=3, model="rerank-english-v2.0")
+                compression_retriever_csv = ContextualCompressionRetriever(
+                    base_compressor=compressor_csv, base_retriever=retriever_csv
+                )
+                compressed_docs_csv = compression_retriever_csv.get_relevant_documents(f"{query}")
+                file_path = compressed_docs_csv[0].metadata['source']
+                print(file_path)
+                if file_path.endswith('.xlsx'):
+                    new = file_path.replace(".xlsx", ".csv")
+                    convert_xlsx_to_csv(file_path, new)
+                    loader1 = CSVLoader(new)
+                else:
+                    loader1 = CSVLoader(file_path)
+                docs1 = loader1.load()
+                text = " "
+                for z in docs1:
+                    text += z.page_content + "\n"
+                prompt_csv = f"Dựa vào nội dung sau: {text}. Hãy trả lời câu hỏi sau đây: {query}. Bằng tiếng Việt"
+                answer_csv = question_answer(prompt_csv)
+                return answer_csv
+            else:
+                file_path = compressed_docs[0].metadata['source']
+                file_path = file_path.replace('\\', '/')
+                print(file_path)
+                if file_path.endswith(".pdf"):
+                    loader = UnstructuredPDFLoader(file_path)
+                elif file_path.endswith('.docx') or file_path.endswith('doc'):
+                    loader = Docx2txtLoader(file_path)
+                elif file_path.endswith('.txt'):
+                    loader = TextLoader(file_path, encoding="utf8")
+                elif file_path.endswith('.pptx'):
+                    loader = UnstructuredPowerPointLoader(file_path)
+                elif file_path.endswith('.xml'):
+                    loader = UnstructuredXMLLoader(file_path)
+                elif file_path.endswith('.html'):
+                    loader = UnstructuredHTMLLoader(file_path)
+                elif file_path.endswith('.json'):
+                    loader = TextLoader(file_path)
+                elif file_path.endswith('.md'):
+                    loader = UnstructuredMarkdownLoader(file_path)
+                elif file_path.endswith('.xlsx'):
+                    file_path_new = file_path.replace(".xlsx", ".csv")
+                    convert_xlsx_to_csv(file_path, file_path_new)
+                    loader = CSVLoader(file_path_new)
+                elif file_path.endswith('.csv'):
+                    loader = CSVLoader(file_path)
+                text_splitter = CharacterTextSplitter(chunk_size=3200, chunk_overlap=1500)
+                texts = text_splitter.split_documents(loader.load())
+                k_1 = len(texts)
+                file_name = os.path.basename(file_path)
+                if check_persist_directory(id, file_name):
+                    vectordb_file = Chroma(persist_directory=f"./vector_database/{id}/{file_name}",
+                                           embedding_function=embeddings)
+                else:
+                    vectordb_file = Chroma.from_documents(texts,
+                                                          embedding=embeddings,
+                                                          persist_directory=f"./vector_database/{id}/{file_name}")
+                retriever_file = vectordb_file.as_retriever(search_kwargs={f"k": k_1})
+                bm25_retriever = BM25Retriever.from_documents(texts)
+                bm25_retriever.k = k_1
+                ensemble_retriever = EnsembleRetriever(retrievers=[bm25_retriever, retriever_file],
+                                                       weights=[0.6, 0.4])
+                docs = ensemble_retriever.get_relevant_documents(f"{query}")
+
+                path = f"./vector_database/FAISS/{id}/{file_name}"
+                if check_path_exists(path):
+                    docsearch = FAISS.load_local(path, embeddings, allow_dangerous_deserialization=True)
+                else:
+                    docsearch = FAISS.from_documents(docs, embeddings)
+                    docsearch.save_local(f"./vector_database/FAISS/{id}/{file_name}")
+                    docsearch = FAISS.load_local(path, embeddings, allow_dangerous_deserialization=True)
+                k_2 = len(docs)
+                retrieve3 = docsearch.as_retriever(search_kwargs={f"k": k_2})
+                compressor_file = CohereRerank(top_n=3, model="rerank-english-v2.0")
+                compression_retriever_file = ContextualCompressionRetriever(
+                    base_compressor=compressor_file, base_retriever=retrieve3
+                )
+                compressed_docs_file = compression_retriever_file.get_relevant_documents(f"{x}")
+                query = question
+                text = ''.join(map(lambda x: x.page_content, compressed_docs_file))
+                prompt = f"Dựa vào nội dung sau:{text}. Hãy trả lời câu hỏi sau đây: {query}. Mà không thay đổi, chỉnh sửa nội dung mà mình đã cung cấp"
+                answer = question_answer(prompt)
+                list_relevant = compressed_docs_file[0].page_content
+                source = file_name
+                return answer, list_relevant, source
+import concurrent.futures
+def handle_query_upgrade_keyword_old(query_all, text_all, id,chat_history):
+    COHERE_API_KEY_2 = os.environ["COHERE_API_KEY_2"]
+    os.environ["COHERE_API_KEY"] = COHERE_API_KEY_2
+    test = query_analyzer(query_all)
+    test_string = str(test)
+    matches = re.findall(r"'([^']*)'", test_string)
+    vectordb = Chroma(persist_directory=f"./vector_database/{id}", embedding_function=embeddings)
+    k = len(text_all)
+    retriever = vectordb.as_retriever(search_kwargs={"k": k})
+    compressor = CohereRerank(top_n=5, model="rerank-english-v2.0")
+    compression_retriever = ContextualCompressionRetriever(base_compressor=compressor, base_retriever= retriever)
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = {executor.submit(handle_query, query, text_all, compression_retriever, id, i): query for i, query in
+                   enumerate(matches)}
+        results = []
+        data_relevant = []
+        sources = []
+        for future in as_completed(futures):
+            try:
+                result, list_data, list_source = future.result()
+                results.append(result)
+                data_relevant.append(list_data)
+                sources.append(list_source)
+            except Exception as e:
+                print(f'An error occurred: {e}')
+    answer_all = ''.join(results)
+    prompt1 = f"Dựa vào nội dung sau: {answer_all}. Hãy trả lời câu hỏi sau đây: {query_all}. Lưu ý rằng ngữ cảnh của cuộc trò chuyện này trước đây là: {chat_history}. Vui lòng trả lời câu hỏi mà không thay đổi, chỉnh sửa nội dung mà mình đã cung cấp."
+    answer1 = question_answer(prompt1)
+    return answer1, data_relevant, sources

function/dropbox.py

@@ -0,0 +1,155 @@
+import dropbox.files
+import os
+import shutil
+import requests, base64
+from fastapi import HTTPException
+from dotenv import load_dotenv
+import os
+load_dotenv()
+DROPBOX_APP_KEY=os.getenv('DROPBOX_APP_KEY')
+DROPBOX_APP_SECRET=os.getenv('DROPBOX_APP_SECRET')
+DROPBOX_REFRESH_TOKEN=os.getenv('DROPBOX_REFRESH_TOKEN')
+
+def refresh_token_dropbox():
+    app_key = DROPBOX_APP_KEY
+    app_secret = DROPBOX_APP_SECRET
+    refresh_token = DROPBOX_REFRESH_TOKEN
+    url = 'https://api.dropbox.com/oauth2/token'
+    auth_string = f"{app_key}:{app_secret}"
+    base64authorization = base64.b64encode(auth_string.encode()).decode('utf-8')
+    headers = {
+        'Authorization': f'Basic {base64authorization}',
+        'Content-Type': 'application/x-www-form-urlencoded'
+    }
+    data = {
+        'refresh_token': refresh_token,
+        'grant_type': 'refresh_token'
+    }
+    response = requests.post(url, headers=headers, data=data)
+    response_json = response.json()
+    access_token = response_json.get('access_token', None)
+    return access_token
+
+def delete_file(id,name_file):
+    try:
+        TOKEN = refresh_token_dropbox()
+        dbx=dropbox.Dropbox(TOKEN)
+        file_path = f"/{id}/{name_file}"
+        dbx.files_delete_v2(file_path)
+        print(f"Xóa file '{file_path}' thành công.")
+    except dropbox.exceptions.ApiError as e:
+        print(f"Lỗi khi xóa file '{file_path}': {e}")
+
+def list_files(id):
+    file_names = []
+    try:
+        TOKEN = refresh_token_dropbox()
+        dbx=dropbox.Dropbox(TOKEN)
+        result = dbx.files_list_folder(f"/{id}")
+        for entry in result.entries:
+            if isinstance(entry, dropbox.files.FileMetadata):
+                file_names.append(os.path.basename(entry.path_display))
+    except dropbox.exceptions.ApiError as e:
+        print(f"Error listing files: {e}") 
+    return file_names
+
+def upload_file_fix(local_path,cloud_path,token):
+    try:
+        TOKEN = refresh_token_dropbox()
+        dbx=dropbox.Dropbox(TOKEN)
+        with open(local_path, "rb") as f:
+            data = f.read()
+        dbx.files_upload(data, cloud_path)
+        print(f"Uploaded file '{local_path}' to '{cloud_path}'")
+    except dropbox.exceptions.ApiError as e:
+        print(f"Error uploading file '{local_path}': {e}")
+
+def upload_file(local_path, cloud_path):
+    try:
+        TOKEN = refresh_token_dropbox()
+        dbx=dropbox.Dropbox(TOKEN)
+        with open(local_path, "rb") as f:
+            data = f.read()
+        dbx.files_upload(data, cloud_path)
+        print(f"Uploaded file '{local_path}' to '{cloud_path}'")
+    except dropbox.exceptions.ApiError as e:
+        upload_file_fix()
+
+def clear_local_folder(path):
+    try:
+        for filename in os.listdir(path):
+            file_path = os.path.join(path, filename)
+            if os.path.isfile(file_path) or os.path.islink(file_path):
+                os.unlink(file_path)
+            elif os.path.isdir(file_path):
+                shutil.rmtree(file_path)
+    except Exception as e:
+        print(f"Failed to delete contents of {path}. Reason: {e}")
+
+def download_folder(id):
+    try:
+        TOKEN = refresh_token_dropbox()
+        dbx = dropbox.Dropbox(TOKEN)
+        local_path = f"./user_file/{id}"
+        os.makedirs(local_path, exist_ok=True)
+        clear_local_folder(local_path)
+        result = dbx.files_list_folder(f"/{id}")
+        for entry in result.entries:
+            if isinstance(entry, dropbox.files.FileMetadata):
+                cloud_file_path = entry.path_display
+                file_name = os.path.basename(cloud_file_path)
+                local_file_path = os.path.join(local_path, file_name)
+                dbx.files_download_to_file(local_file_path, cloud_file_path)
+                print(f"Downloaded file '{file_name}' to '{local_file_path}'")
+    except dropbox.exceptions.ApiError as e:
+        print(f"Error downloading file '{id}': {e}")
+
+def download_file_id(file_name, id):
+    try:
+        TOKEN = refresh_token_dropbox()
+        dbx = dropbox.Dropbox(TOKEN)
+        local_folder_path = f"./user_file/{id}"
+        os.makedirs(local_folder_path, exist_ok=True)
+        local_file_path = os.path.join(local_folder_path, file_name)
+        with open(local_file_path, "wb") as f:
+            metadata, response = dbx.files_download(f"/{id}/{file_name}")
+            f.write(response.content)
+        print(f"Downloaded file '{file_name}' to '{local_file_path}'")
+    except dropbox.exceptions.ApiError as e:
+        print(f"Error downloading file '{file_name}': {e}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+
+def search_and_download_file(start_char, id):
+    try:
+        TOKEN = refresh_token_dropbox()
+        dbx = dropbox.Dropbox(TOKEN)
+        result = dbx.files_list_folder(f"/{id}")
+        files_starting_with_char = [entry.name for entry in result.entries if entry.name.startswith(start_char)]
+        if len(files_starting_with_char) == 0:
+            print(f"No file found starting with '{start_char}' in folder '{id}'")
+            return
+        file_name = files_starting_with_char[0]
+        local_folder_path = f"./user_file/{id}"
+        os.makedirs(local_folder_path, exist_ok=True)
+        local_file_path = os.path.join(local_folder_path, file_name)
+        with open(local_file_path, "wb") as f:
+            metadata, response = dbx.files_download(f"/{id}/{file_name}")
+            f.write(response.content)
+        print(f"Downloaded file '{file_name}' to '{local_file_path}'")
+    except dropbox.exceptions.ApiError as e:
+        print(f"Error searching or downloading file: {e}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+
+def delete_all_files_in_folder(folder_id):
+    try:
+        TOKEN = refresh_token_dropbox()
+        dbx = dropbox.Dropbox(TOKEN)
+        result = dbx.files_list_folder(f"/{folder_id}")
+        for entry in result.entries:
+            if isinstance(entry, dropbox.files.FileMetadata):
+                file_path = entry.path_display
+                dbx.files_delete_v2(file_path)
+                print(f"Deleted file '{file_path}'")
+        print(f"All files in folder '{folder_id}' have been deleted.")
+    except dropbox.exceptions.ApiError as e:
+        print(f"Error deleting files: {e}")

function/support_function.py

@@ -0,0 +1,128 @@
+from pydantic.error_wrappers import ErrorWrapper
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from service import MySQLService,UserService,ChatService
+from request import RequestMySQL,RequestUser,RequestDefault
+from auth.authentication import decodeJWT
+from repository import UserRepository
+from auth import authentication
+from datetime import datetime, timedelta
+from fastapi import Depends, HTTPException, Form, File, UploadFile
+from typing import List
+from service import FileService,DefaultService,UserService
+from request import RequestFile,RequestChat,RequestDefault
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic.error_wrappers import ErrorWrapper
+import json
+from function import support_function
+from repository import UserRepository
+from response import ResponseDefault as res
+import re
+
+def is_positive_integer(value):
+    if isinstance(value, int) and value > 0:
+        return True
+    else:
+        return False
+
+def check_value_user_id_controller(user_id: str):
+    if user_id is None or user_id.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="user_id field is required."))
+    user_id = user_id.strip("'").strip('"')
+    try:
+        user_id_int = int(user_id)
+    except ValueError:
+        return res.ReponseError(status=400,
+                                data=res.Message(message="user_id must be an integer"))
+
+    if not support_function.is_positive_integer(user_id_int):
+        return res.ReponseError(status=400,
+                                data=res.Message(message="user_id must be greater than 0"))
+    return True
+
+def check_value_user_id(user_id: str, current_user_email: str):
+    if user_id is None or user_id.strip() == "":
+        return res.ReponseError(status=400,
+                                data=res.Message(message="user_id field is required."))
+    user_id = user_id.strip("'").strip('"')
+    try:
+        user_id_int = int(user_id)
+    except ValueError:
+        return res.ReponseError(status=400,
+                                data=res.Message(message="user_id must be an integer"))
+
+    if not support_function.is_positive_integer(user_id_int):
+        return res.ReponseError(status=400,
+                                data=res.Message(message="user_id must be greater than 0"))
+    email = UserRepository.getEmailUserByIdFix(user_id)
+    if email is None:
+        return res.ReponseError(status=404,
+                                data=res.Message(message="user_id not exist"))
+    email = email[0]
+    if email != current_user_email:
+        raise HTTPException(status_code=403, detail="Sorry, you can't perform actions with this user id.")
+    return True
+
+def check_value_email_controller(email: str):
+    if email is None or email.strip() == "":
+        return res.ReponseError(status = 400,
+                                data = res.Message(message="Email is required."))
+    try:
+        int(email)
+        return res.ReponseError(status=400,
+                                data=res.Message(message="Email must be a string, not a number."))
+    except ValueError:
+        pass
+    return True
+
+def check_value_otp(otp: str):
+    if otp is None:
+        return res.ReponseError(status=400,
+                                data=res.Message(message="OTP is required"))
+    if otp.isdigit():
+        return res.ReponseError(status=400,
+                                data=res.Message(message="OTP must be a string, not a number."))
+    if len(otp) != 6:
+        return res.ReponseError(status=400,
+                                data=res.Message(message="OTP max length is 6"))
+    return True
+
+regex = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b'
+def check_email(email):
+    if(re.fullmatch(regex, email)):
+        return True
+    else:
+        return False
+def check_email_service(user_id: str):
+    email1 = UserRepository.getEmailUserByIdFix(user_id)
+    if email1 is None:
+        return res.ReponseError(
+            status=404,
+            data=res.Message(message="Id not exist")
+        )
+    email = email1[0]
+    if email is None:
+        return res.ReponseError(
+            status=400,
+            data=res.Message(message="Email is empty")
+        )
+    if check_email(email) == False:
+        return res.ReponseError(
+            status=400,
+            data=res.Message(message="Email invalid")
+        )
+    return email
+
+def check_email_empty_invalid(email: str):
+    if email is None or email == "":
+        return res.ReponseError(
+            status=400,
+            data=res.Message(message="Email is empty")
+        )
+    if check_email(email) == False:
+        return res.ReponseError(
+            status=400,
+            data =res.Message(message="Email invalid")
+        )
+    return True

models/Database_Entity.py

@@ -0,0 +1,68 @@
+from sqlalchemy import Column, String, Text, DateTime, Integer, ForeignKey, TIMESTAMP
+from sqlalchemy.orm import relationship
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.sql import func
+class Base(DeclarativeBase):
+    pass
+
+class User(Base):
+    __tablename__ = 'users'
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    email = Column(String(255))
+    access_token = Column(Text)
+    refresh_token = Column(Text)
+    expires_at = Column(DateTime)
+
+    chat_histories = relationship("ChatHistory", back_populates="user")
+    user_logins = relationship("UserLogin", back_populates="user")
+    user_infos = relationship("UserInfo", back_populates="user")
+
+class ChatHistory(Base):
+    __tablename__ = 'chat_history'
+
+    id = Column(Integer, primary_key=True,autoincrement=True)
+    email = Column(String(255), ForeignKey('users.email'))
+    name_chat = Column(String(255), unique=True)
+
+    user = relationship("User", back_populates="chat_histories")
+    detail_chats = relationship("DetailChat", back_populates="chat_history")
+
+class UserLogin(Base):
+    __tablename__ = 'user_login'
+
+    id = Column(Integer, primary_key=True,autoincrement=True)
+    user_email = Column(String(100), ForeignKey('users.email'), primary_key=True)
+    user_session_id = Column(String(100), primary_key=True)
+    
+    user = relationship("User", back_populates="user_logins")
+
+class UserInfo(Base):
+    __tablename__ = 'user_info'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    uid = Column(Text)
+    email = Column(String(255), ForeignKey('users.email'), unique=True)
+    display_name = Column(Text)
+    photo_url = Column(Text)
+    
+    user = relationship("User", back_populates="user_infos")
+
+class DetailChat(Base):
+    __tablename__ = 'detail_chat'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    chat_id = Column(Integer, ForeignKey('chat_history.id'))
+    YouMessage = Column(Text)
+    AiMessage = Column(Text)
+    data_relevant = Column(Text)
+    source_file = Column(Text)
+
+    chat_history = relationship("ChatHistory", back_populates="detail_chats")
+
+class OTP(Base):
+    __tablename__ = 'otp'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    email = Column(String(255), nullable=False)
+    otp = Column(String(6), nullable=False)
+    created_at = Column(TIMESTAMP, server_default=func.now())

repository/ChatHistoryRepository.py

@@ -0,0 +1,276 @@
+from sqlalchemy.orm import sessionmaker
+import sys
+import os
+app_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+sys.path.insert(0, app_path)
+from models import Database_Entity
+from repository import ConfigDatabase as cf
+chat_history = Database_Entity.ChatHistory
+users = Database_Entity.User
+detail_chat = Database_Entity.DetailChat
+from sqlalchemy.orm import sessionmaker
+from functools import lru_cache
+import sys
+import os
+
+def getIdChatHistoryByUserIdAndNameChat(user_id:int,name_old :str) -> chat_history.id:
+  try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+    chat_id = session.query(chat_history.id).filter(chat_history.email == email, chat_history.name_chat == name_old).scalar()
+    session.commit()
+    if chat_id:
+        session.close()
+        return chat_id
+    else:
+        session.close()
+        return None
+  except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+    chat_id = session.query(chat_history.id).filter(chat_history.email == email, chat_history.name_chat == name_old).scalar()
+    session.commit()
+    if chat_id:
+        session.close()
+        return chat_id
+    else:
+        session.close()
+        return None
+
+def getIdChatHistoryByUserIdAndNameChatNew(user_id:int,name_old :str) -> chat_history.id:
+  try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+    chat_id = session.query(chat_history.id).filter(chat_history.email == email, chat_history.name_chat == name_old).scalar()
+    session.commit()
+    if chat_id:
+        session.close()
+        return chat_id
+    else:
+        session.close()
+        return None
+  except:
+      engine = cf.get_db_engine1()
+      Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+      with Session() as session:
+          email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+          chat_id = session.query(chat_history.id).filter(chat_history.email == email,
+                                                          chat_history.name_chat == name_old).scalar()
+          session.commit()
+          if chat_id:
+              session.close()
+              return chat_id
+          else:
+              session.close()
+              return None
+
+def updateNameChatHistory(user_id: int,name_old :str,name_new:str) -> bool:
+ try:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    try:
+      email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+      session.query(chat_history).filter(chat_history.email == email,chat_history.name_chat == name_old).update({chat_history.name_chat: name_new})
+      session.commit()
+      session.close()
+      return True
+    except:
+       session.rollback()
+       session.close()
+       return False
+ except:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    try:
+      email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+      session.query(chat_history).filter(chat_history.email == email,chat_history.name_chat == name_old).update({chat_history.name_chat: name_new})
+      session.commit()
+      session.close()
+      return True
+    except:
+       session.rollback()
+       session.close()
+       return False
+
+def deleteChatHistory(user_id,chat_name: str) -> bool:
+ try:
+  try:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+    session.query(chat_history).filter(chat_history.email == email, chat_history.name_chat == chat_name).delete()
+    session.commit()
+    session.close()
+    return True
+  except Exception as e:
+        session.rollback()
+        session.close()
+        return False
+ except:
+   try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+     email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+     session.query(chat_history).filter(chat_history.email == email, chat_history.name_chat == chat_name).delete()
+     session.commit()
+     session.close()
+     return True
+   except Exception as e:
+        session.rollback()
+        session.close()
+        return False
+
+
+def getChatHistoryByEmail(email: str) -> chat_history:
+   try:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+       chat_history1 = session.query(chat_history).filter(chat_history.email == email)
+       if chat_history1:
+          session.commit()
+          session.close()
+          return chat_history1
+       session.close()
+       return None
+   except:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+       chat_history1 = session.query(chat_history).filter(chat_history.email == email)
+       if chat_history1:
+          session.commit()
+          session.close()
+          return chat_history1
+       session.close()
+       return None
+
+from sqlalchemy.orm import aliased
+
+def delete_last_chat_detail_by_chat_name_and_email(chat_name: str, user_id: int) -> bool:
+    try:
+        engine = cf.get_db_engine()
+        Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        with Session() as session:
+            email = session.query(users.email).filter(users.id == user_id).one_or_none()
+            if not email:
+                return False
+            email = email[0]
+            last_chat_detail = (session.query(detail_chat)
+                                .join(chat_history, detail_chat.chat_id == chat_history.id)
+                                .filter(chat_history.name_chat == chat_name, chat_history.email == email)
+                                .order_by(detail_chat.id.desc())
+                                .first())
+
+            if last_chat_detail:
+                session.delete(last_chat_detail)
+                session.commit()
+                return True
+            return False
+    except:
+        engine = cf.get_db_engine1()
+        Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        with Session() as session:
+            email = session.query(users.email).filter(users.id == user_id).one_or_none()
+            if not email:
+                return False
+            email = email[0]
+            last_chat_detail = (session.query(detail_chat)
+                                .join(chat_history, detail_chat.chat_id == chat_history.id)
+                                .filter(chat_history.name_chat == chat_name, chat_history.email == email)
+                                .order_by(detail_chat.id.desc())
+                                .first())
+
+            if last_chat_detail:
+                session.delete(last_chat_detail)
+                session.commit()
+                return True
+            return False
+def getChatHistoryByChatIdAndUserId(chat_id: int, user_id: int) -> chat_history:
+    try:
+        engine = cf.get_db_engine()
+        Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        with Session() as session:
+            email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+            chat_history1 = session.query(chat_history).filter(chat_history.id == chat_id,chat_history.email == email).one_or_none()
+            if chat_history1:
+                session.commit()
+                session.close()
+                return True
+            session.close()
+            return None
+    except:
+        engine = cf.get_db_engine1()
+        Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        with Session() as session:
+            email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+            chat_history1 = session.query(chat_history).filter(chat_history.email == email)
+            if chat_history1:
+                session.commit()
+                session.close()
+                return True
+            session.close()
+            return None
+
+
+def getChatHistoryById(id: int) -> chat_history:
+   try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+       email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+       chat_history1 = session.query(chat_history).filter(chat_history.email == email)
+       if chat_history1:
+          session.commit()
+          session.close()
+          return chat_history1
+       session.close()
+       return None
+   except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+       email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+       chat_history1 = session.query(chat_history).filter(chat_history.email == email)
+       if chat_history1:
+          session.commit()
+          session.close()
+          return chat_history1
+       session.close()
+       return None
+
+def addChatHistory(user_id: str, name_chat:str)->None:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+        new_user = chat_history(
+           email = email,
+           name_chat = name_chat
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        email = session.query(users.email).filter(users.id == user_id).one_or_none()[0]
+        new_user = chat_history(
+           email = email,
+           name_chat = name_chat
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()

repository/ConfigDatabase.py

@@ -0,0 +1,48 @@
+from sqlalchemy import create_engine, URL
+from sqlalchemy.orm import DeclarativeBase
+Base = DeclarativeBase()
+from sqlalchemy.engine import create_engine, URL
+from dotenv import load_dotenv
+import os
+load_dotenv()
+MYSQL_USER_NAME=os.getenv('MYSQL_USER_NAME')
+MYSQL_PASSWORD=os.getenv('MYSQL_PASSWOR')
+MYSQL_PORT=os.getenv('MYSQL_PORT')
+MYSQL_DATABASE=os.getenv('MYSQL_DATABASE')
+MYSQL_HOST=os.getenv('MYSQL_HOST')
+#IF USE DOCKER HOST = host.docker.internal
+def get_db_engine():
+    dsn = URL.create(
+        drivername="mysql+pymysql",
+        username=MYSQL_USER_NAME,
+        password=MYSQL_PASSWORD,
+        host=MYSQL_HOST,
+        port=MYSQL_PORT,
+        database=MYSQL_DATABASE
+    )
+    connect_args = {}
+    return create_engine(
+        dsn,
+        connect_args=connect_args,
+        pool_size=20,
+        pool_recycle=300,
+        pool_pre_ping=True
+    )
+
+def get_db_engine1():
+    dsn = URL.create(
+        drivername="mysql+pymysql",
+        username=MYSQL_USER_NAME,
+        password=MYSQL_PASSWORD,
+        host=MYSQL_HOST,
+        port=MYSQL_PORT,
+        database=MYSQL_DATABASE
+    )
+    connect_args = {}
+    return create_engine(
+        dsn,
+        connect_args=connect_args,
+        pool_size=20,
+        pool_recycle=300,
+        pool_pre_ping=True
+    )

repository/DetailChatRepository.py

@@ -0,0 +1,141 @@
+from sqlalchemy.orm import sessionmaker
+from models import Database_Entity
+from repository import ConfigDatabase as cf
+detail_chat = Database_Entity.DetailChat
+chat_history = Database_Entity.ChatHistory
+
+def getListDetailChatByChatId(chat_id: int) -> detail_chat:
+  try:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    chat_record= session.query(detail_chat).filter(detail_chat.chat_id == chat_id)
+    session.commit()
+    if chat_record:
+        session.close()
+        return chat_record
+    else:
+        session.close()
+        return None
+  except:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    chat_record= session.query(detail_chat).filter(detail_chat.chat_id == chat_id)
+    session.commit()
+    if chat_record:
+        session.close()
+        return chat_record
+    else:
+        session.close()
+        return None
+
+def addDetailChat(chat_id: int, YouMessage: str, AiMessage: str, data_relevant: str, source_file: str) -> None:
+  try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        new_user = detail_chat(
+          chat_id = chat_id,
+          YouMessage = YouMessage,
+          AiMessage = AiMessage,
+          data_relevant = data_relevant,
+          source_file  = source_file
+        )
+        session.add(new_user)
+        session.commit()
+        return new_user.id
+        session.close()
+  except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        new_user = detail_chat(
+            chat_id=chat_id,
+            YouMessage=YouMessage,
+            AiMessage=AiMessage,
+            data_relevant=data_relevant,
+            source_file=source_file
+        )
+        session.add(new_user)
+        session.commit()
+        return new_user.id
+        session.close()
+
+def getDetailChatByChatId(id: int) -> detail_chat:
+    try:
+        engine = cf.get_db_engine()
+        Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        with Session() as session:
+            try:
+                chat = session.query(detail_chat).filter(detail_chat.id == id).one_or_none()
+                return chat
+            except:
+                session.close()
+                return False
+    except:
+        engine = cf.get_db_engine1()
+        Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        with Session() as session:
+            try:
+                chat = session.query(detail_chat.id,detail_chat.data_relevant,detail_chat.source_file).filter(detail_chat.id == id).one_or_none()
+                session.commit()
+                session.close()
+                return chat
+            except:
+                session.close()
+                return False
+
+
+def delete_chat_detail(chat_name: str) -> bool:
+ try:
+  engine = cf.get_db_engine()
+  Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+  with Session() as session:
+    try:
+        detail_chat2 = session.query(detail_chat).filter(detail_chat.chat_id == chat_history.id).filter(chat_history.name_chat == chat_name)
+        session.query(detail_chat).filter(detail_chat.chat_id == chat_history.id).filter(chat_history.name_chat == chat_name).delete(synchronize_session=False)
+        session.commit()
+        session.close()
+        return True
+    except:
+        session.close()
+        return False
+ except:
+  engine = cf.get_db_engine1()
+  Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+  with Session() as session:
+    try:
+        session.query(detail_chat).filter(detail_chat.chat_id == chat_history.id).filter(chat_history.name_chat == chat_name).delete(synchronize_session=False)
+        session.commit()
+        session.close()
+        return True
+    except:
+        session.close()
+        return False
+def delete_chat_detail_by_id(id_chat_detail: int) -> bool:
+ try:
+  engine = cf.get_db_engine()
+  Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+  with Session() as session:
+    try:
+
+        session.query(detail_chat).filter(detail_chat.id == id_chat_detail).delete(synchronize_session=False)
+        session.commit()
+        session.close()
+        return True
+    except:
+        session.close()
+        return False
+ except:
+  engine = cf.get_db_engine1()
+  Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+  with Session() as session:
+    try:
+        session.query(detail_chat).filter(detail_chat.chat_id == id_chat_detail).delete(synchronize_session=False)
+        session.commit()
+        session.close()
+        return True
+    except:
+        session.close()
+        return False

repository/OTPRepository.py

@@ -0,0 +1,82 @@
+from sqlalchemy.orm import sessionmaker
+from models import Database_Entity
+from repository import ConfigDatabase as cf
+otp_user = Database_Entity.OTP
+from sqlalchemy.orm import sessionmaker
+from functools import lru_cache
+import sys
+import os
+
+def getOtpByEmail(email: str) -> otp_user:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    user_record= session.query(otp_user).filter(otp_user.email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    user_record= session.query(otp_user).filter(otp_user.email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+    
+def addOTP(email: str, otp: str) -> None:
+    try:
+     engine = cf.get_db_engine()
+     Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+     with Session() as session:
+        otp_record = session.query(otp_user).filter_by(email=email).first()
+        if otp_record:
+            session.delete(otp_record)
+            session.commit()
+        new_user = otp_user(
+           email = email,
+           otp= otp 
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+    except:
+     engine = cf.get_db_engine1()
+     Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+     with Session() as session:
+        otp_record = session.query(otp_user).filter_by(email=email).first()
+        if otp_record:
+            session.delete(otp_record)
+            session.commit()
+        new_user = otp_user(
+           email = email,
+           otp= otp 
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+       
+def deleteOTP(email: str, otp:str) -> None:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+       otp_record = session.query(otp_user).filter_by(email=email, otp=otp).first()
+       if otp_record:
+            session.delete(otp_record)
+            session.commit()
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+       otp_record = session.query(otp_user).filter_by(email=email, otp=otp).first()
+       if otp_record:
+            session.delete(otp_record)
+            session.commit()

repository/UserInfoRepository.py

@@ -0,0 +1,139 @@
+from sqlalchemy.orm import sessionmaker
+from models import Database_Entity
+from repository import ConfigDatabase as cf
+user_info = Database_Entity.UserInfo
+users = Database_Entity.User
+from sqlalchemy.orm import sessionmaker
+import sys
+import os
+
+def getUserInfo(user_id: int) -> user_info:
+ try:
+   email = session.query(users.email).filter(users.id == user_id).one_or_none()
+   if email:
+        email = email[0]
+        user_record= session.query(user_info).filter(user_info.email == email).one_or_none()
+        if user_record:
+         session.close()
+         return user_record
+        else:
+         session.close()
+         return None
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == user_id).one_or_none()
+    if email:
+        email = email[0]
+        user_record= session.query(user_info).filter(user_info.email == email).one_or_none()
+        if user_record:
+         session.close()
+         return user_record
+        else:
+         session.close()
+         return None
+
+def getUserInfoByEmail(email:str) -> user_info:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    user_record= session.query(user_info).filter(user_info.email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    user_record= session.query(user_info).filter(user_info.email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+
+
+
+def addUserInfo(uid: str, email: str, display_name: str, photo_url: str) -> None:
+ try:
+     engine = cf.get_db_engine()
+     Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+     with Session() as session:
+        new_user = user_info(
+           uid = uid,
+           email = email,
+           display_name = display_name,
+           photo_url = photo_url
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+ except:
+     engine = cf.get_db_engine1()
+     Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+     with Session() as session:
+        new_user = user_info(
+           uid = uid,
+           email = email,
+           display_name = display_name,
+           photo_url = photo_url
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+
+def updateUserInfo(user_id, uid: str, email: str, display_name: str, photo_url: str) -> None:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        email = session.query(users.email).filter(users.id == user_id).one_or_none()
+        user_update= session.query(user_info).filter(user_info.email == email).one_or_none()
+        if user_update is not None:
+            user_update.uid = uid,
+            user_update.display_name = display_name,
+            user_update.photo_url = photo_url
+            session.commit()
+        session.close()
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        email = session.query(users.email).filter(users.id == user_id).one_or_none()
+        user_update= session.query(user_info).filter(user_info.email == email).one_or_none()
+        if user_update is not None:
+            user_update.uid = uid,
+            user_update.display_name = display_name,
+            user_update.photo_url = photo_url
+            session.commit()
+        session.close()
+
+
+def updateImage(user_id, photo_url: str) -> None:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        email = session.query(users.email).filter(users.id == user_id).one_or_none()
+        user_update= session.query(user_info).filter(user_info.email == email).one_or_none()
+        if user_update is not None:
+            user_update.photo_url = photo_url
+            session.commit()
+        session.close()
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+       email = session.query(users.email).filter(users.id == user_id).one_or_none()
+       user_update = session.query(user_info).filter(user_info.email == email).one_or_none()
+       if user_update is not None:
+           user_update.photo_url = photo_url
+           session.commit()
+       session.close()
+

repository/UserLoginRepository.py

@@ -0,0 +1,135 @@
+from sqlalchemy.orm import sessionmaker
+from models import Database_Entity
+from repository import ConfigDatabase as cf
+user_login = Database_Entity.UserLogin
+users = Database_Entity.User
+
+def getUserLogin(email: str) -> user_login:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    user_record = session.query(user_login).filter(user_login.user_email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    user_record = session.query(user_login).filter(user_login.user_email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+
+
+def getUserLoginById(id: int) -> user_login:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+    user_record = session.query(user_login).filter(user_login.user_email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+    email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+    user_record = session.query(user_login).filter(user_login.user_email == email).one_or_none()
+    if user_record:
+        session.close()
+        return user_record
+    else:
+        session.close()
+        return None
+   
+def addUserLogin(user_email: str, session_id : str) -> None:
+ try:
+     engine = cf.get_db_engine()
+     Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+     with Session() as session:
+        new_user = user_login(
+           user_email = user_email,
+           user_session_id = session_id
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+ except:
+     engine = cf.get_db_engine1()
+     Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+     with Session() as session:
+        new_user = user_login(
+           user_email = user_email,
+           user_session_id = session_id
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+
+
+def updateUserLogin(email: str, session_id : str ) -> None:
+ try:
+   engine = cf.get_db_engine()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        user_update= session.query(user_login).filter(user_login.user_email == email).one_or_none()
+        if user_update is not None:
+            user_update.user_session_id = session_id
+            session.commit()
+        session.close()
+ except:
+   engine = cf.get_db_engine1()
+   Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+   with Session() as session:
+        user_update= session.query(user_login).filter(user_login.user_email == email).one_or_none()
+        if user_update is not None:
+            user_update.user_session_id = session_id
+            session.commit()
+        session.close()
+
+
+
+def getUserSessionIdByUserEmail(id: int) -> user_login:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+     email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+     session.commit()
+     user_record= session.query(user_login.user_session_id).filter(user_login.user_email == email).one_or_none()[0]
+     session.commit()
+     print(user_record)
+     if user_record:
+        session.close()
+        return user_record
+     else:
+        session.close()
+        return None
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+     email = session.query(users.email).filter(users.id == id).one_or_none()[0]
+     session.commit()
+     user_record= session.query(user_login.user_session_id).filter(user_login.user_email == email).one_or_none()[0]
+     session.commit()
+     print(user_record)
+     if user_record:
+        session.close()
+        return user_record
+     else:
+        session.close()
+        return None

repository/UserRepository.py

@@ -0,0 +1,357 @@
+from sqlalchemy.orm import sessionmaker
+from models import Database_Entity
+from repository import ConfigDatabase as cf
+import pytz , datetime
+from datetime import timedelta
+user = Database_Entity.User
+
+def getUserIdByAccessToken(token:str) -> int:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.access_token == token).one_or_none()
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.access_token == token).one_or_none()
+        session.close()
+        return user_record
+
+def getUserIdByAccessTokenAndUserId(token:str,user_id: int) -> int:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.access_token == token,user.id == user_id).one_or_none()
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.access_token == token,user.id == user_id).one_or_none()
+        session.close()
+        return user_record
+
+def getUserByEmail(email: str) -> user:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user).filter(user.email == email).one_or_none()
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user).filter(user.email == email).one_or_none()
+        session.close()
+        return user_record
+
+def getUserIdByEmail(email: str) -> user.id:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.email == email).one_or_none()[0]
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.email == email).one_or_none()[0]
+        session.close()
+        return user_record
+
+def getUserById(user_id: str) -> user:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user).filter(user.id == user_id).one_or_none()
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user).filter(user.id == user_id).one_or_none()
+        session.close()
+        return user_record
+
+def getRefreshTokenUserByAccessToken(token: str) -> user.refresh_token:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.refresh_token).filter(user.access_token == token).one_or_none()
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.refresh_token).filter(user.access_token == token).one_or_none()
+        session.close()
+        return user_record
+
+
+def getUserIdByRefreshToken(refreshToken: str) -> user.refresh_token:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.refresh_token == refreshToken).one_or_none()[0]
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.id).filter(user.refresh_token == refreshToken).one_or_none()[0]
+        session.close()
+        return user_record
+
+def getRefreshTokenUserById(user_id: str) -> user.refresh_token:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.refresh_token).filter(user.id == user_id).one_or_none()[0]
+        session.close()
+        return user_record
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_record = session.query(user.refresh_token).filter(user.id == user_id).one_or_none()[0]
+        session.close()
+        return user_record
+
+def getEmailUser(email:str) -> user.email:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.email == email).one_or_none()
+        session.close()
+        return user_email
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.email == email).one_or_none()
+        session.close()
+        return user_email
+
+def getEmailUserById(user_id:int) -> user.email:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.id == user_id).one_or_none()[0]
+        session.close()
+        return user_email
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.id == user_id).one_or_none()[0]
+        session.close()
+        return user_email
+
+def getEmailUserByIdFix(user_id:int) -> user.email:
+  try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.id == user_id).one_or_none()
+        session.close()
+        return user_email
+  except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.id == user_id).one_or_none()
+        session.close()
+        return user_email
+
+
+
+def getEmailUserByAccessToken(token: str) -> user.email:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.access_token == token).one_or_none()
+        session.close()
+        return user_email
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_email = session.query(user.email).filter(user.access_token == token).one_or_none()
+        session.close()
+        return user_email
+
+
+def addUser(email: str, access_token: str, refresh_token: str, expires_at: datetime.datetime) -> None:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(bind=engine)
+    with Session() as session:
+        new_user = Database_Entity.User(
+            email=email,
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(bind=engine)
+    with Session() as session:
+        new_user = Database_Entity.User(
+            email=email,
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at
+        )
+        session.add(new_user)
+        session.commit()
+        session.close()
+
+
+def updateUserLogin(email: str, access_token: str, refresh_token: str, expires_at: datetime.datetime) -> bool:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.email == email).one_or_none()
+        if user_update:
+            user_update.email = email
+            user_update.access_token = access_token
+            user_update.refresh_token = refresh_token
+            user_update.expires_at = expires_at
+            session.commit()
+            session.close()
+            return True
+        else:
+            session.close()
+            return False
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.email == email).one_or_none()
+        if user_update:
+            user_update.email = email
+            user_update.access_token = access_token
+            user_update.refresh_token = refresh_token
+            user_update.expires_at = expires_at
+            session.commit()
+            session.close()
+            return True
+        else:
+            session.close()
+            return False
+
+       
+def updateAccessToken(user_id: int,access_token: str, expires_at: datetime.datetime) -> None:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.id == user_id).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.expires_at = expires_at
+            session.commit()
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.id == user_id).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.expires_at = expires_at
+            session.commit()
+
+def updateAccessTokenById(id: int,access_token: str, expires_at: datetime.datetime) -> None:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.id == id).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.expires_at = expires_at
+            session.commit()
+        session.close()
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.id == id).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.expires_at = expires_at
+            session.commit()
+        session.close()
+
+
+def UpdateAccessTokenRefreshToken(email: str, access_token: str, refresh_token: str, expires_at: datetime.datetime) -> None:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.email == email).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.refresh_token = refresh_token
+            user_update.expires_at = expires_at
+            session.commit()
+        session.close()
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.email == email).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.refresh_token = refresh_token
+            user_update.expires_at = expires_at
+            session.commit()
+        session.close()
+
+def UpdateAccessTokenRefreshTokenById(user_id: int,access_token: str, refresh_token: str, expires_at: datetime.datetime) -> None:
+ try:
+    engine = cf.get_db_engine()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.id == user_id).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.refresh_token = refresh_token
+            user_update.expires_at = expires_at
+            session.commit()
+        session.close()
+ except:
+    engine = cf.get_db_engine1()
+    Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    with Session() as session:
+        user_update = session.query(user).filter(user.id == user_id).one_or_none()
+        if user_update:
+            user_update.access_token = access_token
+            user_update.refresh_token = refresh_token
+            user_update.expires_at = expires_at
+            session.commit()
+        session.close()