From 63b72e3b14e4463e82fc385d989f7e7b3b57f0b1 Mon Sep 17 00:00:00 2001 From: mnjnhuang <1090031856@qq.com> Date: Wed, 19 Mar 2025 18:02:29 +0800 Subject: [PATCH] =?UTF-8?q?=E8=BF=81=E7=A7=BBGit=E9=A1=B9=E7=9B=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 3 + .../__pycache__/server_config.cpython-312.pyc | Bin 0 -> 2162 bytes framework/main_framework.py | 61 ++++++++++ framework/mysql_cli.py | 92 +++++++++++++++ framework/open_response.py | 72 ++++++++++++ framework/requests_dataclass.py | 43 +++++++ framework/response_code.py | 45 +++++++ framework/sample_requests.py | 111 ++++++++++++++++++ framework/server_config.py | 35 ++++++ framework/singleton_class.py | 26 ++++ main.py | 27 +++++ requirements | 3 + routers/__init__.py | 9 ++ routers/__pycache__/__init__.cpython-312.pyc | Bin 0 -> 377 bytes routers/search_gm.py | 101 ++++++++++++++++ 15 files changed, 628 insertions(+) create mode 100644 .gitignore create mode 100644 framework/__pycache__/server_config.cpython-312.pyc create mode 100644 framework/main_framework.py create mode 100644 framework/mysql_cli.py create mode 100644 framework/open_response.py create mode 100644 framework/requests_dataclass.py create mode 100644 framework/response_code.py create mode 100644 framework/sample_requests.py create mode 100644 framework/server_config.py create mode 100644 framework/singleton_class.py create mode 100644 main.py create mode 100644 requirements create mode 100644 routers/__init__.py create mode 100644 routers/__pycache__/__init__.cpython-312.pyc create mode 100644 routers/search_gm.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f682246 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +/.idea +/.venv +/test.py diff --git a/framework/__pycache__/server_config.cpython-312.pyc b/framework/__pycache__/server_config.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eef0349edaee3aaba06398073f16e2e169f0e935 GIT binary patch literal 2162 zcmb7F%WoS+7@ygf*NL622vw6b54X_5Cdg?L8kK?qv`Isy5LF~OU|CvR@49jDBbi+X z92qr8kw~Q?azV*~1Dqf#68{36DB?gO6~!7+sS>Aha^+T3J@I|BUN^4bz*zpCGqd00 zH#5IRqiqDn^gG{YW)wpHL?swnL#V$8!ZxvqO>-nq6O^JXfh;8?N*pSYX=2M8#8w>X zmh7*()mWU6g;xcy<|u(Tp_W6Yejn$Ulxw9zcBSNiq)Zh``E+BcV6>ssp9f)^I3z)B zl8|hgkZmcUlx0)l;W>w`I&7-2YSR0-0GI@9)>OG}S%p;Iu`J$ZS^1(}%Ap*wtd&wK z*YK#5Qx_Jdxq4yY^33EespBV~T)KEZx!^j?O}=gCvxThdv6NS2$t&gbVv6Oju;P-F z_S|INntnH#VepNQitNKAtbkCgbg_`hUW+f68CFpc6$Cc|WP{v`bgWNRBORYkF(Yud zWDTtlqy7P~&kp77$VF>U%`taYA!p4)if3`7}!(%*S`buCEX@o;2~afUWI(#PDs#qzzD4n z3s;F@OP~d5kqY{-AihrqEkGNf2((bsr-If@+15Y{H+><{1b)$C>!3jd{wNbOJi8V; z6BobiW+x$Q#>i`<@saU!@IMnD9UbEeD;7Pjjf{@HdUl*^_R^wtEuZ}hn#7fb`Ag@_ z2v^N!zF;jEna33iD#zRMWp^cKEf!rbkV^my-r?Jq zQ?3h8u>;*sd8w-@*9qo|oeY02LM@f{9A?T~ah+U-K^}yMEi0XaZ7j>h0>@(O>lp%O zRC{8A^`A!P@oK<(`h|G_*8Hyb3J`ORIbMks(!q&^ZxL*x0L~T&+oVF4(E7{(YZF9I zU0`j(rN!C=N{h7#krrzc98aw_{Yv|URw&?Jnl&}9h(0NzLwd6}db2Ab?1Ae*bFnd| z#`<9|Hh?6CC{C1%`Nd+QNxajqQ_F<4SWDCXWkxsb;JyiD zom5{M`u6%a*MC%gHhwayL&FC{6Z=CGwyhoC?n00T{;U%ABVN97sxIZ1#l4sjfC4hCzorSleMmv zL=SneqV6#ukf71|Mde0iXa1lszTX$$Gva%CT!5@4aQuV_9AW=ofzJ^(0&bJCK41)U zJRF-YB7jr-%&`f~*i&(7`%#r|l=t*55sDdMco8v#7{hDFzv=OuiF3#mJDc{{Fz8(M zO3OKijiK)>8lsH@oW{yn5Zo!Sin!kLPcq&&;?lvL-Sa>mZ;p5D3q z2wAO1QTx80uM=Rk2vvu77U~38O`~e}j`=sp-ToVcI|{rz@We8#8^iM@qUKuhD!yjo zi>w39;$6Z^<%#}=|7=dM*FnXiyI94VOewufj@>0k0b7#(P?D&zrPK+qx(tRI8XmTF N(eADBM+BJI^B?;I;c@@~ literal 0 HcmV?d00001 diff --git a/framework/main_framework.py b/framework/main_framework.py new file mode 100644 index 0000000..11401f4 --- /dev/null +++ b/framework/main_framework.py @@ -0,0 +1,61 @@ +from abc import abstractmethod +from time import sleep +import json +from framework.open_response import MinCustomException +from framework.mysql_cli import MysqlCliV3 +from framework.open_response import OpenResponse + + +class Response(OpenResponse): + """必须实现Core和Before_Response方法""" + + def __init__(self): + super(Response, self).__init__() + self._is_connect_mysql: bool = False + self.mysql_cli: MysqlCliV3 | None = None + + def set_connect_mysql(self, mysql_cli: MysqlCliV3 | None = None): + if mysql_cli is not None: + self._is_connect_mysql = True + self.mysql_cli = mysql_cli + + # def set_handle_success(self, handle_success: bool): + # self._handle_success = handle_success + + @abstractmethod + def core(self) -> None: + # TODO: 用于处理核心内容, 数据库逻辑等 + pass + + @abstractmethod + def before_response(self) -> dict: + # TODO: 用于创建返回的内容, 以及关闭数据库连接等 + pass + + def run_before_response(self) -> dict: + response_message: dict = self.before_response() + if self._is_connect_mysql: + self.mysql_cli.close_connect() + return response_message + + def run_core(self): + self.core() + if self._handle_success: + self.set_response_code(self.response_code_enum.RESPONSE_200_SUCCESS) + + +def main_function(response: Response) -> dict: + """ + :param response: 重写的Response类 + """ + try: + response.run_core() + except json.decoder.JSONDecodeError: + response.set_response_code(response.response_code_enum.RESPONSE_400_BAD_REQUESTS_JSON) + sleep(1) + response.echo = True + except MinCustomException as e: + response.set_response_code(e.args[0]) + sleep(1) + response.echo = True + return response.run_before_response() diff --git a/framework/mysql_cli.py b/framework/mysql_cli.py new file mode 100644 index 0000000..8ecb4db --- /dev/null +++ b/framework/mysql_cli.py @@ -0,0 +1,92 @@ +import pymysql +import copy +from framework.server_config import ServerConfig +from framework.response_code import MinCustomException, ResponseCode +from abc import ABC + + +class MysqlCliV3(ServerConfig): + def __init__(self): + super().__init__() + self._sql_response = { + "Status": False, + "Result": None, + "Execute_sql": None, + "Exception_error": None, + "Exception_code": 0 + } + self._initialize_connection() + + def _initialize_connection(self): + if not hasattr(self, "_connect"): + mysql_config = self.return_mysql_config() + self._connect = pymysql.connect( + host=mysql_config["host"], + user=mysql_config["user"], + password=mysql_config["password"], + database=mysql_config["database"], + port=mysql_config["port"] + ) + self._cursor = self._connect.cursor() + + def close_connect(self): + try: + self._cursor.close() + self._connect.close() + except pymysql.err.Error as e: + print(f"pymysql close: {e}") + + def execute_sql(self, sql: str, fetch_all: bool = False, commit_all: bool = False, + close_connect: bool = True) -> dict: + sql_response = copy.deepcopy(self._sql_response) + try: + self._cursor.execute(sql) + result = self._cursor.fetchall() if fetch_all else self._cursor.fetchone() + if commit_all: + self._connect.commit() + sql_response.update({ + "Status": True, + "Result": result, + "Execute_sql": sql + }) + except pymysql.err.IntegrityError as e: + sql_response.update({ + "Result": None, + "Exception_error": e, + "Exception_code": 1062, + "Execute_sql": sql + }) + self._connect.rollback() + self._print_result() + self.close_connect() + # raise + except Exception as e: + sql_response.update({ + "Result": None, + "Exception_error": e, + "Exception_code": 502, + "Execute_sql": sql + }) + self._connect.rollback() + self._print_result() + self.close_connect() + raise + if close_connect: + self.close_connect() + return sql_response + + def _print_result(self): + self.print_result(self._sql_response) + + @staticmethod + def print_result(mysql_result: dict): + print("-" * 50) + print("Database Operation Result:") + for key, value in mysql_result.items(): + print(f"{key}: {value}") + + def check_mysql_exception(self, mysql_result: dict, print_result: bool = False): + if not mysql_result.get("Status"): + if print_result: + self.print_result(mysql_result) + raise MinCustomException(ResponseCode.RESPONSE_501_NOT_IMPLEMENTED_EXCEPTION) diff --git a/framework/open_response.py b/framework/open_response.py new file mode 100644 index 0000000..d53ade9 --- /dev/null +++ b/framework/open_response.py @@ -0,0 +1,72 @@ +from abc import ABC +from framework.response_code import ResponseCode, MinCustomException +from datetime import datetime +from flask import request +import hashlib + + +class OpenABC(ABC): + """ + 提供公共函数和功能函数 + """ + + def __init__(self): + self.response_code_enum: ResponseCode = ResponseCode + + @staticmethod + def call_datetime(need_str: bool = True): + return str(datetime.now()) if need_str else datetime.now() + + @staticmethod + def md5sum(string: str): + md5 = hashlib.md5() + password = string.encode("utf-8") + md5.update(password) + return md5.hexdigest() + + @staticmethod + def make_exception(error_code: ResponseCode): + raise MinCustomException(error_code) + + +class OpenResponse(OpenABC): + def __init__(self): + super(OpenResponse, self).__init__() + self._response_code = self.response_code_enum.RESPONSE_100_CONTINUE # 错误代码, 默认Continue + self._response_data = None # 返回的数据 + self.response: dict = {} + self.echo = False # 是否打印消息 + self._handle_success: bool = False + + def make_response(self, use_custom_context: bool = False) -> dict: + if use_custom_context: + return self._response_data + response_code: ResponseCode = self._response_code + + err_code, err_message = response_code.return_tuple() + self.response = {"code": err_code, "message": err_message} + + if self._response_data is not None: + self.response.update({"data": self._response_data}) + + if self.echo is True: + print("-" * 50) + print("Interface ERROR:") + print(f"Echo url: {request.url}") + print(f"Echo methods: {request.method}") + if request.method == "GET": + print(f"Echo params: {request.args}") + elif request.method == "POST": + print(f"Echo data: {request.data}") + print(f"Echo response: {self.response}") + return self.response + + def set_response_data(self, data: object): + self._response_data = data + self._handle_success = True + + def set_response_code(self, code_enum: ResponseCode): + self._response_code = code_enum + + def make_debug_response(self): + raise MinCustomException(self.response_code_enum.RESPONSE_201_DEBUG) diff --git a/framework/requests_dataclass.py b/framework/requests_dataclass.py new file mode 100644 index 0000000..b2f0fda --- /dev/null +++ b/framework/requests_dataclass.py @@ -0,0 +1,43 @@ +from dataclasses import dataclass +import json as JSON +from flask import request +from framework.open_response import OpenABC +from framework.response_code import RequestMethods + + +@dataclass +class SampleRequests(OpenABC): + """ + 基本数据请求体 + login_username: str + login_password: str + self.login_username = self.check_string(self.json_data.get("login_username")) + self.login_password = self.check_string(self.json_data.get("login_token")) + """ + + def __init__(self, methods: RequestMethods, json_data: bytes | str | dict): + """ + :param methods: 请求方式, 需要传入枚举类型的数据 + :param json_data: 请求的数据, 如果是POST请求, 则为bytes|str类型 + 如果是GET请求, 则为dict类型 + """ + super().__init__() + if methods != RequestMethods.POST and methods != RequestMethods.GET: + self.make_exception(self.response_code_enum.RESPONSE_405_METHODS_NOT_ALLOW) + if methods == RequestMethods.POST: + self.json_data: dict = JSON.loads(json_data) + elif methods == RequestMethods.GET: + self.json_data = json_data + + def repr(self): + print(self.__repr__()) + + @staticmethod + def return_headers(): + return request.headers + + # def return_token(self) -> str: + # authorization = request.headers.get("Authorization") + # if authorization and authorization.startswith("Bearer"): + # return authorization.replace("Bearer ", "") + # self.make_exception(self.response_code_enum.RESPONSE_401_TOKEN_INVALID) diff --git a/framework/response_code.py b/framework/response_code.py new file mode 100644 index 0000000..a78ab8f --- /dev/null +++ b/framework/response_code.py @@ -0,0 +1,45 @@ +from enum import unique +from enum import Enum + + +class MinCustomException(Exception): + def __init__(self, error): + self.error = error + super().__init__(self.error) + + +@unique +class RequestMethods(Enum): + GET = 1 + POST = 2 + PUT = 3 + DELETE = 4 + + +@unique +class ResponseCode(Enum): + def __init__(self, code: int, message: str) -> None: + self.code: int = code + self.message: str = message + + # Main + RESPONSE_100_CONTINUE = 100, "Continue" + RESPONSE_200_SUCCESS = 200, "Success" + RESPONSE_201_DEBUG = 201, "Debug" + RESPONSE_502_BAD_GATEWAY = 502, "BadGateway" + RESPONSE_500_SERVER_ERROR = 500, "ServerError" + RESPONSE_405_METHODS_NOT_ALLOW = 405, "METHODS NOT ALLOW" + RESPONSE_501_NOT_IMPLEMENTED_EXCEPTION = 501.1, "NOT IMPLEMENTED" # 数据库语句异常 + RESPONSE_501_NOT_IMPLEMENTED_NULL = 501.2, "NOT IMPLEMENTED" # 数据库语句异常 + + RESPONSE_400_BAD_REQUESTS_JSON = 400.1, "JsonDecodeError" + RESPONSE_401_Unauthorized = 401, "Unauthorized" + RESPONSE_401_TOKEN_INVALID = 401.1, "TokenInvalid" + RESPONSE_401_TOKEN_EXPIRE = 401.2, "TokenExpire" + + # Request Params Warning + RESPONSE_PARAMS_IS_NULL = 10400, "未获取所有参数" + RESPONSE_PARAMS_IS_VALID = 10401, "请求参数错误" + + def return_tuple(self) -> tuple: + return self.code, self.message diff --git a/framework/sample_requests.py b/framework/sample_requests.py new file mode 100644 index 0000000..5ec523c --- /dev/null +++ b/framework/sample_requests.py @@ -0,0 +1,111 @@ +from framework.main_framework import Response, main_function +from framework.requests_dataclass import SampleRequests +from dataclasses import dataclass +from dataclasses import asdict +from flask import Blueprint +from flask import request +from framework.mysql_cli import MysqlCliV3 +from framework.response_code import RequestMethods + + +@dataclass +class OverrideSampleRequestParams(SampleRequests): + """ + 创建POST请求参数 + """ + + def __init__(self): + if request.method == "GET": + super(OverrideSampleRequestParams, self).__init__(json_data=request.args, methods=RequestMethods.GET) + if request.method == "POST": + super(OverrideSampleRequestParams, self).__init__(json_data=request.get_data(), methods=RequestMethods.POST) + + +@dataclass +class ResponseInterface: + """ + 返回的内容 + """ + + def convert_to_dict(self) -> dict: + """ + 调用这个函数将ResponseInterface数据类转成字典类型的数据 + :return: dict + """ + return asdict(self) + + +class OverrideMysqlCli(MysqlCliV3): + """ + 创建Mysql操作类 + """ + + def __init__(self): + super().__init__() + self.token_table = "accounts_info" + + def handle_search_token_valid(self, username: str, user_token: str) -> None: + # 验证登录token + sql = f""" + SELECT + username + FROM {self.token_table} + WHERE username = '{username}' AND user_token = '{user_token} AND 1=1' + """ + self.create_sql(sql) + mysql_result: dict = self.fetchone() + self.check_mysql_exception(mysql_result=mysql_result) + self.check_mysql_response_null(mysql_result=mysql_result) + + +class OverriderMainResponse(Response): + """ + 主要处理请求的类 + """ + + def __init__(self): + super(OverriderMainResponse, self).__init__() + # self.is_connect_mysql = connect_mysql + self.mysql_cli: MysqlCliV3 = MysqlCliV3() + self.set_connect_mysql(mysql_cli=self.mysql_cli) + + def core(self) -> None: + """ + 重写core函数处理核心内容 例如数据查询/数据处理 + """ + params = OverrideSampleRequestParams() + + """ + 处理完核心内容后将 handle_success 设置为True + self.handle_success = True + """ + self.set_handle_success(handle_success=True) + + def before_response(self) -> dict: + """ + 重写before_response函数 + 例如关闭mysql/redis连接等 + """ + return self.make_response() + + +""" +请不要忘记生成Flask蓝图 +""" +sample_interface = Blueprint("sample_interface", __name__) + +""" +请不要忘记指定URL路径 +请不要忘记执行main_function函数 +""" + + +@sample_interface.route("/sample/index", methods=["GET"]) +def main(): + """ + 实例化OverrideMainResponse类 并传入main_function中 + 您只重写core()和before_response() + 即可完成一个接口 它将返回一个dict直接发送给请求端 + """ + override_main_response = OverriderMainResponse() + return main_function(override_main_response) diff --git a/framework/server_config.py b/framework/server_config.py new file mode 100644 index 0000000..fda5ddf --- /dev/null +++ b/framework/server_config.py @@ -0,0 +1,35 @@ +from enum import unique +from enum import Enum + + +@unique +class ServerEnv(Enum): + DEBUG = 1, + BUILD = 2, + + +class ServerConfig(object): + def __init__(self, env: ServerEnv = ServerEnv.DEBUG): + super(ServerConfig, self).__init__() + self._listen: str = "0.0.0.0" + self._listen_port: int = 5000 + self._env: ServerEnv = env + + self._mysql_host = "192.168.160.223" + self._mysql_user = "root" + self._mysql_password = "123456" + self._mysql_database = "djh_gm" + self._mysql_port = 3306 + self._mysql_character = "UTF8" + + def return_mysql_config(self) -> dict: + _mysql_config: dict = {"host": self._mysql_host, "user": self._mysql_user, + "password": self._mysql_password, "database": self._mysql_database, + "charset": self._mysql_character, "port": self._mysql_port} + return _mysql_config + + def tell_listen(self) -> tuple: + return self._listen, self._listen_port + + def tell_env(self) -> ServerEnv: + return self._env diff --git a/framework/singleton_class.py b/framework/singleton_class.py new file mode 100644 index 0000000..4359f9a --- /dev/null +++ b/framework/singleton_class.py @@ -0,0 +1,26 @@ +from abc import ABC +from datetime import datetime +import hashlib + + +class SingletonFunction(ABC): + """ + 提供公共函数和功能函数 + """ + + def __init__(self): + pass + + @staticmethod + def call_datetime(need_str: bool = True): + return str(datetime.now()) if need_str else datetime.now() + + @staticmethod + def md5sum(string: str): + md5 = hashlib.md5() + password = string.encode("utf-8") + md5.update(password) + return md5.hexdigest() + + +singleton_function = SingletonFunction() diff --git a/main.py b/main.py new file mode 100644 index 0000000..da4b665 --- /dev/null +++ b/main.py @@ -0,0 +1,27 @@ +from flask import Flask +from flask import abort +from flask_cors import CORS +from framework.server_config import ServerEnv +from framework.server_config import ServerConfig +from routers import register_blueprints + +app = Flask(__name__) +CORS(app, supports_credentials=True) +register_blueprints(app) + + +@app.route("/") +def hello_world(): + return abort(403) + + +server: ServerConfig = ServerConfig(env=ServerEnv.DEBUG) + +# if server.tell_env() != ServerEnv.BUILD: +# # 开启计划任务 +# pass + +if __name__ == '__main__': + server_listen: tuple = server.tell_listen() + app.run(host=server_listen[0], port=server_listen[1], + debug=True if server.tell_env() == ServerEnv.DEBUG else False) diff --git a/requirements b/requirements new file mode 100644 index 0000000..b2f2228 --- /dev/null +++ b/requirements @@ -0,0 +1,3 @@ +pymysql +flask +flask-cors \ No newline at end of file diff --git a/routers/__init__.py b/routers/__init__.py new file mode 100644 index 0000000..23d1636 --- /dev/null +++ b/routers/__init__.py @@ -0,0 +1,9 @@ +from flask import Blueprint +from flask.app import Flask + +from .search_gm import search_gm_data_bp + + +def register_blueprints(app: Flask): + # app.register_blueprint(login_bp, url_prefix="/main") + app.register_blueprint(search_gm_data_bp) diff --git a/routers/__pycache__/__init__.cpython-312.pyc b/routers/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e07e3d1f2b9c71ccfcd0dba6f09581482aa1a7d7 GIT binary patch literal 377 zcmXw#u}Z{15QcZNi6&wy3kw@d)7%4yC@N^>aR}Fhz!EPTjV6~cyD8FH_zveQ2=^xT z76CyJ3%i3@UFA%;49m dict: + if table is not None: + self.table_name = table + sql = f""" + SELECT `base` , `uid` , `gameId`, `free`, `id`, `normalIcons`, `multiplier` + FROM {self.table_name} WHERE 1 = 1 AND `gameId` = {game_id} AND `uid` = {uid} + """ + mysql_result: dict = self.execute_sql(sql=sql, fetch_all=False, close_connect=False) + self.check_mysql_exception(mysql_result) + return mysql_result + + def delete_game_configuration_table_with_read_once(self, m_id: int, table: str | None = None) -> None: + if table is not None: + self.table_name = table + sql = f""" + DELETE FROM {self.table_name} WHERE 1 = 1 AND `id` = {m_id} + """ + mysql_result: dict = self.execute_sql(sql=sql, fetch_all=False, close_connect=True, commit_all=True) + self.check_mysql_exception(mysql_result) + + +class OverriderMainResponse(Response): + def __init__(self): + super(OverriderMainResponse, self).__init__() + self.mysql_cli: OverrideMysqlCli = OverrideMysqlCli() + self.set_connect_mysql(mysql_cli=self.mysql_cli) + + def core(self) -> None: + params: OverrideSampleRequestParams = OverrideSampleRequestParams() + mysql_result: dict = self.mysql_cli.search_game_configuration_table(game_id=params.gameId, uid=params.uid) + result: tuple = mysql_result.get("Result") + if result is None: + response_message: str = "code" + else: + base_message_from_mysql: str = result[0] + code_content: int = 1 + content_id: int = result[4] + not_use_base_field_game_id: list[str] = ['3000503', '3000524'] + + if str(params.gameId) in not_use_base_field_game_id: + normal_icons_from_mysql: str = result[5] + normal_icons_content: list[str] = normal_icons_from_mysql.split(",") + normal_icons_content_to_int: list[int] = [int(i) for i in normal_icons_content] + multiplier: int = result[6] + response_message: str = JSON.dumps({ + "code": code_content, + "data": {"normalIcons": normal_icons_content_to_int, "multiplier": multiplier} + }) + else: + base_content: list[str] = base_message_from_mysql.split(",") + base_content_to_int: list[int] = [int(i) for i in base_content] + free_content: str = result[3] + response_message: str = JSON.dumps({ + "code": code_content, + "data": {"base": base_content_to_int, "free": free_content} + }) + # self.mysql_cli.delete_game_configuration_table_with_read_once(m_id=content_id) + self.set_response_data(data=response_message) + + def before_response(self) -> dict: + return self.make_response(use_custom_context=True) + + +search_gm_data_bp = Blueprint("search_gm_data_bp", __name__) + + +@search_gm_data_bp.route("/test/result", methods=["GET"]) +def main(): + override_main_response = OverriderMainResponse() + return main_function(override_main_response)