Delete controller

controller/CallbackController.py

@@ -1,156 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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)