14194024562

Committed 01 Apr 2025 11:06AM UTC coverage: 90.101% (-0.2%) from 90.343%

Build # 14194024562

Build Type

Pull #1882

github

Committed by

web-flow

Commit Message

Merge 33c7b495e into cf1b5e237

Pull Request Pull Request #1882: Callback pyscript final changes

Run Details

486 of 621 new or added lines in 13 files covered. (78.26%)

1 existing line in 1 file now uncovered.

25530 of 28335 relevant lines covered (90.1%)

0.9 hits per line

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

95.45

/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.route("/callback/d/{identifier}/{token}", methods=["GET", "POST", "PUT", "PATCH", "DELETE"])
async def execute_async_action(request: Request, identifier: str, token: str) -> BSResponse:
    return await process_router_message(token, identifier, request.method, request)


@router.route("/callback/s/{token}", methods=["POST", "PUT", "PATCH"])
async def execute_async_action_standalone(request: Request, token: str) -> BSResponse:
    return await process_router_message(token, None, request.method, 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✔
32	except Exception as e:	1✔
33	logger.info('Request Body type: text')	1✔
34	req_data = await request.read()	1✔
35	if req_data and len(req_data) > 0:	1✔
36	req_data = req_data.decode('utf-8')	1✔
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.route("/callback/d/{identifier}/{token}", methods=["GET", "POST", "PUT", "PATCH", "DELETE"])	1✔
86	async def execute_async_action(request: Request, identifier: str, token: str) -> BSResponse:	1✔
87	return await process_router_message(token, identifier, request.method, request)	1✔
88
89
90	@router.route("/callback/s/{token}", methods=["POST", "PUT", "PATCH"])	1✔
91	async def execute_async_action_standalone(request: Request, token: str) -> BSResponse:	1✔
92	return await process_router_message(token, None, request.method, request)	1✔

digiteinfotech / kairon / 14194024562

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