Upload 14 files

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 = "404E635266556A586E3272357538782F413F4428472B4B6250645367566B5970"
+JWT_ALGORITHM = "HS256"
+SECRET_KEY="404E635266556A586E3272357538782F413F4428472B4B6250645367566B5970"
+
+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=400, 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/CallbackController.py

@@ -0,0 +1,156 @@
+from fastapi import APIRouter, Request,HTTPException
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.requests import Request
+import yaml
+from typing import Dict
+from fastapi.responses import RedirectResponse
+from service import CallBackService
+import json
+from fastapi.responses import JSONResponse
+with open("config.yaml", "r") as f:
+    config = yaml.safe_load(f)
+base_backend_java  = config["callback_urls"]
+base_frontend = config["frontend"]
+
+router = APIRouter()
+
+class JWTBearer(HTTPBearer):
+    def __init__(self, auto_error: bool = True):
+        super(JWTBearer, self).__init__(auto_error=auto_error)
+
+    async def __call__(self, request: Request):
+        credentials: HTTPAuthorizationCredentials = await super(JWTBearer, self).__call__(request)
+        if credentials:
+            if credentials.scheme != "Bearer":
+                raise HTTPException(status_code=401, detail="Invalid authentication scheme.")
+            return credentials.credentials
+        else:
+            raise HTTPException(status_code=401, detail="Invalid authorization code.")
+
+jwt_bearer = JWTBearer()
+
+
+
+@router.post("/android/zalo")
+async def zalo_callback_post(request: Request):
+    try:
+        json_data = await request.json()
+        data_str =json_data.get("data")
+        if data_str:
+               data_dict = json.loads(data_str)
+               app_trans_id = data_dict.get("app_trans_id")
+               print(app_trans_id)
+               data = await CallBackService.zalo_callback(str(app_trans_id))
+               return data
+    except Exception as e:
+        print("Lỗi khi gọi callback web zalo:", e)
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+
+
+@router.post("/android/group/zalo")
+async def zalo_callback_post(request: Request):
+    try:
+        json_data = await request.json()
+        data_str =json_data.get("data")
+        if data_str:
+               data_dict = json.loads(data_str)
+               app_trans_id = data_dict.get("app_trans_id")
+               print(app_trans_id)
+               data = await CallBackService.zalo_group_callback(str(app_trans_id))
+               return data
+    except Exception as e:
+        print("Lỗi khi gọi callback group ảndroid zalo:", e)
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+
+
+@router.get("/android/payOs")
+async def return_url_handler(code: str = None, id: str = None, cancel: bool = None, status: str = None, orderCode: str = None):
+    try:
+     return await  CallBackService.android_payos_callback(status,orderCode)
+    except Exception as e:
+        print("Lỗi khi gọi callback android payos:", e)
+        # Trả về lỗi 500 - Internal Server Error
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+
+
+@router.get("/android/group/payOs")
+async def return_url_handler1(code: str = None, id: str = None, cancel: bool = None, status: str = None, orderCode: str = None):
+    try:
+     return await CallBackService.android_group_payOs_callback(status,orderCode)
+    except Exception as e:
+        print("Lỗi khi gọi callback group payos:", e)
+        # Trả về lỗi 500 - Internal Server Error
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+    
+
+@router.get("/web/payOs")
+async def return_url_handler(code: str = None, id: str = None, cancel: bool = None, status: str = None, orderCode: str = None):
+    try:
+     return await CallBackService.web_payos_callback(code, id, cancel, status, orderCode)
+    except Exception as e:
+        print("Lỗi khi gọi callback web payos:", e)
+        # Trả về lỗi 500 - Internal Server Error
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+       
+
+@router.post("/android/momo")
+async def return_url_handler(request: Request):
+    json_data = await request.json()
+    print(json_data)
+    data_str =json_data.get("data")
+    order_id = json_data.get("orderId")
+    result_code = json_data.get("resultCode")
+    print(data_str)
+
+    try:
+        result = await CallBackService.momo_callback(order_id,result_code)
+        print(result)
+    except Exception as e:
+        print("Lỗi khi gọi call back android momo:", e)
+        
+    if 0 != int(result_code):
+        return RedirectResponse(url=f"{base_frontend['android_redirect_base']}?status=-49")
+    else :
+        return RedirectResponse(url=f"{base_frontend['android_redirect_base']}?status=1")
+
+
+@router.post("/android/group/momo")
+async def return_url_handler(request: Request):
+    json_data = await request.json()
+    print(json_data)
+    data_str =json_data.get("data")
+    order_id = json_data.get("orderId")
+    result_code = json_data.get("resultCode")
+    print(data_str)
+
+    try:
+        result = await CallBackService.momo_group_callback(order_id,result_code)
+        print(result)
+    except Exception as e:
+        print("Lỗi khi gọi callback android group momo:", e)
+    if 0 != int(result_code):
+        return RedirectResponse(url=f"""{base_frontend["android_group_redirect_base"]}?status=-49""")
+    else :
+        return RedirectResponse(url=f"""{base_frontend["android_group_redirect_base"]}?status=1""")
+
+
+@router.get("/android/vnpay_ipn")
+async def vnpay_ipn(request: Request):
+    params: Dict[str, str] = dict(request.query_params)
+    try:
+     return await CallBackService.vnpay_callbackk(params)
+    except Exception as e:
+        print("Lỗi khi gọi callback vnpay:", e)
+        # Trả về lỗi 500 - Internal Server Error
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+
+
+@router.get("/android/group/vnpay_ipn")
+async def vnpay_ipn(request: Request):
+    params: Dict[str, str] = dict(request.query_params)
+    try:
+     return await CallBackService.vnpay_group_callback(params)
+    except Exception as e:
+        print("Lỗi khi gọi callback group vnpay ipn:", e)
+        # Trả về lỗi 500 - Internal Server Error
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)

controller/ChatController.py

@@ -0,0 +1,99 @@
+from fastapi import APIRouter, Form, Request,Depends,HTTPException
+from service import ChatService
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from request import RequestChat
+from fastapi.requests import Request
+from fastapi.responses import JSONResponse
+router = APIRouter()
+
+class JWTBearer(HTTPBearer):
+    def __init__(self, auto_error: bool = True):
+        super(JWTBearer, self).__init__(auto_error=auto_error)
+
+    async def __call__(self, request: Request):
+        credentials: HTTPAuthorizationCredentials = await super(JWTBearer, self).__call__(request)
+        if credentials:
+            if credentials.scheme != "Bearer":
+                raise HTTPException(status_code=401, detail="Invalid authentication scheme.")
+            return credentials.credentials
+        else:
+            raise HTTPException(status_code=401, detail="Invalid authorization code.")
+
+jwt_bearer = JWTBearer()
+import decode_token
+
+
+@router.get("/chat/user_history")
+async def get_user_chat_history(token: str = Depends(jwt_bearer)):
+    try:
+     user_id_token = decode_token.JwtService.extract_user_id(token)
+     return await ChatService.get_user_chat_history(user_id_token)
+    except Exception as e:
+        print("Lỗi khi gọi user history chat:", e)
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+
+
+@router.post("/new_chat/create/")
+async def create_chat(token: str = Depends(jwt_bearer)):
+  try:
+    user_id_token = decode_token.JwtService.extract_user_id(token)
+    new_chat = await ChatService.create_new_chat_history(user_id_token)
+    return new_chat
+  except Exception as e:
+        print("Lỗi khi gọi create new chat:", e)
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+
+
+@router.post("/question")
+async def question(request: RequestChat.ChatWithServer, token: str = Depends(jwt_bearer)):
+  try:
+    user_id_token = decode_token.JwtService.extract_user_id(token)
+    user_role = decode_token.JwtService.extract_user_role(token)
+    new_chat = await ChatService.chat_with_user(request.user_input,user_id_token,request.language,user_role,token,request.chat_history_id)
+    return new_chat 
+  except Exception as e:
+        print("Lỗi khi chạy:", e)
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+
+
+@router.put("/regenerate")
+async def regenerate(request: RequestChat.Regenerate,token: str = Depends(jwt_bearer)):
+    try:
+     user_id_token = decode_token.JwtService.extract_user_id(token)
+     user_role = decode_token.JwtService.extract_user_role(token)
+     new_chat = await ChatService.regenerate(request.question_new ,user_id_token,request.languages ,user_role,token,request.chat_id)
+     return new_chat
+    except Exception as e:
+        print("Lỗi khi gọi regenerate:", e)
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+
+@router.put("/update")
+async def update_chat_name(request: RequestChat.UpdateNameChat, token: str = Depends(jwt_bearer)):
+    try:
+     user_id_token = decode_token.JwtService.extract_user_id(token)
+     updated_chat = await ChatService.update_chat_name(request.chat_id, request.name_chat,user_id_token)
+     return updated_chat
+    except Exception as e:
+        print("Lỗi khi gọi update:", e)
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+
+
+@router.delete("/delete")
+async def delete_chat(request: RequestChat.DeleteChatRequest, token: str = Depends(jwt_bearer)):
+    try:
+     user_id_token = decode_token.JwtService.extract_user_id(token)
+     deleted_chat = await ChatService.soft_delete_chat(request.chat_id,user_id_token)
+     return deleted_chat
+    except Exception as e:
+        print("Lỗi khi gọi deleted:", e)
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+
+
+@router.get("/list_detail_chat/{chat_id}")
+async def get_chat_details(chat_id: str, token: str = Depends(jwt_bearer)):
+    try:
+     user_id_token = decode_token.JwtService.extract_user_id(token)
+     return await ChatService.get_chat_details(chat_id,user_id_token)
+    except Exception as e:
+        print("Lỗi khi gọi list_detail_chat:", e)
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)

controller/GroupOrderController.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter, Form, Request,Depends,HTTPException
+from service import ChatService
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from request import RequestChat
+from typing import Optional
+from fastapi.requests import Request
+from fastapi.responses import JSONResponse
+
+router = APIRouter()
+
+class JWTBearer(HTTPBearer):
+    def __init__(self, auto_error: bool = True):
+        super(JWTBearer, self).__init__(auto_error=auto_error)
+
+    async def __call__(self, request: Request):
+        credentials: HTTPAuthorizationCredentials = await super(JWTBearer, self).__call__(request)
+        if credentials:
+            if credentials.scheme != "Bearer":
+                raise HTTPException(status_code=401, detail="Invalid authentication scheme.")
+            return credentials.credentials
+        else:
+            raise HTTPException(status_code=401, detail="Invalid authorization code.")
+
+jwt_bearer = JWTBearer()
+import decode_token

controller/RecommendController.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter, Form, Request,Depends,HTTPException
+from service import ChatService
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from request import RequestChat
+from typing import Optional
+from fastapi.requests import Request
+
+
+router = APIRouter()
+
+class JWTBearer(HTTPBearer):
+    def __init__(self, auto_error: bool = True):
+        super(JWTBearer, self).__init__(auto_error=auto_error)
+
+    async def __call__(self, request: Request):
+        credentials: HTTPAuthorizationCredentials = await super(JWTBearer, self).__call__(request)
+        if credentials:
+            if credentials.scheme != "Bearer":
+                raise HTTPException(status_code=401, detail="Invalid authentication scheme.")
+            return credentials.credentials
+        else:
+            raise HTTPException(status_code=401, detail="Invalid authorization code.")
+
+jwt_bearer = JWTBearer()
+import decode_token

controller/RedirectController.py

@@ -0,0 +1,95 @@
+from fastapi import APIRouter, Form, Request,Depends,HTTPException
+from service import ChatService
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from request import RequestChat
+from typing import Optional
+from fastapi.requests import Request
+
+
+router = APIRouter()
+
+class JWTBearer(HTTPBearer):
+    def __init__(self, auto_error: bool = True):
+        super(JWTBearer, self).__init__(auto_error=auto_error)
+
+    async def __call__(self, request: Request):
+        credentials: HTTPAuthorizationCredentials = await super(JWTBearer, self).__call__(request)
+        if credentials:
+            if credentials.scheme != "Bearer":
+                raise HTTPException(status_code=401, detail="Invalid authentication scheme.")
+            return credentials.credentials
+        else:
+            raise HTTPException(status_code=401, detail="Invalid authorization code.")
+
+jwt_bearer = JWTBearer()
+import decode_token
+from service import RedirectService
+from typing import Optional
+from fastapi import Request, Query
+from fastapi.responses import JSONResponse
+@router.get("/android/zalo")
+async def zalo_callback_get(
+    amount: Optional[int] = Query(None),
+    appid: Optional[str] = Query(None),
+    apptransid: Optional[str] = Query(None),
+    bankcode: Optional[str] = Query(None),
+    checksum: Optional[str] = Query(None),
+    discountamount: Optional[int] = Query(None),
+    pmcid: Optional[int] = Query(None),
+    status: Optional[int] = Query(None)
+):
+    return await RedirectService.zalo_redirect(status)
+
+
+@router.get("/android/group/zalo")
+async def zalo_callback_get(
+    amount: Optional[int] = Query(None),
+    appid: Optional[str] = Query(None),
+    apptransid: Optional[str] = Query(None),
+    bankcode: Optional[str] = Query(None),
+    checksum: Optional[str] = Query(None),
+    discountamount: Optional[int] = Query(None),
+    pmcid: Optional[int] = Query(None),
+    status: Optional[int] = Query(None)
+):
+    return await RedirectService.zalo_group_redirect(status)
+
+@router.get("/web/zalo")
+async def zalo_web_callback_get(request: Request):
+    return await RedirectService.zalo_web_redirect(request.query_params)
+
+
+@router.get("/android/momo")
+async def return_url_handler_1(request: Request):
+    query_params = request.query_params
+    return await RedirectService.android_momo_redirect(query_params)
+
+@router.get("/android/group/momo")
+async def return_url_handler_group_momo(request: Request):
+    query_params = request.query_params
+    return await RedirectService.android_group_momo_redirect(query_params)
+
+
+from urllib.parse import urlencode
+@router.get("/web/momo")
+async def return_url_handler_web(request: Request):
+    query_params = request.query_params
+    return await RedirectService.web_momo_redirect(query_params)
+
+
+from typing import Dict
+@router.get("/android/vnpay")
+async def vnpay_ipn_redirect(request: Request):
+    params: Dict[str, str] = dict(request.query_params)
+    return await RedirectService.android_vnpay_ipn_redirect(params)
+
+
+@router.get("/android/group/vnpay")
+async def vnpay_ipn_redirect(request: Request):
+    params: Dict[str, str] = dict(request.query_params)
+    return await RedirectService.android_vnpay_group_ipn_redirect(params)
+
+@router.get("/web/vnpay")
+async def vnpay_ipn_redirect(request: Request):
+    query_params = request.query_params
+    return await RedirectService.web_vnpay_ipn_redirect(query_params)