13115292153

Committed 03 Feb 2025 02:07PM UTC coverage: 90.041% (-0.2%) from 90.222%

Build # 13115292153

Build Type

Pull #1779

github

Committed by

web-flow

Commit Message

Merge eabf68bed into 0e29863a1

Pull Request Pull Request #1779: Callback Service Change

Run Details

193 of 272 new or added lines in 6 files covered. (70.96%)

5 existing lines in 2 files now uncovered.

24656 of 27383 relevant lines covered (90.04%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.71

/kairon/async_callback/router/pyscript_callback.py

from typing import Optional
from blacksheep import Router, Request, Response as BSResponse
from blacksheep.contents import JSONContent

from loguru import logger
from kairon.async_callback.processor import CallbackProcessor
from kairon.exceptions import AppException

router = Router()


async def process_router_message(token: str, identifier: Optional[str] = None, req_type: str = 'GET', request: Request = None) -> BSResponse:
    """Process the incoming request for the callback."""
    if not request:
        raise AppException("Request is not valid!")

    data = {
        'type': req_type,
        'body': None,
        'params': {},
    }

    if request.query:
        data['params'].update({key: request.query.get(key) for key in request.query.keys()})

    try:
        req_data = None

        try:
            req_data = await request.json()
            logger.info('Request Body type: json')
        except Exception as e:
            logger.info('Request Body type: text')
            req_data = await request.read()
            if req_data and len(req_data) > 0:
                req_data = req_data.decode('utf-8')
            else:
                req_data = None

        if req_data:
            data.update({"body": req_data})

        request_source = request.scope.get("client", ["unknown"])[0]
        logger.info(f"Request source IP: {request_source}")
        logger.info(f"Data from request: {data}")
        print(request_source)

        data, message, error_code = await CallbackProcessor.process_async_callback_request(
            token, identifier, data, request_source
        )

        return BSResponse(
            status=200,
            content=JSONContent({
                "message": message,
                "data": data,
                "error_code": error_code,
                "success": error_code == 0,
            })
        )
    except AppException as ae:
        logger.error(f"AppException: {ae}")
        return BSResponse(
            status=400,
            content=JSONContent({
                "message": str(ae),
                "error_code": 400,
                "data": None,
                "success": False,
            })
        )
    except Exception as e:
        logger.exception(e)
        return BSResponse(
            status=500,
            content=JSONContent({
                "message": str(e),
                "error_code": 400,
                "data": None,
                "success": False
            })
        )


@router.get("/callback/d/{identifier}/{token}")
async def execute_async_action_get(request: Request, identifier: str, token: str) -> BSResponse:
    print(token, identifier)
    return await process_router_message(token, identifier, 'GET', request)


@router.post("/callback/d/{identifier}/{token}")
async def execute_async_action_post(request: Request, identifier: str, token: str) -> BSResponse:
    return await process_router_message(token, identifier, 'POST', request)


@router.put("/callback/d/{identifier}/{token}")
async def execute_async_action_put(request: Request, identifier: str, token: str) -> BSResponse:
    return await process_router_message(token, identifier, 'PUT', request)


@router.patch("/callback/d/{identifier}/{token}")
async def execute_async_action_patch(request: Request, identifier: str, token: str) -> BSResponse:
    return await process_router_message(token, identifier, 'PATCH', request)


@router.delete("/callback/d/{identifier}/{token}")
async def execute_async_action_delete(request: Request, identifier: str, token: str) -> BSResponse:
    return await process_router_message(token, identifier, 'DELETE', request)


@router.post("/callback/s/{token}")
async def execute_async_action_standalone_post(request: Request, token: str) -> BSResponse:
    return await process_router_message(token, None, 'POST', request)


@router.put("/callback/s/{token}")
async def execute_async_action_standalone_put(request: Request, token: str) -> BSResponse:
    return await process_router_message(token, None, 'PUT', request)


@router.patch("/callback/s/{token}")
async def execute_async_action_standalone_patch(request: Request, token: str) -> BSResponse:
    return await process_router_message(token, None, 'PATCH', request)

1	from typing import Optional	1✔
2	from blacksheep import Router, Request, Response as BSResponse	1✔
3	from blacksheep.contents import JSONContent	1✔
4
5	from loguru import logger	1✔
6	from kairon.async_callback.processor import CallbackProcessor	1✔
7	from kairon.exceptions import AppException	1✔
8
9	router = Router()	1✔
10
11
12	async def process_router_message(token: str, identifier: Optional[str] = None, req_type: str = 'GET', request: Request = None) -> BSResponse:	1✔
13	"""Process the incoming request for the callback."""
14	if not request:	1✔
15	raise AppException("Request is not valid!")	1✔
16
17	data = {	1✔
18	'type': req_type,
19	'body': None,
20	'params': {},
21	}
22
23	if request.query:	1✔
NEW 24	data['params'].update({key: request.query.get(key) for key in request.query.keys()})	×
25
26	try:	1✔
27	req_data = None	1✔
28
29	try:	1✔
30	req_data = await request.json()	1✔
31	logger.info('Request Body type: json')	1✔
UNCOV 32	except Exception as e:	×
UNCOV 33	logger.info('Request Body type: text')	×
NEW 34	req_data = await request.read()	×
UNCOV 35	if req_data and len(req_data) > 0:	×
36	req_data = req_data.decode('utf-8')	×
37	else:
UNCOV 38	req_data = None	×
39
40	if req_data:	1✔
41	data.update({"body": req_data})	1✔
42
43	request_source = request.scope.get("client", ["unknown"])[0]	1✔
44	logger.info(f"Request source IP: {request_source}")	1✔
45	logger.info(f"Data from request: {data}")	1✔
46	print(request_source)	1✔
47
48	data, message, error_code = await CallbackProcessor.process_async_callback_request(	1✔
49	token, identifier, data, request_source
50	)
51
52	return BSResponse(	1✔
53	status=200,
54	content=JSONContent({
55	"message": message,
56	"data": data,
57	"error_code": error_code,
58	"success": error_code == 0,
59	})
60	)
61	except AppException as ae:	1✔
62	logger.error(f"AppException: {ae}")	1✔
63	return BSResponse(	1✔
64	status=400,
65	content=JSONContent({
66	"message": str(ae),
67	"error_code": 400,
68	"data": None,
69	"success": False,
70	})
71	)
72	except Exception as e:	1✔
73	logger.exception(e)	1✔
74	return BSResponse(	1✔
75	status=500,
76	content=JSONContent({
77	"message": str(e),
78	"error_code": 400,
79	"data": None,
80	"success": False
81	})
82	)
83
84
85	@router.get("/callback/d/{identifier}/{token}")	1✔
86	async def execute_async_action_get(request: Request, identifier: str, token: str) -> BSResponse:	1✔
87	print(token, identifier)	1✔
88	return await process_router_message(token, identifier, 'GET', request)	1✔
89
90
91	@router.post("/callback/d/{identifier}/{token}")	1✔
92	async def execute_async_action_post(request: Request, identifier: str, token: str) -> BSResponse:	1✔
93	return await process_router_message(token, identifier, 'POST', request)	1✔
94
95
96	@router.put("/callback/d/{identifier}/{token}")	1✔
97	async def execute_async_action_put(request: Request, identifier: str, token: str) -> BSResponse:	1✔
98	return await process_router_message(token, identifier, 'PUT', request)	1✔
99
100
101	@router.patch("/callback/d/{identifier}/{token}")	1✔
102	async def execute_async_action_patch(request: Request, identifier: str, token: str) -> BSResponse:	1✔
103	return await process_router_message(token, identifier, 'PATCH', request)	1✔
104
105
106	@router.delete("/callback/d/{identifier}/{token}")	1✔
107	async def execute_async_action_delete(request: Request, identifier: str, token: str) -> BSResponse:	1✔
108	return await process_router_message(token, identifier, 'DELETE', request)	1✔
109
110
111	@router.post("/callback/s/{token}")	1✔
112	async def execute_async_action_standalone_post(request: Request, token: str) -> BSResponse:	1✔
113	return await process_router_message(token, None, 'POST', request)	1✔
114
115
116	@router.put("/callback/s/{token}")	1✔
117	async def execute_async_action_standalone_put(request: Request, token: str) -> BSResponse:	1✔
NEW 118	return await process_router_message(token, None, 'PUT', request)	×
119
120
121	@router.patch("/callback/s/{token}")	1✔
122	async def execute_async_action_standalone_patch(request: Request, token: str) -> BSResponse:	1✔
NEW 123	return await process_router_message(token, None, 'PATCH', request)	×

digiteinfotech / kairon / 13115292153

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous