Upload 15 files

controller/CallbackController.py

@@ -0,0 +1,207 @@
+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
+from models.Database_Entity import PaymentCallbackLog
+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")
+               PaymentCallbackLog(
+    type="zalopay",
+    app_trans_id=data_dict.get("app_trans_id"),
+    raw_data=data_dict,
+    status="success" if data_dict.get("status") == "1" else "fail",
+    is_refund = False
+).save()
+
+               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")
+               PaymentCallbackLog(
+    type="zalopay",
+    app_trans_id=data_dict.get("app_trans_id"),
+    raw_data=data_dict,
+    status="success" if data_dict.get("status") == "1" else "fail",
+    is_refund = False
+).save()
+               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")
+    PaymentCallbackLog(
+    type="momo",
+    order_id=order_id,
+    raw_data=json_data,
+    status="success" if result_code == 0 else "fail",
+    is_refund = False
+).save()
+    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)
+    PaymentCallbackLog(
+    type="momo",
+    order_id=order_id,
+    raw_data=json_data,
+    status="success" if result_code == 0 else "fail",
+    is_refund = False
+).save()
+
+    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)
+    # Lưu callback vnpay
+    PaymentCallbackLog(
+    type="vnpay",
+    txn_ref=params.get("vnp_TxnRef"),
+    raw_data=params,
+    status="success" if params.get("vnp_ResponseCode") == "00" else "fail",
+    is_refund = False
+).save()
+
+    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)
+    # Lưu callback vnpay
+    PaymentCallbackLog(
+    type="vnpay",
+    txn_ref=params.get("vnp_TxnRef"),
+    raw_data=params,
+    status="success" if params.get("vnp_ResponseCode") == "00" else "fail",
+    is_refund = False
+).save()
+
+    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,202 @@
+from fastapi import APIRouter, Form, Request,Depends,HTTPException,BackgroundTasks
+from service import ChatService
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from request import RequestChat
+from fastapi.requests import Request
+from fastapi.responses import JSONResponse
+import asyncio
+router = APIRouter()
+import asyncio
+# Lưu task đang chạy theo chat_history_id
+task_registry: dict[str, asyncio.Task] = {}
+# Lưu stop_event để dừng từng task
+stop_events: dict[str, asyncio.Event] = {}
+import decode_token
+from models.Database_Entity import StopSignal
+from models.Database_Entity  import ChatHistory, User
+from repository.MySQL import UserRepository
+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.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)
+
+
+from bson import ObjectId
+@router.post("/question")
+async def question(
+    request: RequestChat.ChatWithServer,
+    background_tasks: BackgroundTasks,
+    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)
+        chat_id = request.chat_history_id
+
+        stop_event = asyncio.Event()
+        stop_events[chat_id] = stop_event
+        print(f"[CREATE] stop_event id: {id(stop_event)} for chat_id: {chat_id}")
+        chat_history = ChatHistory.objects(pk=ObjectId(chat_id)).first()
+
+        if chat_history:
+         signal = StopSignal.objects(chat_history=chat_history).first()
+         if not signal:
+            signal = StopSignal(chat_history=chat_history)
+         signal.is_stopped = False
+         signal.stopped_at = None
+         signal.save()
+
+        async def run_chat():
+            try:
+                result = await ChatService.chat_with_user(
+                    request.user_input,
+                    user_id_token,
+                    request.language,
+                    user_role,
+                    token,
+                    chat_id,
+                    stop_event
+                )
+                return result
+            except asyncio.CancelledError:
+                print(f"🛑 Task {chat_id} was cancelled by asyncio.")
+                return {"status": "cancelled"}
+            except Exception as e:
+                print(f"❌ Lỗi trong task {chat_id}:", e)
+                return {"error": str(e)}
+            finally:
+                # Dọn dẹp
+                stop_events.pop(chat_id, None)
+                task_registry.pop(chat_id, None)
+
+        task = asyncio.create_task(run_chat())
+        task_registry[chat_id] = task
+        return await task
+
+    except Exception as e:
+        print("Lỗi khi chạy:", e)
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+    
+     
+from datetime import datetime
+@router.post("/stop-task/{chat_history_id}")
+async def stop_task(chat_history_id: str, token: str = Depends(jwt_bearer)):
+    user_id = int(decode_token.JwtService.extract_user_id(token))
+    if not isinstance(user_id, int) or user_id <= 0:
+        raise HTTPException(status_code=400, detail="Invalid user_id: must be a positive integer")
+    check = UserRepository.getUserByUserId(user_id)
+    if check is None:
+        raise HTTPException(status_code=400, detail="User not found or has been deleted in MySQL")
+    
+    check_history_id = UserRepository.getChatHistory(user_id,chat_history_id)
+    if check_history_id is None:
+        raise HTTPException(status_code=400, detail="Chat not found or has been deleted in MySQL")
+    
+    user = User.objects(user_id=user_id).first()
+    if not user:
+        return {"error": "User not found or has been deleted in MongoDB"}
+    
+    event = stop_events.get(chat_history_id)
+    task = task_registry.get(chat_history_id)
+
+    print(f"🚨 Đã vào stop-task với chat_history_id = {chat_history_id}")
+    print(f"🔎 stop_event: {event}, task: {task}")
+
+    # Set event trong RAM
+    if event:
+        print(f"🛑 Setting stop_event for {chat_history_id}")
+        event.set()
+
+    # Cancel task
+    if task:
+        print(f"🔪 Cancelling task for {chat_history_id}")
+        task.cancel()
+
+    # Cập nhật trạng thái stop vào MongoDB
+    from bson import ObjectId
+
+    chat_history = ChatHistory.objects(pk=ObjectId(chat_history_id)).first()
+
+    if chat_history:
+        signal = StopSignal.objects(chat_history=chat_history).first()
+        if not signal:
+            signal = StopSignal(chat_history=chat_history)
+        signal.is_stopped = True
+        signal.stopped_at = datetime.utcnow()
+        signal.save()
+    return {"message": f"Stop signal sent for chat_history_id {chat_history_id}"}
+
+
+@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)

controller/RefundController.py

@@ -0,0 +1,132 @@
+from fastapi import APIRouter, Request, Depends, HTTPException
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.requests import Request
+from fastapi.responses import JSONResponse
+import asyncio
+router = APIRouter()
+import asyncio
+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.")
+import sys,os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+jwt_bearer = JWTBearer()
+import decode_token
+
+from models.Database_Entity import StopSignal
+from models.Database_Entity  import ChatHistory,PaymentCallbackLog
+from service.RefundService import *
+from models.Database_Entity import PaymentCallbackLog
+from bson import ObjectId
+from mongoengine import connect
+MONGO_URI = "mongodb+srv://kltn20133118:XEYSVzYvEwsp5Cvo@cluster0.nnsw9.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0"
+connect("chatbot_hmdrinks", host=MONGO_URI)
+
+
+async def refund_by_type_and_code(type: str, code: str):
+    if type.lower() == "zalopay":
+        log = PaymentCallbackLog.objects(type="zalopay", app_trans_id=code,is_refund = False).first()
+        if not log:
+            return {"code": -3, "message": "Không tìm thấy giao dịch ZaloPay"}
+        data =  call_zalopay_refund(
+            app_trans_id=code,
+            amount=log.raw_data.get("amount", 0),
+            description="Hoàn tiền ZaloPay"
+        )
+        return_code = data.get("return_code")
+        if return_code == 3:
+            log.is_refund = True
+            log.save()
+            return {"code": 0 , "message": f"Hoàn tiền thành công", "data": data}
+        else:
+            log.is_refund = False
+            log.save()
+            return {"code": -1 , "message": f"Hoàn tiền thất bại", "data": data}
+      
+
+    elif type.lower() == "vnpay":
+        log = PaymentCallbackLog.objects(type="vnpay", txn_ref=code, is_refund = False).first()
+        if not log:
+            return {"code": -2, "message": "Không tìm thấy giao dịch VNPay"}
+        raw = log.raw_data
+        data =  call_vnpay_refund(
+            txn_ref=code,
+            amount=int(raw.get("vnp_Amount", 0)),  # VNPAY trả về x100
+            transaction_date=raw.get("vnp_PayDate"),
+            transaction_no=raw.get("vnp_TransactionNo"),
+            create_by="system_refund",
+            order_info=raw.get("vnp_OrderInfo", "Hoàn tiền VNPay")
+        )
+  
+        resultCode = data.get("data").get("vnp_ResponseCode")
+        message = data.get("data").get("vnp_Message")
+        if resultCode == "00":
+            log.is_refund = True
+            log.save()
+            return {"code": 0 , "message": f"Hoàn tiền thành công {message}", "data": data}
+        else:
+            log.is_refund = False
+            log.save()
+            return {"code": -1 , "message": f"Hoàn tiền thất bại {message}", "data": data}
+
+    elif type.lower() == "momo":
+        log = PaymentCallbackLog.objects(type="momo", order_id=code,is_refund = False).first()
+        if not log:
+            return {"code": -3, "message": "Không tìm thấy giao dịch MoMo"}
+        if log.raw_data.get("payType", "") != "qr":
+            return {"code": -2 , "message": f"Payment không thể hoàn tiền với ", "data": data}
+        data =  call_momo_refund(
+            trans_id=log.raw_data.get("transId", 0),
+            amount=log.raw_data.get("amount", 0),
+            description=f"Hoàn tiền MoMo cho giao dịch {code}"
+        )
+        resultCode = data.get("resultCode")
+        if resultCode == 0:
+            log.is_refund = True
+            log.save()
+            return {"code": 0 , "message": f"Hoàn tiền thành công", "data": data}
+        else:
+            log.is_refund = False
+            log.save()
+            return {"code": -1 , "message": f"Hoàn tiền thất bại", "data": data}
+    else:
+        return {"code": -4, "message": f"Không hỗ trợ cổng thanh toán '{type}'"}
+
+from fastapi import  HTTPException
+from pydantic import BaseModel
+
+
+class Refund(BaseModel):
+    type: str
+    code: str
+
+
+@router.post("/refund")
+async def refund_endpoint(request: Refund,token: str = Depends(jwt_bearer)):
+    type = request.type
+    code = request.code
+    user_role = decode_token.JwtService.extract_user_role(token)
+    if user_role != "ADMIN":
+        return JSONResponse(content={"message": "Not allow"}, status_code=404)
+    
+    data = asyncio.run(refund_by_type_and_code(type = type,code=code))
+    if data.get("code") != 0 :
+        return JSONResponse(content={"message": f"Not allow type {type}","status": -1, "data":data}, status_code=404)
+    else:
+        return JSONResponse(
+        content={
+            "status": 0,
+            "data": data
+        },
+        status_code=200
+    )
+