Update test framework: fix run_tests.py to support all test files, add auto-import-check for test files

base_framework/platform_tools/IDF/app/api/controller/__init__.py

@@ -0,0 +1,128 @@
+# encoding: UTF-8
+import time
+import subprocess
+from subprocess import PIPE
+import os
+
+
+class OSType:
+    WIN, LINUX, UNKNOWN = range(3)
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def get_type():
+        import platform
+        system_name = platform.system()
+        if system_name.lower() == 'windows':
+            return OSType.WIN
+        elif system_name.lower() == 'linux':
+            return OSType.LINUX
+        else:
+            return OSType.UNKNOWN
+
+
+class tool(object):
+    def __init__(self):
+        self.env_port = 5011
+
+    def run_process(self, cmd_str, out_p=False):
+        """
+        run command
+        cmd_str unicode string.
+        """
+        if OSType.WIN == OSType.get_type():
+            # cmd_str = cmd_str.encode('gbk')
+            cmd_str = cmd_str
+        elif OSType.LINUX == OSType.get_type():
+            cmd_str = cmd_str.encode('utf-8')
+        else:
+            raise RuntimeError("your os is not support.")
+        close_fds = False if OSType.WIN == OSType.get_type() else True
+        if out_p:
+            p = subprocess.Popen(cmd_str, shell=True, close_fds=close_fds, stdout=PIPE)
+            p.wait()
+            return p.returncode, p.stdout.read()
+        else:
+            c = self.get_devnull()
+            p = subprocess.Popen(cmd_str, shell=True, close_fds=close_fds, stdout=c)
+            p.wait()
+            return p.returncode, None
+
+    def get_devnull(self):
+        try:
+            return subprocess.DEVNULL
+        except AttributeError:
+            # Python 2.x or older
+            return open(os.devnull, 'r+')
+
+    def _kills_pid(self):
+        if OSType.WIN == OSType.get_type():
+            kill_pid_cmd = "taskkill /f /pid {}".format(self.pid)
+        elif OSType.LINUX == OSType.get_type():
+            kill_pid_cmd = "kill -9 {}".format(self.pid)
+        else:
+            raise RuntimeError("your os is not support.")
+
+        res_code, res_context = self.run_process(kill_pid_cmd)
+        if res_code:
+            raise RuntimeError("kill pid: {} failed. error: {}".format(self.pid, res_context))
+
+    def check_port(self):
+        if OSType.WIN == OSType.get_type():
+            find_pid_win_cmd = 'netstat -ano | findstr {} | findstr LISTENING'.format(self.env_port)
+            print(find_pid_win_cmd)
+            res_code, res_context = self.run_process(find_pid_win_cmd, out_p=True)
+            if res_code == 0:
+                if len(res_context) > 0:
+                    try:
+                        self.pid = str(res_context).split()[-1].replace("\\r\\n'", "")
+                        self._kills_pid()
+                    except IndexError:
+                        pass
+
+        elif OSType.LINUX == OSType.get_type():
+            find_pid_linux_cmd = "lsof -i:{}".format(self.env_port)
+            res_code, res_context = self.run_process(find_pid_linux_cmd, out_p=True)
+            if res_code == 0:
+                # 获取pid
+                if len(res_context) > 0:
+                    try:
+                        self.pid = str(res_context).split("\n")[1].split()[1]
+                        self._kills_pid()
+                    except IndexError:
+                        pass
+        else:
+            raise RuntimeError("your os is not support.")
+
+    def run_manage(self):
+        count = 3
+        while count > 0:
+            self.run_manages()
+            find_pid_linux_cmd = "lsof -i:{}".format(self.env_port)
+            res_code, res_context = self.run_process(find_pid_linux_cmd, out_p=True)
+            print(res_code,"---res_code---",res_context,"---res_context---")
+            if len(res_context) > 0:
+                time.sleep(2)
+                pid = str(res_context).split("\n")[1].split()[1]
+                print(pid,"pid####")
+                count -= 1
+                if pid:
+                    break
+                else:
+                    continue
+            else:
+                break
+
+    def run_manages(self):
+        lod = "nohup python3 platform_tools/aida/manage.py &."
+        subprocess.call(["./5011.sh"])
+        # self.run_process(lod)
+
+
+if __name__ == '__main__':
+    test = tool()
+    test.check_port()
+    time.sleep(3)
+    test.run_manage()

base_framework/platform_tools/IDF/app/api/controller/commonController.py

@@ -0,0 +1,527 @@
+# encoding: UTF-8
+from ....common.sqlSession import SqlSession
+from ..service.createDataDetailService import CreateDetailService
+from ..service.createDataDictService import CreateDictService
+from ..service.createDataInfoService import CreateInfoService
+from ..service.createDataNumberService import CreateNumberService
+from ..service.createDataResultService import CreateResultService
+from ..model.createDataInfo import CreateInfo
+from ..model.createDetailInfo import CreateDetail
+from ..model.createDictInfo import CreateDict
+from datetime import datetime, timedelta
+from logger import logger
+import ast
+from operator import methodcaller
+import astunparse
+import os
+import re
+import time
+from sqlalchemy.exc import SQLAlchemyError
+
+
+class CommonController(object):
+    def __init__(self):
+        self.session = SqlSession()
+
+    def create_all_info(self, team_name, list_detail):
+        """
+        对比造数基础表数据，新增的进行录库
+        :return:
+        """
+        for detail in list_detail:
+            file_name = detail.get("file_name")
+            get_class_name = detail.get("class_name")
+            module_names = detail.get("module_name")
+            method_name = detail.get("method_name")
+            module_name = module_names.split(".")[0]
+            method_detail = detail.get("method_detail")
+            request_parameter = list(eval(detail.get("request_parameter")))
+            create_dict_service = CreateDictService()
+            create_detail_service = CreateDetailService()
+            create_info_service = CreateInfoService()
+            filter_detail_list = list()
+            filter_detail_list.append(CreateDetail.class_name == get_class_name)
+            filter_detail_list.append(CreateDetail.method_name == method_name)
+            filter_detail_list.append(CreateDetail.module_name == module_name)
+            get_data_detail = create_detail_service.get_detail_simple_data_by_filters(self.session,
+                                                                                      filter_detail_list)
+
+            # 数据字典中业务线配置的路径，用于获取各个业务线下的业务名称
+            filter_dict_list = list()
+            filter_dict_list.append(CreateDict.data_type == 1)
+            filter_dict_list.append(CreateDict.dict_key == team_name)
+            get_dict_detail = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_dict_list)
+            get_split_team_name = get_dict_detail.dict_value.split(".")[-1]
+            get_split_file_name = file_name.split(get_split_team_name)[-1]
+            if get_split_file_name:
+                get_file_name = get_split_file_name[1:].replace("\\", ".")
+            else:
+                get_file_name = ""
+            if get_data_detail:
+                compare_class_name = self.compare_string(get_data_detail.class_name, get_class_name)
+                compare_module_name = self.compare_string(get_data_detail.module_name, module_name)
+                compare_method_name = self.compare_string(get_data_detail.method_name, method_name)
+                compare_method_detail = self.compare_string(get_data_detail.method_detail, method_detail)
+                # compare_file_name = self.compare_string(get_data_detail.file_name, get_file_name)
+                update_info = {}
+                if compare_class_name:
+                    update_info["class_name"] = get_class_name
+                elif compare_module_name:
+                    update_info["module_name"] = module_name
+                elif compare_method_name:
+                    update_info["method_name"] = method_name
+                elif compare_method_detail:
+                    update_info["method_detail"] = method_detail
+                # elif compare_file_name:
+                #     get_data_detail.file_name = get_file_name
+                else:
+                    continue
+                update_info["modified_time"] = update_time()
+                print(update_info)
+                err_msg = create_detail_service.update_service_detail_data(self.session, update_info,
+                                                                           get_data_detail.create_data_detail_id)
+                if err_msg:
+                    return err_msg
+            else:
+                if method_name == "__init__":
+                    continue
+                if re.findall("__", method_name):
+                    continue
+                if method_name.startswith("_"):
+                    continue
+                dict_parameter = {}
+                if request_parameter:
+                    for parameter in request_parameter:
+                        if parameter != 'self':
+                            dict_parameter[parameter] = ""
+                else:
+                    dict_parameter = {}
+                get_method_detail = self.handle_method_detail(method_detail)
+                get_creator = self.get_creator_info(team=team_name, method_detail=method_detail)
+                if get_method_detail:
+                    get_function_details = get_method_detail
+                else:
+                    get_function_details = str(module_name) + "." + str(get_class_name) + "." + str(method_name)
+                add_detail_data = {}
+                add_info_data = {}
+                add_dict_data = {}
+                add_detail_data["create_data_detail_id"] = get_uuid()
+                add_detail_data["team_name"] = team_name
+                add_detail_data["file_name"] = get_file_name
+                add_detail_data["class_name"] = get_class_name
+                add_detail_data["del_flag"] = 0
+                add_detail_data["module_name"] = module_name
+                add_detail_data["method_name"] = method_name
+                add_detail_data["method_detail"] = method_detail
+                add_detail_data["method_function_detail"] = get_function_details
+                add_detail_data["creator"] = get_creator
+                add_detail_data["status"] = 0
+                add_detail_data["created_time"] = update_time()
+                add_detail_data["modified_time"] = update_time()
+                create_data_detail_id = create_detail_service.create_service_detail_data(self.session,
+                                                                                         add_detail_data)
+                add_info_data["create_data_info_id"] = get_uuid()
+                add_info_data["create_data_detail_id"] = create_data_detail_id
+                add_info_data["class_name"] = get_class_name
+                add_info_data["del_flag"] = 0
+                add_info_data["method_name"] = method_name
+                add_info_data["request_parameter"] = dict_parameter
+                add_info_data["created_time"] = get_time()
+                add_info_data["modified_time"] = get_time()
+                info_id = create_info_service.create_service_info_data(self.session, add_info_data)
+                filter_dict_type_list = list()
+                filter_dict_type_list.append(CreateDict.team_name == team_name.upper())
+                filter_dict_type_list.append(CreateDict.data_type == 3)
+                filter_dict_type_list.append(CreateDict.dict_key == get_file_name)
+                get_dict_detail = create_dict_service.get_dict_simple_data_by_filters(self.session,
+                                                                                      filter_dict_type_list)
+                add_dict_data["create_dict_data_id"] = get_uuid()
+                add_dict_data["data_type"] = 3
+                add_dict_data["team_name"] = team_name
+                add_dict_data["dict_key"] = get_file_name
+                add_dict_data["dict_value"] = get_file_name
+                add_dict_data["del_flag"] = 0
+                add_dict_data["created_time"] = get_time()
+                add_dict_data["modified_time"] = get_time()
+                if get_dict_detail or get_file_name == "":
+                    continue
+                else:
+                    dict_id = create_dict_service.create_service_dict_data(self.session, add_dict_data)
+        return True
+
+    def compare_string(self, sub_str1, sub_str2):
+        '''
+        对两个字符串进行比较，查看字符串是否相同
+        :param sub_str1:
+        :param sub_str2:
+        :return:
+        '''
+        if sub_str1 == sub_str2:
+            return False
+        else:
+            return True
+
+    def handle_dict_data(self, create_data_detail_id, data_type, dict_key):
+        '''
+        处理数据字典的路径类型，进行初始化路径组装
+        :return:
+        '''
+        create_detail_service = CreateDetailService()
+        create_dict_service = CreateDictService()
+        filter_detail_list = list()
+        filter_dict_list = list()
+        filter_detail_list.append(CreateDetail.create_data_detail_id == create_data_detail_id)
+        filter_dict_list.append(CreateDict.data_type == data_type)
+        filter_dict_list.append(CreateDict.dict_key == dict_key)
+        get_data_detail = create_detail_service.get_detail_simple_data_by_filters(self.session, filter_detail_list)
+        get_dict_data = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_dict_list)
+        if get_dict_data:
+            if get_data_detail.file_name:
+                get_new_path = get_dict_data.dict_value + "." + get_data_detail.file_name + "." + get_data_detail.module_name
+            else:
+                get_new_path = get_dict_data.dict_value + "." + get_data_detail.module_name
+            return {"get_new_path": get_new_path, "class_name": get_data_detail.class_name}
+        else:
+            return False
+
+    def handle_result_data(self, create_data_detail_id, create_data_info_id):
+        """
+        处理数据结果表
+        :return:
+        """
+        create_detail_service = CreateDetailService()
+        create_info_service = CreateInfoService()
+        filter_detail_list = list()
+        filter_data_list = list()
+        filter_detail_list.append(CreateDetail.create_data_detail_id == create_data_detail_id)
+        filter_data_list.append(CreateInfo.create_data_info_id == create_data_info_id)
+        get_data_detail = create_detail_service.get_detail_simple_data_by_filters(self.session, filter_detail_list)
+        get_data_info = create_info_service.get_data_simple_data_by_filters(self.session, filter_data_list)
+        dict_data = {"team_name": get_data_detail.team_name, "module_name": get_data_detail.module_name,
+                     "file_name": get_data_detail.file_name, "class_name": get_data_detail.class_name,
+                     "method_name": get_data_detail.method_name, "request_parameter": get_data_info.request_parameter,
+                     "method_function_detail": get_data_detail.method_function_detail}
+        return dict_data
+
+    def handle_method_detail(self, method_detail):
+        '''
+        对方法描述进行匹配出主要功能信息
+        :return:
+        '''
+        if method_detail:
+            get_function_detail = re.findall("功能说明： \|(.*)\|", method_detail)
+        else:
+            get_function_detail = "请补充方法注释"
+        if get_function_detail:
+            return get_function_detail
+        else:
+            get_function_details = re.findall("\s*功能(.+)", method_detail)
+            if get_function_details:
+                return get_function_details
+            else:
+                return False
+
+    def get_creator_info(self, team, method_detail):
+        '''
+        获取负责人信息
+        :return:
+        '''
+        if method_detail:
+            get_creators = re.findall("作者信息： \|(.*?)\|", method_detail)
+        else:
+            get_creators = ""
+        if get_creators:
+            return get_creators
+        else:
+            create_dict_service = CreateDictService()
+            filter_dict_list = list()
+            filter_dict_list.append(CreateDict.data_type == 5)
+            filter_dict_list.append(CreateDict.dict_key == team.upper())
+            get_data_detail = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_dict_list)
+            if get_data_detail:
+                return get_data_detail.dict_value
+            else:
+                return "未找到负责人"
+
+    def get_login_creator(self, token):
+        '''
+        获取造数使用者信息
+        :return:
+        '''
+        if token:
+            return token
+        else:
+            return "administrator"
+
+    def get_team_name(self, team):
+        """
+        各业务线对应枚举
+        :return:
+        """
+        # 业务线枚举映射
+        create_dict_service = CreateDictService()
+        filter_list = list()
+        filter_list.append(CreateDict.dict_key == team.upper())
+        filter_list.append(CreateDict.data_type == 2)
+        get_dict_data = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_list)
+        if get_dict_data:
+            return get_dict_data.dict_value
+        else:
+            return team
+
+    def get_module_name(self, team, dict_key):
+        """
+        各业务线模块对应枚举
+        :return:
+        """
+        # 业务线模块名称映射
+        create_dict_service = CreateDictService()
+        filter_list = list()
+        filter_list.append(CreateDict.team_name == team.upper())
+        filter_list.append(CreateDict.data_type == 3)
+        filter_list.append(CreateDict.dict_key == dict_key)
+        get_dict_data = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_list)
+        if get_dict_data:
+            return get_dict_data.dict_value
+        else:
+            return dict_key
+
+    def get_keyword_path(self, team, file_name=""):
+        """
+        获取某个组的关键字路径
+        :return:
+        """
+        # 业务线模块名称映射
+        create_dict_service = CreateDictService()
+        filter_list = list()
+        filter_list.append(CreateDict.dict_key == team.upper())
+        filter_list.append(CreateDict.data_type == 1)
+        get_data_detail = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_list)
+        get_list_path = get_data_detail.dict_value.split(".")
+        basic_path = os.path.dirname(os.path.abspath(__file__))
+        team_path = os.path.abspath(os.path.join(basic_path, '../../../../../../'))
+        if file_name.endswith(".py"):
+            return os.path.join(team_path, *get_list_path, file_name)
+        else:
+            return os.path.join(team_path, *get_list_path)
+
+    def get_model_name(self, team, dict_key):
+        '''
+        各业务线对应枚举
+        :param files_path:
+        :return:
+        '''
+        # 业务线模块名称映射
+        create_dict_service = CreateDictService()
+        filter_list = list()
+        filter_list.append(CreateDict.team_name == team.upper())
+        filter_list.append(CreateDict.dict_key == dict_key)
+        filter_list.append(CreateDict.data_type == 3)
+        get_data_detail = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_list)
+        if get_data_detail:
+            return get_data_detail.dict_value
+        else:
+            return dict_key
+
+    def daily_task_update_month_number(self):
+        """
+        定时任务，每天更新月使用次数
+        :return:
+        """
+
+        create_detail_service = CreateDetailService()
+        create_number_service = CreateNumberService()
+        create_result_service = CreateResultService()
+        # 假设时间字段为 `created_time`，格式为 'YYYYMMDDHHMM'
+        time_field_format = '%Y%m%d%H%M'
+        # 获取当前时间
+        now = datetime.now()
+        # 计算一个月前的时间
+        one_month_ago = now - timedelta(days=30)
+        # 将时间转换为目标格式的字符串
+        one_month_ago_str = one_month_ago.strftime(time_field_format)
+
+        all_number_methods = create_number_service.get_service_number_all_no_filters(session=self.session)
+        if len(all_number_methods) == 0:
+            return ""
+        for number in all_number_methods:
+            try:
+                if not self.session.object_session(number):
+                    self.session.add(number)  # 重新绑定对象到会话
+                get_number = create_result_service.get_service_result_numbers_by_month(session=self.session,
+                                                                                       create_data_detail_id=number.create_data_detail_id,
+                                                                                       one_month_ago_str=one_month_ago_str)
+                if get_number is None:
+                    get_number = 0
+                else:
+                    get_number = get_number[0]
+                create_number_service.update_service_number_data(session=self.session,
+                                                                 update_info={"month_number": get_number},
+                                                                 create_data_detail_id=number.create_data_detail_id)
+            except SQLAlchemyError as e:
+                self.session.rollback()
+            finally:
+                self.session.close()
+        return {"code": 20000, "message": "更新成功"}
+
+
+class LambdaCheck(ast.NodeVisitor):
+
+    def __init__(self):
+        self.illegal_args_list = []
+
+        self._cur_file = None
+        self._cur_lambda_args = []
+
+    def set_cur_file(self, cur_file):
+        assert os.path.isfile(cur_file), cur_file
+        self._cur_file = os.path.realpath(cur_file)
+
+    def visit_Lambda(self, node):
+        """
+        lambda 闭包检查原则：
+        只需检测lambda expr body中args是否引用了lambda args list之外的参数
+        """
+        self._cur_lambda_args = [a.id for a in node.args.args]
+        print(astunparse.unparse(node))
+        self.get_lambda_body_args(node.body)
+        self.generic_visit(node)
+
+    def record_args(self, name_node):
+        if isinstance(name_node, ast.Name) and name_node.id not in self._cur_lambda_args:
+            self.illegal_args_list.append((self._cur_file, 'line no:%s' % name_node.lineno, 'var:%s' % name_node.id))
+
+    def _is_args(self, node):
+        if isinstance(node, ast.Name):
+            self.record_args(node)
+            return True
+        if isinstance(node, ast.Call):
+            map(self.record_args, node.args)
+            return True
+        return False
+
+    def get_lambda_body_args(self, node):
+        if self._is_args(node): return
+        # for cnode in ast.walk(node):
+        for cnode in ast.iter_child_nodes(node):
+            if not self._is_args(cnode):
+                self.get_lambda_body_args(cnode)
+
+
+list_info = []  # 存爬取出来的方法列表
+
+
+class CodeVisitor(ast.NodeVisitor):
+    def __init__(self, file, file_name):
+        self.file = file
+        self.file_name = file_name
+        self.dict_info = {}
+
+    def visit_BinOp(self, node):  # 这个函数的访问是由于 Visit_FunctionDef的先访问再generic_visit才访问的
+        # print('Bin')  # 如果Visit_FunctionDef中没有generic_visit的话，则这个函数是不会访问的
+        if isinstance(node.op, ast.Add):
+            node.op = ast.Sub()
+        self.generic_visit(node)
+
+    def visit_ClassDef(self, node):
+        # print('Class Name: %s' % node.name)
+        global class_name
+        class_name = node.name
+        self.generic_visit(node)  # ClassDef中还包含有 BinOp,因此会进去visit BinOP
+        # print(dict_info)
+
+    def visit_FunctionDef(self, node):
+        # print('Function Name: %s' % node.name)
+        self.dict_info = {}
+        is_kwargs = node.args.kwarg
+        args = list([arg.arg for arg in node.args.args])
+        if is_kwargs is not None:
+            args.append("is_kwargs")
+        # print(str(args))
+        self.dict_info["file_name"] = self.file_name
+        self.dict_info["class_name"] = class_name
+        self.dict_info["module_name"] = self.file
+        self.dict_info["method_name"] = node.name
+        self.dict_info["request_parameter"] = str(args)
+        self.dict_info["method_detail"] = ast.get_docstring(node)
+        # print(ast.get_docstring(node))
+        list_info.append(self.dict_info)
+        self.generic_visit(node)  # FunctionDef中还包含有 BinOp,因此会进去visit BinOP
+
+
+def run(files_path, end_file, remove_file):
+    """
+    用于执行获取各个类中的方法与方法注解
+    :param files_path:需要爬取关键字的路径
+    :param end_file:爬取需要什么结尾的文件
+    :param remove_file:不需要爬取的文件路径的文件名称
+    :return:
+    """
+    if files_path.endswith(end_file):
+        checker = LambdaCheck()
+        checker.set_cur_file(files_path)
+        with open(files_path, 'rb') as f:
+            root_node = ast.parse(f.read())
+            visitor = CodeVisitor(os.path.basename(files_path), file_name="")
+            visitor.visit(root_node)
+    else:
+        for root, dirs, files in os.walk(files_path):
+            file_name = os.path.basename(root)
+            # if re.findall(remove_file, root):
+            #     continue
+            py_files = filter(lambda file: file.endswith(end_file), files)
+            checker = LambdaCheck()
+            for file in py_files:
+                file_path = os.path.join(root, file)
+                checker.set_cur_file(file_path)
+                with open(file_path, 'rb') as f:
+                    root_node = ast.parse(f.read())
+                    # print(file_name)
+                    visitor = CodeVisitor(file, root)
+                    visitor.visit(root_node)
+    return list_info
+
+
+def call_method(class_name, method_info):
+    '''
+    主要用于动态调用方法，
+    :param class_name:传入定义后的类名
+    :param method_name:传入方法与参数  eg:{"methodName":"kw_astwb_create_classes","requestParameter":{"user":"qiaoxinjiu","post_data_input={'studentMin':'2'}"}
+    :return:
+    '''
+    method_name = method_info.get("methodName")
+    if method_name:
+        request_data = method_info.get("requestParameter")
+        return methodcaller(method_name, **request_data)(class_name())
+    else:
+        return {"方法名输入错误"}
+
+
+def get_time():
+    """
+    获取当前时间
+    :return:
+    """
+    # now_time = datetime.datetime.now().strftime("%Y%m%d%H%M%S.%f")
+    now_time = time.strftime("%Y%m%d%H%M%S", time.localtime())
+    return now_time
+
+
+def update_time():
+    """
+    录入数据库时间
+    :return:
+    """
+    import datetime
+    now_time = datetime.datetime.now().strftime("%Y%m%d%H%M%S.%f")
+    return now_time
+
+
+def get_uuid():
+    '''
+    获取uuid
+    :return:
+    '''
+    import uuid
+    test_id = str(uuid.uuid1())
+    return test_id

base_framework/platform_tools/IDF/app/api/controller/createDataDetailController.py

@@ -0,0 +1,304 @@
+# encoding: UTF-8
+from ....common.sqlSession import SqlSession
+
+from ..service.createDataDetailService import CreateDetailService
+from ..service.createDataInfoService import CreateInfoService
+from ..service.createDataGroupService import CreateGroupService
+from ..service.createDataNumberService import CreateNumberService
+from ..model.createDetailInfo import CreateDetail
+from ..controller import commonController
+from ..controller.createDataResultController import CreateDataResultController
+from ..controller.createDataNumberController import CreateDataNumberController
+from logger import logger
+import time
+import json
+import importlib
+import sys
+
+
+class CreateDataDetailController(object):
+    def __init__(self, req_json, token):
+        self.session = SqlSession()
+        self.page = req_json.get('pageNo')
+        self.limit = req_json.get('pageSize')
+        self.create_data_detail_id = req_json.get('create_data_detail_id')
+        self.create_data_info_id = req_json.get('create_data_info_id')
+        self.team_name = req_json.get('team_name')
+        self.file_name = req_json.get('file_name')
+        self.module_name = req_json.get('module_name')
+        self.method_name = req_json.get('method_name')
+        self.detail_name = req_json.get('detail_name')
+        self.method_detail = req_json.get('method_detail')
+        self.method_function_detail = req_json.get('method_function_detail')
+        self.request_parameter = req_json.get('request_parameter')
+        self.dict_key = req_json.get('dict_key')
+        self.get_tag = req_json.get('get_tag')
+        self.email = req_json.get('email')
+        self.status = req_json.get('status')
+        self.token = token
+        self.del_flag = 0
+        self.req_json = req_json
+
+    def create_detail_data(self):
+        """
+        对造数列表进行新增
+        :return:
+        """
+
+    def update_detail_data(self):
+        """
+        对造数信息进行修改
+        :return:
+        """
+
+    def delete_detail_data(self):
+        """
+        对造数信息进行删除
+        :return:
+        """
+        create_detail_service = CreateDetailService()
+        del_info = create_detail_service.delete_service_detail_data(self.session,
+                                                                    create_data_detail_id=self.create_data_detail_id)
+        return del_info
+
+    def count_sucess_rate(self, total_number, right_number):
+        """
+        计算成功率
+        :return:
+        """
+        if total_number == 0:
+            return 0
+        else:
+            get_result = right_number / total_number
+            return round(get_result, 2)
+
+    def get_number_data(self, create_data_detail_id):
+        """
+        根据造数详情id查询对应的次数信息
+        :return:
+        """
+        create_number_service = CreateNumberService()
+        get_query_info, message = create_number_service.get_service_number_by_id(session=self.session,
+                                                                                 create_data_detail_id=create_data_detail_id)
+        if message:
+            if get_query_info:
+                return {"total_number": get_query_info.total_number,
+                        "success_rate": self.count_sucess_rate(get_query_info.total_number,
+                                                               get_query_info.right_number)}
+            else:
+                return {"total_number": 0,
+                        "success_rate": 0}
+        else:
+            return {"total_number": 0,
+                    "success_rate": 0}
+
+    def approve_detail_status(self):
+        """
+        审核状态
+        :return:
+        """
+        create_detail_service = CreateDetailService()
+        update_info = {"status": 1}
+        err_msg = create_detail_service.update_service_detail_data(self.session, update_info,
+                                                                   self.create_data_detail_id)
+        if err_msg:
+            return {"code": 40010, "message": err_msg}
+        else:
+            return {"code": 20000, "message": "审核成功"}
+
+    def get_detail_query_advance(self):
+        """
+        列表页查询
+        :return:
+        """
+        create_group_service = CreateGroupService()
+        if self.page is None:
+            self.page = 1
+        if self.limit is None:
+            self.limit = 10
+        create_detail_service = CreateDetailService()
+        common_controller = commonController.CommonController()
+        get_group_data = create_group_service.get_service_group_info_data_by_email(self.session, email=self.email)
+        list_group_user = ["ALL"]
+        filter_list = []
+        team_name = self.team_name
+        file_name = self.file_name
+        module_name = self.module_name
+        detail_name = self.detail_name
+        status = self.status
+        if team_name:
+            filter_list.append(CreateDetail.team_name == team_name)
+        if file_name:
+            filter_list.append(CreateDetail.file_name == file_name)
+        if module_name:
+            filter_list.append(CreateDetail.module_name == module_name)
+        if detail_name:
+            filter_list.append(CreateDetail.method_function_detail.like('%' + self.detail_name + '%'))
+        if status:
+            filter_list.append(CreateDetail.status == 1)
+        if filter_list:
+            if get_group_data:
+                list_group_user.append(get_group_data.team_name)
+            detail_list, total = create_detail_service.get_detail_list_by_filters_team_page(self.session,
+                                                                                            filter_list,
+                                                                                            list_group_user,
+                                                                                            self.page, self.limit)
+        else:
+            if get_group_data:
+                list_group_user.append(get_group_data.team_name)
+            detail_list, total = create_detail_service.get_detail_list_no_filters_team_page(self.session,
+                                                                                            list_group_user, self.page,
+                                                                                            self.limit)
+        ret_ls = []
+        for obj in detail_list:
+            ret_ls.append({
+                'create_data_detail_id': obj.create_data_detail_id,
+                'team_name': common_controller.get_team_name(obj.team_name),
+                'total_number': self.get_number_data(obj.create_data_detail_id).get("total_number"),
+                'success_rate': self.get_number_data(obj.create_data_detail_id).get("success_rate"),
+                'file_name': common_controller.get_module_name(team=obj.team_name, dict_key=obj.file_name),
+                'class_name': obj.class_name,
+                'module_name': obj.module_name,
+                'method_name': obj.method_name,
+                'method_function_detail': obj.method_function_detail,
+                'method_detail': obj.method_detail,
+                'status': obj.status,
+                'creator': obj.creator,
+                'created_time': obj.created_time,
+                'modified_time': obj.modified_time
+            })
+        return {"list": ret_ls, "total": total}
+
+    def get_request_parameter(self, request_parameter):
+        """
+        组成详情获取组装请求参数信息
+        :return:
+        """
+        try:
+            get_dict_parameter = request_parameter
+            # get_dict_parameter = json.loads(request_parameter)
+
+            dict_data = {}
+            for key, value in get_dict_parameter.items():
+                if key == "post_data_input":
+                    dict_data.update(get_dict_parameter.get("post_data_input"))
+                else:
+                    dict_data[key] = value
+            return dict_data
+        except:
+            return request_parameter
+
+    def get_detail_advance(self):
+        """
+        关键字基础信息详情页查询
+        :return:
+        """
+        create_info_service = CreateInfoService()
+        get_data_info = create_info_service.get_create_data_info_by_detail_id(session=self.session,
+                                                                              detail_id=self.create_data_detail_id)
+        create_detail_service = CreateDetailService()
+        get_detail_info = create_detail_service.get_create_detail_info_by_id(session=self.session,
+                                                                             create_data_detail_id=self.create_data_detail_id)
+        common_controller = commonController.CommonController()
+
+        _data = {'create_data_detail_id': get_data_info.create_data_detail_id,
+                 'create_data_info_id': get_data_info.create_data_info_id,
+                 'team_name': get_detail_info.team_name,
+                 'file_name': common_controller.get_model_name(team=get_detail_info.team_name,
+                                                               dict_key=get_detail_info.file_name),
+                 'class_name': get_data_info.class_name,
+                 'method_name': get_data_info.method_name,
+                 'method_detail': get_detail_info.method_detail,
+                 'method_function_detail': get_detail_info.method_function_detail,
+                 'creator': get_detail_info.creator,
+                 # 'request_parameter':unescape(str(_edit.request_parameter)),
+                 'request_parameter': self.get_request_parameter(get_data_info.request_parameter),
+                 'created_time': get_data_info.created_time,
+                 'modified_time': get_data_info.modified_time}
+        return _data
+
+    def run_keyword_data(self):
+        """
+        执行造数
+        :return:
+        """
+        create_info_service = CreateInfoService()
+        common_controller = commonController.CommonController()
+        data_type = 1
+        # creator = dict_data["creator"]
+        creator = common_controller.get_login_creator(self.email)
+        time.sleep(2)
+        # 查询请求参数的表用于判断传入的类名与方法名是否正确
+        get_data_info = create_info_service.get_create_data_info_by_id(session=self.session,
+                                                                       sid=self.create_data_info_id)
+        chushi_name = get_data_info.class_name
+
+        try:
+            get_parameter = json.loads(self.request_parameter)
+        except:
+            return {"code": 40009, "message": "请求参数格式不正确"}
+        create_data_result_id = commonController.get_uuid()
+        created_time = commonController.get_time()
+        modified_time = commonController.get_time()
+        get_result_info = common_controller.handle_result_data(create_data_detail_id=self.create_data_detail_id,
+                                                               create_data_info_id=self.create_data_info_id)
+        req_json = {"create_data_detail_id": self.create_data_detail_id,
+                    "method_name": get_result_info.get("method_name")}
+        create_number_controller = CreateDataNumberController(req_json=req_json, token=self.token)
+        req_json = {"create_data_result_id": create_data_result_id,
+                    "create_data_info_id": self.create_data_info_id,
+                    "create_data_detail_id": self.create_data_detail_id,
+                    "team_name": get_result_info.get("team_name"),
+                    "file_name": get_result_info.get("file_name"),
+                    "module_name": get_result_info.get("module_name"),
+                    "class_name": get_result_info.get("class_name"),
+                    "method_name": get_result_info.get("method_name"),
+                    "tag": self.get_tag,
+                    "status": 0,
+                    "method_function_detail": get_result_info.get("method_function_detail"),
+                    "request_parameter": get_parameter, "result_info": "",
+                    "creator": creator, "created_time": created_time, "modified_time": modified_time}
+        add_result_controller = CreateDataResultController(req_json=req_json, token=self.token)
+        add_result_id = add_result_controller.create_result_data(req_json)
+        try:
+            if get_data_info:
+
+                dict_key = self.dict_key
+                get_dict_info = common_controller.handle_dict_data(create_data_detail_id=self.create_data_detail_id,
+                                                                   data_type=data_type, dict_key=dict_key.upper())
+                if get_dict_info is False:
+                    return {"code": 500, "message": "字典中不存在该信息"}
+                method_info = {"methodName": get_data_info.method_name,
+                               "requestParameter": get_data_info.request_parameter}
+                class_name = get_data_info.class_name
+                print("get_new_path:", get_dict_info.get("get_new_path"))
+                test = importlib.import_module(get_dict_info.get("get_new_path"))
+                get_data_info.class_name = getattr(test, get_dict_info.get("class_name"))  # 实例化case
+                result_data = commonController.call_method(class_name=get_data_info.class_name,
+                                                           method_info=method_info)  # 返回造数结果
+                try:
+                    if isinstance(result_data, str):
+                        is_json = False
+                    else:
+                        is_json = True
+                    get_result = json.dumps(result_data, ensure_ascii=False)
+                except:
+                    is_json = False
+                    get_result = result_data
+                add_result_controller.update_result_data(sid=add_result_id, status=1, result_info=str(result_data))
+                get_data_info.class_name = class_name
+
+                create_number_controller.update_number_data(is_right=True)
+                data = {"message": "造数成功", "data": {"create_data_result_id": create_data_result_id, "data": get_result,
+                                                    "is_json": is_json}}
+            else:
+                data = {"message": "传入请求id未查询到相应信息"}
+            return data
+        except:
+            get_data_info.class_name = chushi_name
+            s = sys.exc_info()
+            create_number_controller.update_number_data(is_right=False)
+            add_result_controller.update_result_data(sid=add_result_id, status=2, result_info=str(s[1]))
+            logger.info('Error "%s" happend on line %d' % (s[1], s[2].tb_lineno))
+            data = {"message": "造数出现异常,异常为：{}".format(str(s[1]))}
+            return data

base_framework/platform_tools/IDF/app/api/controller/createDataDictController.py

@@ -0,0 +1,180 @@
+# encoding: UTF-8
+from datetime import datetime
+
+from ....common.sqlSession import SqlSession
+from ..controller import commonController
+from ..service.createDataDictService import CreateDictService
+from ..service.createDataGroupService import CreateGroupService
+from ..model.createDictInfo import CreateDict
+from ..controller.commonController import CommonController
+from logger import logger
+
+
+class CreateDataDictController(object):
+    def __init__(self, req_json, token):
+        self.session = SqlSession()
+        self.pageNo = req_json.get('pageNo')
+        self.pageSize = req_json.get('pageSize')
+        self.create_dict_data_id = req_json.get('create_dict_data_id')
+        self.team_name = req_json.get('team_name')
+        self.data_type = req_json.get('data_type')
+        self.dict_key = req_json.get('dict_key')
+        self.dict_value = req_json.get('dict_value')
+        self.email = req_json.get('email')
+        self.token = token
+        self.del_flag = 0
+        self.req_json = req_json
+
+    def create_dict_data(self):
+        """
+        对数据字典进行新增
+        :return:
+        """
+        common_controller = commonController.CommonController()
+
+        # 获取抓取的方法名称，描述等
+        create_dict_id = commonController.get_uuid()
+        created_time = commonController.get_time()
+        modified_time = commonController.get_time()
+
+        create_dict_service = CreateDictService()
+        filter_list = list()
+        filter_list.append(CreateDict.dict_value == self.team_name)
+        filter_list.append(CreateDict.data_type == 2)
+        # 获取抓取的方法名称，描述等
+        get_dict_value_data = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_list)
+        if get_dict_value_data:
+            dict_keys = get_dict_value_data.dict_key
+        else:
+            dict_keys = self.dict_key
+        filter_list_data = list()
+        filter_list_data.append(CreateDict.dict_key == self.dict_key)
+        filter_list_data.append(CreateDict.data_type == self.data_type)
+        filter_list_data.append(CreateDict.team_name == dict_keys)
+        filter_list_data.append(CreateDict.data_type == 2)
+        get_dict_data = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_list_data)
+        add_data = {
+            "create_dict_data_id": create_dict_id,
+            "data_type": self.data_type,
+            "team_name": self.team_name,
+            "dict_key": self.dict_key,
+            "dict_value": self.dict_value,
+            "del_flag": 0,
+            "created_time": created_time,
+            "modified_time": modified_time
+        }
+        create_data_info_id, err_msg = create_dict_service.create_service_dict_data(session=self.session,
+                                                                                    create_info=add_data)
+        return err_msg
+
+    def update_dict_data(self):
+        """
+        对数据字典进行修改
+        :return:
+        """
+        create_dict_service = CreateDictService()
+        filter_list = list()
+        filter_list.append(CreateDict.dict_value == self.team_name)
+        filter_list.append(CreateDict.data_type == 2)
+        # 获取抓取的方法名称，描述等
+        get_dict_value_data = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_list)
+        if get_dict_value_data:
+            dict_keys = get_dict_value_data.dict_key
+        else:
+            dict_keys = self.dict_key
+        filter_data_list = list()
+        filter_data_list.append(CreateDict.team_name == dict_keys)
+        filter_data_list.append(CreateDict.data_type == self.data_type)
+        filter_data_list.append(CreateDict.dict_key == self.dict_key)
+        get_dict_data = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_data_list)
+        if get_dict_data:
+            edit_dict_id = self.create_dict_data_id
+            filter_edit_list = list()
+            filter_edit_list.append(CreateDict.create_dict_data_id == edit_dict_id)
+            get_edit_data = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_edit_list)
+            edit_data = {'dict_value': self.dict_value, 'team_name': get_edit_data.team_name,
+                         'dict_key': get_edit_data.dict_key}
+            err_msg = create_dict_service.update_service_dict_data(session=self.session, update_info=edit_data,
+                                                                   create_dict_data_id=edit_dict_id)
+            if err_msg:
+                return err_msg
+        else:
+            add_data = {
+                'data_type': self.data_type,
+                'team_name': self.team_name,
+                'dict_key': self.dict_key,
+                'dict_value': self.dict_value,
+            }
+            create_data_info_id, err_msg = create_dict_service.create_service_dict_data(session=self.session,
+                                                                                        create_info=add_data)
+            if err_msg:
+                return err_msg
+
+    def get_dict_list_data(self):
+        """
+        数据字典列表页查询
+        :return:
+        """
+        if self.pageNo is None:
+            self.pageNo = 1
+        if self.pageSize is None:
+            self.pageSize = 10
+        create_dict_service = CreateDictService()
+        common_controller = CommonController()
+        create_group_service = CreateGroupService()
+        get_group_data = create_group_service.get_service_group_info_data_by_email(self.session, email=self.email)
+        list_group_user = ["ALL"]
+        filter_list = []
+        if self.team_name:
+            filter_list.append(CreateDict.team_name == self.team_name)
+        if self.dict_value:
+            filter_list.append(CreateDict.dict_value.like('%' + self.dict_value + '%'))
+        filter_list.append(CreateDict.data_type == 3)
+        if get_group_data:
+            list_group_user.append(get_group_data.team_name)
+        dict_list, total = create_dict_service.get_dict_list_by_team_filters_page(self.session, filter_list,
+                                                                                  list_group_user,
+                                                                                  self.pageNo, self.pageSize)
+        ret_ls = []
+        for obj in dict_list:
+            ret_ls.append({
+                'create_dict_data_id': obj.create_dict_data_id,
+                'team_name': common_controller.get_team_name(obj.team_name),
+                'data_type': obj.data_type,
+                'dict_key': obj.dict_key,
+                'dict_value': obj.dict_value,
+                'created_time': obj.created_time,
+                'modified_time': obj.modified_time,
+            })
+        return {"list": ret_ls, "total": total}
+
+    def get_team_name(self):
+        """
+        获取各个业务线的数据字典,用于查询
+        :return:
+        """
+        create_dict_service = CreateDictService()
+        create_group_service = CreateGroupService()
+        get_group_data = create_group_service.get_service_group_info_data_by_email(self.session, email=self.email)
+        list_group_user = ["ALL"]
+        filter_list = list()
+        filter_list.append(CreateDict.data_type == self.data_type)
+        if self.team_name:
+            filter_list.append(CreateDict.team_name == self.team_name)
+        if get_group_data:
+            list_group_user.append(get_group_data.team_name)
+        get_dict_data = create_dict_service.get_dict_list_by_team_filters_page(self.session, filter_list,
+                                                                               list_group_user, page=1,
+                                                                               limit=10)
+        list_data = []
+        if get_dict_data:
+            for value in get_dict_data[0]:
+                dict_value = {}
+                get_data_key = value.dict_key
+                get_data_value = value.dict_value
+                dict_value["value"] = get_data_key
+                dict_value["label"] = get_data_value
+                list_data.append(dict_value)
+            return list_data
+        else:
+            return get_dict_data

base_framework/platform_tools/IDF/app/api/controller/createDataInfoController.py

@@ -0,0 +1,94 @@
+# encoding: UTF-8
+from ....common.sqlSession import SqlSession
+
+from ..service.createDataInfoService import CreateInfoService
+from ..controller import commonController
+from ..model.createDataInfo import CreateInfo
+from logger import logger
+import json
+
+
+class CreateDataInfoController(object):
+    def __init__(self, req_json, token):
+        self.session = SqlSession()
+        self.create_data_info_id = req_json.get('create_data_info_id')
+        self.create_data_detail_id = req_json.get('create_data_detail_id')
+        self.className = req_json.get('className')
+        self.methodName = req_json.get('methodName')
+        self.request_parameter = req_json.get('request_parameter')
+        self.token = token
+        self.del_flag = 0
+        self.req_json = req_json
+
+    def create_info_data(self):
+        """
+        对造数详情进行新增
+        :return:
+        """
+        get_time = commonController.get_time()
+        get_request_parameter = json.loads(self.request_parameter)
+        request_parameter = self.get_method_request_parameter(create_data_info_id=self.create_data_info_id,
+                                                              request_param=get_request_parameter)
+        get_uuid = commonController.get_uuid()
+        add_data = {
+            'create_data_info_id': get_uuid,
+            'create_data_detail_id': self.create_data_detail_id,
+            'class_name': self.className,
+            'method_name': self.methodName,
+            'request_parameter': request_parameter,
+            'del_flag': self.del_flag,
+            'created_time': get_time,
+            'modified_time': get_time
+        }
+
+        create_info_service = CreateInfoService()
+        create_data_info_id, err_msg = create_info_service.create_service_info_data(session=self.session,
+                                                                                    create_info=add_data)
+        if err_msg:
+            return err_msg
+
+    def update_info_data(self):
+        """
+        编辑请求参数信息表
+        :return:
+        """
+        get_time = commonController.get_time()
+        get_request_parameter = json.loads(self.request_parameter)
+        request_parameter = self.get_method_request_parameter(create_data_info_id=self.create_data_info_id,
+                                                              request_param=get_request_parameter)
+        edit_data_id = self.create_data_info_id
+        edit_data = {'class_name': self.className, 'method_name': self.methodName,
+                     'request_parameter': request_parameter,'modified_time':get_time}
+        create_info_service = CreateInfoService()
+        err_msg = create_info_service.update_service_info_data(session=self.session, update_info=edit_data,
+                                                               create_data_info_id=edit_data_id)
+        if err_msg:
+            return err_msg
+
+    def get_method_request_parameter(self, create_data_info_id, request_param):
+        """
+        组装方法的请求参数
+        :param parameter:
+        :return:
+        """
+        # 定义请求的json
+        json_data = {}
+        # 查询抓取的请求参数信息
+        create_info_service = CreateInfoService()
+        get_data_info = create_info_service.get_create_data_info_by_id(session=self.session, sid=create_data_info_id)
+
+        get_db_parameter = get_data_info.request_parameter
+        # 判断如果请求参数里面含有**kwargs，组装请求
+        if "is_kwargs" in get_db_parameter:
+            json_data = request_param
+        else:
+            # 定义请求的json如果是json格式的参数，则组装json
+            post_data_input = {}
+            for key, value in request_param.items():
+                if key in get_db_parameter.keys():
+                    json_data[key] = value
+                else:
+                    post_data_input[key] = value
+            if "post_data_input" in get_db_parameter:
+                json_data["post_data_input"] = post_data_input
+        return json_data

base_framework/platform_tools/IDF/app/api/controller/createDataNumberController.py

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+from ....common.sqlSession import SqlSession
+
+from ..service.createDataNumberService import CreateNumberService
+from ..service.createDataDetailService import CreateDetailService
+from ..service.createDataInfoService import CreateInfoService
+from ..controller import commonController
+
+
+class CreateDataNumberController(object):
+    def __init__(self, req_json, token):
+        self.session = SqlSession()
+        self.create_data_detail_id = req_json.get('create_data_detail_id')
+        self.method_name = req_json.get('method_name')
+        self.token = token
+        self.del_flag = 0
+        self.req_json = req_json
+
+    def get_number_data(self, create_data_detail_id):
+        """
+        根据id查询对应的次数信息
+        :return:
+        """
+        create_number_service = CreateNumberService()
+        get_query_info = create_number_service.get_service_number_by_id(session=self.session,
+                                                                        create_data_detail_id=create_data_detail_id)
+
+    def create_result_data(self, add_data):
+        """
+        对造数结果数据进行统计
+        :return:
+        """
+        create_number_service = CreateNumberService()
+        create_data_info_id = create_number_service.create_service_number_data(session=self.session,
+                                                                               create_info=add_data)
+        return create_data_info_id
+
+    def update_number_data(self, is_right):
+        """
+        更新造数使用次数表
+        """
+        create_number_service = CreateNumberService()
+        try:
+            get_db_data_number, success = create_number_service.get_service_number_by_id(session=self.session,
+                                                                                         create_data_detail_id=self.create_data_detail_id)
+            if success:
+                if get_db_data_number:
+                    total_number = get_db_data_number.total_number
+                    error_number = get_db_data_number.error_number
+                    right_number = get_db_data_number.right_number
+                    month_number = get_db_data_number.month_number
+
+                    update_total_number = total_number + 1
+                    update_data = {"total_number": update_total_number}
+                    if is_right:
+                        update_right_number = right_number + 1
+                        update_month_number = month_number + 1
+                        update_data["right_number"] = update_right_number
+                        update_data["month_number"] = update_month_number
+                    else:
+                        update_error_number = error_number + 1
+                        update_data["error_number"] = update_error_number
+
+                    create_number_service = CreateNumberService()
+                    update_data_info_id = create_number_service.update_service_number_data(
+                        create_data_detail_id=self.create_data_detail_id, session=self.session,
+                        update_info=update_data)
+                    return "更新数据成功"
+                else:
+                    get_uuid = commonController.get_uuid()
+                    get_time = commonController.get_time()
+                    if is_right:
+                        right_number = 1
+                        error_number = 0
+                        month_number = 1
+                    else:
+                        right_number = 0
+                        error_number = 1
+                        month_number = 0
+                    add_data = {
+                        'id': get_uuid,
+                        'create_data_detail_id': self.create_data_detail_id,
+                        'method_name': self.method_name,
+                        'total_number': 1,
+                        'error_number': error_number,
+                        'right_number': right_number,
+                        'month_number': month_number,
+                        'del_flag': self.del_flag,
+                        'created_time': get_time,
+                        'modified_time': get_time,
+                    }
+                    self.create_result_data(add_data=add_data)
+            else:
+                return "更新数据失败"
+        except:
+            return "更新数据失败"
+
+    def do_history_data(self):
+        """
+        处理历史数据
+        :return:
+        """
+        create_detail_service = CreateDetailService()
+        create_number_service = CreateNumberService()
+        create_data_number_id = commonController.get_uuid()
+        created_time = commonController.get_time()
+        modified_time = commonController.get_time()
+        get_data_detail = create_detail_service.get_all_detail_list_no_filters_page(session=self.session)
+        list_update_data = []
+        for detail_info in get_data_detail:
+            get_create_number = create_number_service.get_service_number_by_id(session=self.session,
+                                                                               create_data_detail_id=detail_info.create_data_detail_id)
+            if get_create_number:
+                list_update_data.append(detail_info.create_data_detail_id)
+                create_number_service.update_service_number_data(session=self.session,
+                                                                 update_info={"method_name": detail_info.method_name},
+                                                                 create_data_detail_id=detail_info.create_data_detail_id)
+            else:
+                add_data = {
+                    "id": create_data_number_id,
+                    "create_data_detail_id": detail_info.create_data_detail_id,
+                    "method_name": detail_info.method_name,
+                    "total_number": 0,
+                    "error_number": 0,
+                    "right_number": 0,
+                    "del_flag": 0,
+                    "created_time": created_time,
+                    "modified_time": modified_time,
+                }
+                create_number_service.create_service_number_data(session=self.session, create_info=add_data)
+
+                list_update_data.append(detail_info.create_data_detail_id)
+
+        return list_update_data

base_framework/platform_tools/IDF/app/api/controller/createDataResultController.py

@@ -0,0 +1,186 @@
+# encoding: UTF-8
+from ....common.sqlSession import SqlSession
+
+from ..service.createDataResultService import CreateResultService
+from ..service.createDataInfoService import CreateInfoService
+from ..service.createDataDetailService import CreateDetailService
+from ..service.createDataGroupService import CreateGroupService
+
+from ..controller import commonController
+from ..model.createResultInfo import CreateResult
+from logger import logger
+import json
+
+
+class CreateDataResultController(object):
+    def __init__(self, req_json, token):
+        self.session = SqlSession()
+        self.page = req_json.get('pageNo')
+        self.limit = req_json.get('pageSize')
+        self.create_data_result_id = req_json.get('create_data_result_id')
+        self.create_data_info_id = req_json.get('create_data_info_id')
+        self.create_data_detail_id = req_json.get('create_data_detail_id')
+        self.team_name = req_json.get('team_name')
+        self.file_name = req_json.get('file_name')
+        self.module_name = req_json.get('module_name')
+        self.class_name = req_json.get('class_name')
+        self.method_name = req_json.get('method_name')
+        self.tag = req_json.get('get_tag')
+        self.status = req_json.get('status')
+        self.method_function_detail = req_json.get('method_function_detail')
+        self.detail_name = req_json.get('detail_name')
+        self.request_parameter = req_json.get('request_parameter')
+        self.result_info = req_json.get('result_info')
+        self.creator = req_json.get('creator')
+        self.email = req_json.get('email')
+        self.token = token
+        self.del_flag = 0
+        self.req_json = req_json
+
+    def create_result_data(self, add_data):
+        """
+        对造数结果进行新增
+        :return:
+        """
+        add_data["del_flag"] = self.del_flag
+        create_result_service = CreateResultService()
+        create_data_info_id = create_result_service.create_result_data(session=self.session,
+                                                                       create_info=add_data)
+        return create_data_info_id
+
+    def update_result_data(self, sid, status, result_info):
+        """
+        对返回结果进行编辑
+        """
+        edit_data = {'result_info': result_info, 'status': status}
+        create_result_service = CreateResultService()
+        err_msg = create_result_service.update_service_result_data(session=self.session, update_info=edit_data,
+                                                                   sid=sid)
+        if err_msg:
+            return err_msg
+
+    def get_method_request_parameter(self, create_data_info_id, request_param):
+        """
+        组装方法的请求参数
+        :param parameter:
+        :return:
+        """
+        # 定义请求的json
+        json_data = {}
+        # 查询抓取的请求参数信息
+        create_info_service = CreateInfoService()
+        get_data_info = create_info_service.get_create_data_info_by_id(session=self.session, sid=create_data_info_id)
+
+        get_db_parameter = get_data_info.request_parameter
+        # 判断如果请求参数里面含有**kwargs，组装请求
+        if "is_kwargs" in get_db_parameter:
+            json_data = request_param
+        else:
+            # 定义请求的json如果是json格式的参数，则组装json
+            post_data_input = {}
+            for key, value in request_param.items():
+                if key in get_db_parameter.keys():
+                    json_data[key] = value
+                else:
+                    post_data_input[key] = value
+            if "post_data_input" in get_db_parameter:
+                json_data["post_data_input"] = post_data_input
+        return json_data
+
+    def get_result_query_list(self):
+        """
+        结果列表页查询
+        :return:
+        """
+        create_group_service = CreateGroupService()
+        if self.page is None:
+            self.page = 1
+        if self.limit is None:
+            self.limit = 10
+        create_result_service = CreateResultService()
+        common_controller = commonController.CommonController()
+        get_group_data = create_group_service.get_service_group_info_data_by_email(self.session, email=self.email)
+        filter_list = []
+        team_name = self.team_name
+        get_tag = self.tag
+        detail_name = self.detail_name
+        list_group_user = ["ALL"]
+        if team_name:
+            filter_list.append(CreateResult.team_name == team_name)
+        if detail_name:
+            filter_list.append(CreateResult.method_function_detail.like('%' + detail_name + '%'))
+        if get_tag:
+            filter_list.append(CreateResult.tag.like('%' + get_tag + '%'))
+
+        if filter_list:
+            if get_group_data:
+                list_group_user.append(get_group_data.team_name)
+            detail_list, total = create_result_service.get_result_list_by_team_filters_page(self.session, filter_list,
+                                                                                            list_group_user,
+                                                                                            self.page, self.limit)
+        else:
+            if get_group_data:
+                list_group_user.append(get_group_data.team_name)
+            detail_list, total = create_result_service.get_result_list_no_team_filters_page(self.session,
+                                                                                            list_group_user, self.page,
+                                                                                            self.limit)
+        ret_ls = []
+        for obj in detail_list:
+            ret_ls.append({
+                'create_data_result_id': obj.create_data_result_id,
+                'create_data_info_id': obj.create_data_info_id,
+                'create_data_detail_id': obj.create_data_detail_id,
+                'team_name': common_controller.get_team_name(obj.team_name),
+                'request_parameter': json.dumps(obj.request_parameter),
+                'result_info': obj.result_info,
+                'tag': obj.tag,
+                'class_name': obj.class_name,
+                'module_name': obj.module_name,
+                'method_name': obj.method_name,
+                'method_function_detail': obj.method_function_detail,
+                'creator': obj.creator,
+                'created_time': obj.created_time,
+                'modified_time': obj.modified_time
+            })
+        return {"list": ret_ls, "total": total}
+
+    def get_result_advance(self):
+        """
+        关键字造数结果详情页查询
+        :return:
+        """
+        create_result_service = CreateResultService()
+        get_data_result = create_result_service.get_create_result_by_id(session=self.session,
+                                                                        create_data_result_id=self.create_data_result_id)
+        create_detail_service = CreateDetailService()
+        get_detail_info = create_detail_service.get_create_detail_info_by_id(session=self.session,
+                                                                             create_data_detail_id=get_data_result.create_data_detail_id)
+
+        common_controller = commonController.CommonController()
+        try:
+            is_json = True
+            get_result = json.dumps(eval(get_data_result.result_info), ensure_ascii=False)
+        except:
+            is_json = False
+            get_result = get_data_result.result_info
+        _data = {'create_data_result_id': get_data_result.create_data_result_id,
+                 'create_data_detail_id': get_data_result.create_data_detail_id,
+                 'team_name': get_detail_info.team_name,
+                 'file_name': common_controller.get_model_name(team=get_detail_info.team_name,
+                                                               dict_key=get_detail_info.file_name),
+                 'module_name': get_data_result.module_name,
+                 'class_name': get_data_result.class_name,
+                 'method_name': get_data_result.method_name,
+                 'method_detail': get_detail_info.method_detail,
+                 'request_parameter': get_data_result.request_parameter,
+                 # 'method_function_detail': CreateDictData.query.filter_by(del_flag=0, data_type=2,
+                 #                                                          dict_key=get_detail_info.method_name).first().dict_value,
+                 'method_function_detail': get_detail_info.method_function_detail,
+                 'result_info': get_result,
+                 'creator': get_data_result.creator,
+                 'get_tag': get_data_result.tag,
+                 'is_json': is_json,
+                 'created_time': get_data_result.created_time,
+                 'modified_time': get_data_result.modified_time}
+
+        return _data

base_framework/platform_tools/IDF/app/api/controller/scrapyController.py

@@ -0,0 +1,112 @@
+# encoding: UTF-8
+from ....common.sqlSession import SqlSession
+from ..service.createDataDictService import CreateDictService
+from ..controller import commonController
+from logger import logger
+from ..model.createDictInfo import CreateDict
+import os
+from base_framework.public_tools.eureka_api import EurekaAPI
+import configparser
+
+
+class ScrapyController(object):
+    def __init__(self, req_json, token):
+        self.session = SqlSession()
+        self.file_name = req_json.get('fileName')
+        self.get_team = req_json.get('team')
+        self.team_name = self.get_team.upper()
+        self.username = req_json.get('username')
+        self.password = req_json.get('password')
+        self.token = token
+        self.del_flag = 0
+        self.req_json = req_json
+
+    def scrapy_enter_db(self):
+        """
+        对抓取的数据进行入库
+        :return:
+        """
+        get_common_controller = commonController.CommonController()
+        create_dict_service = CreateDictService()
+        filter_list = list()
+        filter_list.append(CreateDict.dict_key == self.team_name)
+        filter_list.append(CreateDict.data_type == 1)
+        get_team_data = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_list)
+        if get_team_data:
+            get_path = get_common_controller.get_keyword_path(team=self.team_name, file_name=self.file_name)  # 获取路径值
+            print("get_path:", get_path)
+            team_name = self.team_name
+            get_team = team_name.upper()
+            if get_team == "ALL":
+                get_list_data = commonController.run(files_path=get_path, end_file="_public_business.py",
+                                                     remove_file="common")
+            else:
+                get_list_data = commonController.run(files_path=get_path, end_file=".py", remove_file="")
+            get_scrapy_info = get_common_controller.create_all_info(team_name=self.team_name, list_detail=get_list_data)
+            if get_scrapy_info:
+                err_msg = "抓取成功"
+            else:
+                err_msg = "未成功抓取数据，请重试"
+        else:
+            err_msg = "请检查数据字典，输入正确的组名"
+        return err_msg
+
+    def get_git_pull(self):
+        """
+        拉取git上的代码到本地
+        :return:
+        """
+        create_dict_service = CreateDictService()
+        filter_list = list()
+        filter_list.append(CreateDict.team_name == self.team_name)
+        filter_list.append(CreateDict.data_type == 4)
+        get_dict_data = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_list)
+        if get_dict_data:
+            base = get_dict_data.dict_value
+        else:
+            base = self.team_name
+        username = self.username
+        password = self.password
+        print(base,"----base----")
+        basic_path = os.path.dirname(os.path.abspath(__file__))
+        base_path = os.path.abspath(os.path.join(basic_path, '../../../../{}'.format("base_framework")))
+        team_path = os.path.abspath(os.path.join(basic_path, '../../../../{}'.format(base)))
+        try:
+            os.system(f"cd " + base_path + "&& git stash drop")
+            os.system(f"cd " + base_path + "&& git pull")
+            os.system(f"cd " + team_path + "&& git stash drop")
+            os.system(f"cd " + team_path + "&& git pull")
+            err_msg = ""
+        except:
+            err_msg = "拉取代码失败"
+        return err_msg
+
+    def get_eureka_ip(self):
+        """
+        重新获取eureka_ip地址，重写下ip
+        :return:
+        """
+        create_dict_service = CreateDictService()
+        filter_list = list()
+        filter_list.append(CreateDict.team_name == self.team_name)
+        filter_list.append(CreateDict.data_type == 4)
+        get_dict_data = create_dict_service.get_dict_simple_data_by_filters(self.session, filter_list)
+        if get_dict_data:
+            team = get_dict_data.dict_value
+        else:
+            team = self.team_name
+        get_eureka = EurekaAPI()
+        get_eureka.team = team
+        upper_team = team.upper()
+        get_eureka.get_all_server_ip_from_eureka()
+        get_eureka.get_all_server_ip_from_eureka(eureka="EC")
+        file_path = os.path.dirname(os.path.abspath(__file__))
+        env_choose_path = os.path.join(file_path, "../../../../../base_config/env_choose.ini")
+        cof = configparser.ConfigParser()
+        cof.read(env_choose_path, encoding='utf-8')
+        cof.set(section="run_evn_name", option="current_team", value=upper_team)
+        with open(env_choose_path, 'w') as fw:  # 循环写入
+            cof.write(fw)
+        test_vi_path = os.path.join(file_path, "test_vi.py")
+        os.system(f"echo 1 >> {test_vi_path}")
+        return True

base_framework/platform_tools/IDF/app/api/controller/test_vi.py

@@ -0,0 +1,28 @@
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 
+1 

base_framework/platform_tools/IDF/app/api/controller/userController.py

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+from ....common.sqlSession import SqlSession
+import requests
+from base_framework.public_tools.sqlhelper import MySqLHelper
+
+sql = MySqLHelper()
+
+
+class UserController(object):
+    def __init__(self, req_json, token):
+        self.session = SqlSession()
+        self.username = req_json.get('username')
+        self.password = req_json.get('password')
+        self.token = token
+        self.del_flag = 0
+        self.req_json = req_json
+
+    def get_user_email(self):
+        """
+        获取用户邮箱信息
+        :return:
+        """
+        username = self.username
+        password = self.password
+        if "@" not in username:
+            username = username + "@sparkedu.com"
+        header = {"Authorization": "Basic c3BhcmtsZS13ZWI6c3BhcmtsZS13ZWI="}
+        session = requests.session()
+        session.headers.update(header)
+        url = "https://sso.qa.huohua.cn/uim/oauth/token/pwd?username=%s&password=%s" % (
+            username, password)
+        resp = session.post(url).json()
+        if resp["code"] == 200:
+            # user_id = resp.get("data").get('userId')
+            # name_dict = sql.select_one(sql='select * from emp.employee where id = "%s"' % user_id, choose_db="huohua")
+            return {"code": 20000, "data": resp.get("data")}
+        else:
+            return {"code": 50012, "message": "用户名密码错误"}

base_framework/platform_tools/IDF/app/api/dao/createDataDetailDao.py

@@ -0,0 +1,139 @@
+# encoding: UTF-8
+from ..model.createDetailInfo import CreateDetail
+from ..model.createDataNumber import CreateDataNumber
+
+from sqlalchemy.exc import NoResultFound
+from sqlalchemy import desc
+from logger import logger
+
+
+class CreateDetailDao(object):
+    @staticmethod
+    def get_all_detail_list_no_filters(session):
+        rets = session.query(CreateDetail) \
+            .filter(CreateDetail.del_flag == 0) \
+            .order_by(CreateDetail.modified_time.desc()) \
+            .all()
+        total = session.query(CreateDetail).filter(CreateDetail.del_flag == 0).count()
+        return rets, total
+
+    @staticmethod
+    def get_detail_list_by_filters(session, filter_list, page=1, limit=20):
+        rets = session.query(CreateDetail) \
+            .filter(*filter_list).filter(CreateDetail.del_flag == 0) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        total = session.query(CreateDetail).filter(*filter_list).filter(CreateDetail.del_flag == 0).count()
+        return rets, total
+
+    @staticmethod
+    def get_detail_list_by_filters_by_team(session, filter_list, list_team_name, page=1, limit=10):
+        # rets = session.query(CreateDetail) \
+        #     .filter(*filter_list).filter(CreateDetail.del_flag == 0) \
+        #     .filter(CreateDetail.team_name.in_(list_team_name)) \
+        #     .offset((int(page) - 1) * int(limit)) \
+        #     .limit(limit) \
+        #     .all()
+        rets = session.query(CreateDetail) \
+            .outerjoin(CreateDataNumber,
+                       CreateDetail.create_data_detail_id == CreateDataNumber.create_data_detail_id) \
+            .filter(*filter_list).filter(CreateDetail.del_flag == 0) \
+            .order_by(desc(CreateDataNumber.month_number)) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        # total = session.query(CreateDetail).filter(*filter_list).filter(CreateDetail.del_flag == 0).filter(
+        #     CreateDetail.team_name.in_(list_team_name)).count()
+        total = session.query(CreateDetail).filter(*filter_list).filter(CreateDetail.del_flag == 0).count()
+        return rets, total
+
+    @staticmethod
+    def get_detail_list_no_filters_by_team(session, list_team_name, page=1, limit=10):
+        # rets = session.query(CreateDetail) \
+        #     .join(CreateDataNumber,
+        #           CreateDetail.create_data_detail_id == CreateDataNumber.create_data_detail_id) \
+        #     .filter(CreateDetail.del_flag == 0) \
+        #     .order_by(desc(CreateDataNumber.month_number)) \
+        #     .offset((int(page) - 1) * int(limit)) \
+        #     .limit(limit) \
+        #     .all()
+        rets = session.query(CreateDetail) \
+            .filter(CreateDetail.del_flag == 0) \
+            .order_by(CreateDetail.modified_time.desc()) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        total = session.query(CreateDetail).filter(CreateDetail.del_flag == 0).count()
+        return rets, total
+
+    @staticmethod
+    def get_detail_list_no_filters(session, page=1, limit=20):
+        rets = session.query(CreateDetail) \
+            .filter(CreateDetail.del_flag == 0) \
+            .order_by(CreateDetail.modified_time.desc()) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        total = session.query(CreateDetail).filter(CreateDetail.del_flag == 0).count()
+        return rets, total
+
+    @staticmethod
+    def get_detail_simple_by_filters(session, filter_list):
+        rets = session.query(CreateDetail) \
+            .filter(*filter_list).filter(CreateDetail.del_flag == 0) \
+            .first()
+        return rets
+
+    @staticmethod
+    def get_create_detail_info_by_id(session, sid):
+        try:
+            ret = session.query(CreateDetail).filter(CreateDetail.create_data_detail_id == sid).one()
+        except Exception as e:
+            logger.warning(f'获取造数基础信息失败: id{sid}, {e}')
+            return None, f'获取造数基础信息失败: id{sid}'
+        return ret
+
+    @staticmethod
+    def save_detail_info_record(session, create_info):
+        if not isinstance(create_info, dict):
+            logger.error('只支持dict类型。build_info type: {}'.format(type(create_info)))
+        create_detail_info = CreateDetail(**create_info)
+        session.add(create_detail_info)
+        # session.flush()
+        err = session.done(close=False)
+        create_info_id = create_detail_info.create_data_detail_id
+        if err:
+            logger.error(f'新增失败！{err}')
+            return 0
+        if not create_info_id:
+            logger.error(f'{create_detail_info}获取关键字id失败！')
+            return 0
+        # session.commit()
+        return create_info_id
+
+    @staticmethod
+    def update_detail_info_record(session, update_info, create_data_detail_id):
+        create_info = session.query(CreateDetail).filter(
+            CreateDetail.create_data_detail_id == create_data_detail_id).update(
+            update_info)
+        err_msg = session.commit()
+        session.done()
+        if err_msg:
+            return '修改场景失败！'
+        return ""
+
+    @staticmethod
+    def delete_detail_info_record(session, create_data_detail_id):
+        build_info = session.query(CreateDetail).filter(
+            CreateDetail.create_data_detail_id == create_data_detail_id).all()
+        if build_info:
+            del_info = session.query(CreateDetail).filter(
+                CreateDetail.create_data_detail_id == create_data_detail_id).update({'del_flag': 1})
+            session.commit()
+            if not del_info:
+                logger.error(f'删除记录失败！res: {del_info}')
+            return del_info
+        else:
+            logger.error(f'id：{create_data_detail_id} 不存在记录！')
+            return f'id：{create_data_detail_id} 不存在记录！'

base_framework/platform_tools/IDF/app/api/dao/createDataDictDao.py

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+from ..model.createDictInfo import CreateDict
+
+from sqlalchemy.exc import NoResultFound
+from logger import logger
+
+
+class CreateDictDao(object):
+    @staticmethod
+    def get_dict_list_by_filters(session, filter_list, page=1, limit=20):
+        rets = session.query(CreateDict) \
+            .filter(*filter_list).filter(CreateDict.del_flag == 0) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        total = session.query(CreateDict).filter(*filter_list).filter(CreateDict.del_flag == 0).count()
+        return rets, total
+
+    @staticmethod
+    def get_dict_list_by_team_filters(session, filter_list, list_team_name, page=1, limit=20):
+        # rets = session.query(CreateDict) \
+        #     .filter(*filter_list).filter(CreateDict.del_flag == 0) \
+        #     .filter(CreateDict.team_name.in_(list_team_name)) \
+        #     .offset((int(page) - 1) * int(limit)) \
+        #     .limit(limit) \
+        #     .all()
+        # total = session.query(CreateDict).filter(*filter_list).filter(CreateDict.del_flag == 0).filter(
+        #     CreateDict.team_name.in_(list_team_name)).count()
+        rets = session.query(CreateDict) \
+            .filter(*filter_list).filter(CreateDict.del_flag == 0) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        total = session.query(CreateDict).filter(*filter_list).filter(CreateDict.del_flag == 0).count()
+        return rets, total
+
+    @staticmethod
+    def get_dict_list_no_filters(session, page=1, limit=20):
+        rets = session.query(CreateDict) \
+            .filter(CreateDict.del_flag == 0) \
+            .order_by(CreateDict.modified_time.desc()) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        total = session.query(CreateDict).filter(CreateDict.del_flag == 0).count()
+        return rets, total
+
+    @staticmethod
+    def get_dict_simple_by_filters(session, filter_list):
+        rets = session.query(CreateDict) \
+            .filter(*filter_list).filter(CreateDict.del_flag == 0) \
+            .first()
+        return rets
+
+    @staticmethod
+    def save_dict_info_record(session, create_info):
+        if not isinstance(create_info, dict):
+            logger.error('只支持dict类型。build_info type: {}'.format(type(create_info)))
+        create_dict_info = CreateDict(**create_info)
+        session.add(create_dict_info)
+        # session.flush()
+        err = session.done(close=False)
+        create_info_id = create_dict_info.create_dict_data_id
+        if err:
+            logger.error(f'新增失败！{err}')
+            return 0
+        if not create_info_id:
+            logger.error(f'{create_dict_info}获取关键字id失败！')
+            return 0
+        # session.commit()
+        return create_info_id
+
+    @staticmethod
+    def update_dict_info_record(session, update_info, create_dict_data_id):
+        create_info = session.query(CreateDict).filter(
+            CreateDict.create_dict_data_id == create_dict_data_id).one()
+        create_info.team_name = update_info["team_name"]
+        create_info.dict_key = update_info["dict_key"]
+        create_info.dict_value = update_info["dict_value"]
+        err_msg = session.done()
+        if err_msg:
+            return '修改失败！'
+        return ''

base_framework/platform_tools/IDF/app/api/dao/createDataInfoDao.py

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+from ..model.createDataInfo import CreateInfo
+
+from sqlalchemy.exc import NoResultFound
+from logger import logger
+
+
+class CreateInfoDao(object):
+    @staticmethod
+    def get_data_info(session, filter_list):
+        try:
+            ls = session.query(CreateInfo).filter(*filter_list).filter(CreateInfo.del_flag == 0).first()
+            total = session.query(CreateInfo).filter(*filter_list).filter(CreateInfo.del_flag == 0).count()
+        except Exception as e:
+            logger.warning(e)
+            return [], '获取基础信息失败！'
+        return ls, total
+
+    @staticmethod
+    def get_data_simple_by_filters(session, filter_list):
+        rets = session.query(CreateInfo) \
+            .filter(*filter_list).filter(CreateInfo.del_flag == 0) \
+            .first()
+        return rets
+
+    @staticmethod
+    def get_create_data_info_by_id(session, sid):
+        try:
+            ret = session.query(CreateInfo).filter(CreateInfo.create_data_info_id == sid).one()
+        except Exception as e:
+            logger.warning(f'获取造数信息失败: id{sid}, {e}')
+            return None, f'获取造数信息失败: id{sid}'
+        return ret
+
+    @staticmethod
+    def get_create_data_info_by_detail_id(session, detail_id):
+        try:
+            ret = session.query(CreateInfo).filter(CreateInfo.create_data_detail_id == detail_id).one()
+        except Exception as e:
+            logger.warning(f'获取造数信息失败: id{detail_id}, {e}')
+            return None, f'获取造数信息失败: id{detail_id}'
+        return ret
+
+    @staticmethod
+    def save_data_info_record(session, create_info):
+        if not isinstance(create_info, dict):
+            logger.error('只支持dict类型。build_info type: {}'.format(type(create_info)))
+        create_data_info = CreateInfo(**create_info)
+        session.add(create_data_info)
+        # session.flush()
+        err = session.done(close=False)
+        create_info_id = create_data_info.create_data_info_id
+        if err:
+            logger.error(f'新增失败！{err}')
+            return 0
+        if not create_info_id:
+            logger.error(f'{create_data_info}获取关键字id失败！')
+            return 0
+        # session.commit()
+        return create_info_id
+
+    @staticmethod
+    def update_data_info_record(session, update_info, create_data_info_id):
+        create_info = session.query(CreateInfo).filter(CreateInfo.create_data_info_id == create_data_info_id).one()
+        create_info.class_name = update_info['class_name']
+        create_info.method_name = update_info['method_name']
+        create_info.request_parameter = update_info['request_parameter']
+        err_msg = session.done()
+        if err_msg:
+            return '修改失败！'
+        return ''

base_framework/platform_tools/IDF/app/api/dao/createDataNumberDao.py

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+from ..model.createDataNumber import CreateDataNumber
+
+from logger import logger
+
+
+class CreateNumberDao(object):
+    @staticmethod
+    def get_number_no_filters(session):
+        rets = session.query(CreateDataNumber) \
+            .filter(CreateDataNumber.del_flag == 0) \
+            .all()
+        return rets
+
+    @staticmethod
+    def get_number_simple_by_filters(session, filter_list):
+        rets = session.query(CreateDataNumber) \
+            .filter(*filter_list).filter(CreateDataNumber.del_flag == 0) \
+            .first()
+        return rets
+
+    @staticmethod
+    def get_number_info_by_id(session, create_data_detail_id):
+        try:
+            ret = session.query(CreateDataNumber).filter(
+                CreateDataNumber.create_data_detail_id == create_data_detail_id).first()
+        except Exception as e:
+            logger.warning(f'获取造数使用次数失败: id{create_data_detail_id}, {e}')
+            return f'获取造数使用次数失败: id{create_data_detail_id}', False
+        return ret, True
+
+    @staticmethod
+    def save_number_info(session, create_info):
+        if not isinstance(create_info, dict):
+            logger.error('只支持dict类型。build_info type: {}'.format(type(create_info)))
+        create_detail_info = CreateDataNumber(**create_info)
+        session.add(create_detail_info)
+        # session.flush()
+        err = session.done(close=False)
+        create_info_id = create_detail_info.id
+        if err:
+            logger.error(f'新增失败！{err}')
+            return 0
+        if not create_info_id:
+            logger.error(f'{create_detail_info}获取关键字id失败！')
+            return 0
+        # session.commit()
+        return create_info_id
+
+    @staticmethod
+    def update_number_info(session, update_info, create_data_detail_id):
+        update_res = session.query(CreateDataNumber).filter(
+            CreateDataNumber.create_data_detail_id == create_data_detail_id).update(
+            update_info)
+        print(update_res, "update_res")
+        err_msg = session.commit()
+        # session.done()
+        if err_msg:
+            return '基础信息修改失败！'
+        return update_res

base_framework/platform_tools/IDF/app/api/dao/createDataResultDao.py

@@ -0,0 +1,125 @@
+# encoding: UTF-8
+from sqlalchemy import func
+
+from ..model.createResultInfo import CreateResult
+
+from sqlalchemy.exc import NoResultFound
+from logger import logger
+
+
+class CreateResultDao(object):
+    @staticmethod
+    def get_result_list_by_filters(session, filter_list, page=1, limit=20):
+        rets = session.query(CreateResult) \
+            .filter(*filter_list).filter(CreateResult.del_flag == 0, CreateResult.status == 1) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        total = session.query(CreateResult).filter(*filter_list).filter(CreateResult.del_flag == 0,
+                                                                        CreateResult.status == 1).count()
+        return rets, total
+
+    @staticmethod
+    def get_result_list_by_team_filters(session, filter_list, list_team_name, page=1, limit=20):
+        # rets = session.query(CreateResult) \
+        #     .filter(*filter_list).filter(CreateResult.del_flag == 0, CreateResult.status == 1) \
+        #     .filter(CreateResult.team_name.in_(list_team_name)) \
+        #     .offset((int(page) - 1) * int(limit)) \
+        #     .limit(limit) \
+        #     .all()
+        # total = session.query(CreateResult).filter(*filter_list).filter(CreateResult.del_flag == 0,
+        #                                                                 CreateResult.status == 1).filter(
+        #     CreateResult.team_name.in_(list_team_name)).count()
+        rets = session.query(CreateResult) \
+            .filter(*filter_list).filter(CreateResult.del_flag == 0, CreateResult.status == 1) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        total = session.query(CreateResult).filter(*filter_list).filter(CreateResult.del_flag == 0,
+                                                                        CreateResult.status == 1).count()
+        return rets, total
+
+    @staticmethod
+    def get_result_list_no_filters(session, page=1, limit=20):
+        rets = session.query(CreateResult) \
+            .filter(CreateResult.del_flag == 0, CreateResult.status == 1) \
+            .order_by(CreateResult.modified_time.desc()) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        total = session.query(CreateResult).filter(CreateResult.del_flag == 0, CreateResult.status == 1).count()
+        return rets, total
+
+    @staticmethod
+    def get_result_list_no_team_filters(session, list_team_name, page=1, limit=20):
+        # rets = session.query(CreateResult) \
+        #     .filter(CreateResult.del_flag == 0, CreateResult.status == 1) \
+        #     .filter(CreateResult.team_name.in_(list_team_name)) \
+        #     .order_by(CreateResult.modified_time.desc()) \
+        #     .offset((int(page) - 1) * int(limit)) \
+        #     .limit(limit) \
+        #     .all()
+        # total = session.query(CreateResult).filter(CreateResult.del_flag == 0, CreateResult.status == 1).filter(
+        #     CreateResult.team_name.in_(list_team_name)).count()
+        rets = session.query(CreateResult) \
+            .filter(CreateResult.del_flag == 0, CreateResult.status == 1) \
+            .order_by(CreateResult.modified_time.desc()) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        total = session.query(CreateResult).filter(CreateResult.del_flag == 0, CreateResult.status == 1).count()
+        return rets, total
+
+    @staticmethod
+    def get_result_simple_by_filters(session, filter_list):
+        rets = session.query(CreateResult) \
+            .filter(*filter_list).filter(CreateResult.del_flag == 0) \
+            .first()
+        return rets
+
+    @staticmethod
+    def get_result_detail_info_by_id(session, sid):
+        try:
+            ret = session.query(CreateResult).filter(CreateResult.create_data_result_id == sid).one()
+        except Exception as e:
+            logger.warning(f'获取造数基础信息失败: id{sid}, {e}')
+            return None, f'获取造数基础信息失败: id{sid}'
+        return ret
+
+    @staticmethod
+    def save_result_info_record(session, create_info):
+        if not isinstance(create_info, dict):
+            logger.error('只支持dict类型。build_info type: {}'.format(type(create_info)))
+        create_result_info = CreateResult(**create_info)
+        session.add(create_result_info)
+        # session.flush()
+        err = session.done(close=False)
+        create_info_id = create_result_info.create_data_result_id
+        if err:
+            logger.error(f'新增失败！{err}')
+            return 0
+        if not create_info_id:
+            logger.error(f'{create_result_info}获取造数结果id失败！')
+            return 0
+        # session.commit()
+        return create_info_id
+
+    @staticmethod
+    def update_result_record(session, update_info, sid):
+        create_info = session.query(CreateResult).filter(
+            CreateResult.create_data_result_id == sid).one()
+        create_info.status = update_info["status"]
+        create_info.result_info = update_info["result_info"]
+        err_msg = session.done()
+        if err_msg:
+            return '修改结果失败！'
+        return ''
+
+    @staticmethod
+    def get_result_numbers_by_month(session, create_data_detail_id, one_month_ago_str):
+        ret = session.query(func.count(CreateResult.create_data_detail_id).label('count')).filter(
+            CreateResult.created_time >= one_month_ago_str,
+            CreateResult.create_data_detail_id == create_data_detail_id, CreateResult.status == 1).group_by(
+            CreateResult.method_function_detail
+        ).first()
+        return ret

base_framework/platform_tools/IDF/app/api/dao/createGroupUserDao.py

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+from ..model.createGroupUser import CreateGroupUser
+from logger import logger
+
+
+class CreateGroupDao(object):
+    @staticmethod
+    def get_group_list_by_filters(session, filter_list, page=1, limit=20):
+        rets = session.query(CreateGroupUser) \
+            .filter(*filter_list).filter(CreateGroupUser.del_flag == 0) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        total = session.query(CreateGroupUser).filter(*filter_list).filter(CreateGroupUser.del_flag == 0).count()
+        return rets, total
+
+    @staticmethod
+    def get_group_list_no_filters(session, page=1, limit=20):
+        rets = session.query(CreateGroupUser) \
+            .filter(CreateGroupUser.del_flag == 0) \
+            .offset((int(page) - 1) * int(limit)) \
+            .limit(limit) \
+            .all()
+        total = session.query(CreateGroupUser).filter(CreateGroupUser.del_flag == 0).count()
+        return rets, total
+
+    @staticmethod
+    def get_group_all_data(session):
+        rets = session.query(CreateGroupUser).filter(CreateGroupUser.del_flag == 0).all()
+        return rets
+
+    @staticmethod
+    def get_group_detail_info_by_email(session, email):
+        try:
+            if email is not None:
+                ret = session.query(CreateGroupUser).filter(CreateGroupUser.email == email).one()
+            else:
+                return None
+        except Exception as e:
+            logger.warning(f'获取组名失败: id{email}, {e}')
+            return None
+        return ret

base_framework/platform_tools/IDF/app/api/model/createDataInfo.py

@@ -0,0 +1,23 @@
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, TIMESTAMP, text, JSON
+
+from ....common.sqlSession import to_dict
+
+Base = declarative_base()
+Base.to_dict = to_dict
+
+
+class CreateInfo(Base):
+    __tablename__ = 'create_data_info'
+    create_data_info_id = Column(String(120), primary_key=True, comment='传入参数的id')
+    create_data_detail_id = Column(String(120), unique=True, comment='基础信息的id')
+    class_name = Column(String(120), unique=True, comment='类名称')
+    method_name = Column(String(120), unique=True, comment='方法名称')
+    request_parameter = Column(JSON, unique=True, comment='请求参数')
+    del_flag = Column(Integer, unique=True, comment='0：未删除；1：已删除')
+    created_time = Column(TIMESTAMP, server_default=text('CURRENT_TIMESTAMP'), comment='创建时间')
+    modified_time = Column(TIMESTAMP, server_default=text('CURRENT_TIMESTAMP'),
+                           server_onupdate=text('CURRENT_TIMESTAMP'), comment='更新时间')
+
+    def __repr__(self):
+        return '<create_data_info %r>' % self.create_data_info_id

base_framework/platform_tools/IDF/app/api/model/createDataNumber.py

@@ -0,0 +1,23 @@
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, TIMESTAMP, text
+from ....common.sqlSession import to_dict
+
+Base = declarative_base()
+Base.to_dict = to_dict
+
+
+class CreateDataNumber(Base):
+    __tablename__ = 'create_data_number'
+    id = Column(String(100), primary_key=True, comment='次数的id')
+    create_data_detail_id = Column(String(100), primary_key=True, comment='数据字典的id')
+    method_name = Column(String(120), unique=True, comment='方法名称')
+    total_number = Column(Integer, unique=True, comment='方法总使用次数')
+    error_number = Column(Integer, unique=True, comment='方法使用的错误次数')
+    right_number = Column(Integer, unique=True, comment='方法使用的正确次数')
+    month_number = Column(Integer, unique=True, comment='方法使用的最近一个月次数')
+    del_flag = Column(Integer, unique=True, comment='0：未删除；1：已删除')
+    created_time = Column(String(100), unique=True, comment='创建时间')
+    modified_time = Column(String(100), unique=True, comment='更新时间')
+
+    def __repr__(self):
+        return '<id %r>' % self.id

base_framework/platform_tools/IDF/app/api/model/createDetailInfo.py

@@ -0,0 +1,28 @@
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, TIMESTAMP, text
+
+from ....common.sqlSession import to_dict
+
+Base = declarative_base()
+Base.to_dict = to_dict
+
+
+class CreateDetail(Base):
+    __tablename__ = 'create_data_detail'
+    create_data_detail_id = Column(String(120), primary_key=True, comment='基础信息的id')
+    team_name = Column(String(100), unique=True, comment='组名（项目名）')
+    file_name = Column(String(100), unique=True, comment='文件夹名称')
+    module_name = Column(String(100), unique=True, comment='模块名称')
+    class_name = Column(String(120), unique=True, comment='类名称')
+    method_name = Column(String(120), unique=True, comment='方法名称')
+    method_function_detail = Column(String(5000), unique=True, comment='方法简单说明')
+    method_detail = Column(String(5000), unique=True, comment='方法描述')
+    creator = Column(String(100), unique=True, comment='责任人')
+    status = Column(Integer, unique=True, comment='状态:0：未审核；1：创建失败')
+    del_flag = Column(Integer, unique=True, comment='0：未删除；1：已删除')
+    created_time = Column(TIMESTAMP, server_default=text('CURRENT_TIMESTAMP'), comment='创建时间')
+    modified_time = Column(TIMESTAMP, server_default=text('CURRENT_TIMESTAMP'),
+                           server_onupdate=text('CURRENT_TIMESTAMP'), comment='更新时间')
+
+    def __repr__(self):
+        return '<create_data_detail_id %r>' % self.create_data_detail_id

base_framework/platform_tools/IDF/app/api/model/createDictInfo.py

@@ -0,0 +1,23 @@
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, TIMESTAMP, text
+
+from ....common.sqlSession import to_dict
+
+Base = declarative_base()
+Base.to_dict = to_dict
+
+
+class CreateDict(Base):
+    __tablename__ = 'create_dict_data'
+    create_dict_data_id = Column(String(120), primary_key=True, comment='数据字典的id')
+    data_type = Column(Integer, unique=True, comment='1：路径  2：对应名称')
+    team_name = Column(String(100), unique=True, comment='业务线名称')
+    dict_key = Column(String(100), unique=True, comment='字典的key')
+    dict_value = Column(String(255), unique=True, comment='字典的value')
+    del_flag = Column(Integer, unique=True, comment='0：未删除；1：已删除')
+    created_time = Column(TIMESTAMP, server_default=text('CURRENT_TIMESTAMP'), comment='创建时间')
+    modified_time = Column(TIMESTAMP, server_default=text('CURRENT_TIMESTAMP'),
+                           server_onupdate=text('CURRENT_TIMESTAMP'), comment='更新时间')
+
+    def __repr__(self):
+        return '<create_dict_data_id %r>' % self.create_dict_data_id

base_framework/platform_tools/IDF/app/api/model/createGroupUser.py

@@ -0,0 +1,19 @@
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, TIMESTAMP, text
+
+from ....common.sqlSession import to_dict
+
+Base = declarative_base()
+Base.to_dict = to_dict
+
+
+class CreateGroupUser(Base):
+    __tablename__ = 'create_group_user'
+    id = Column(Integer, primary_key=True, comment='用户的id')
+    email = Column(String(100), unique=True, comment='邮箱')
+    team_name = Column(String(100), unique=True, comment='组名')
+    name = Column(String(100), unique=True, comment='用户名称')
+    del_flag = Column(Integer, unique=True, comment='0：未删除；1：已删除')
+
+    def __repr__(self):
+        return '<id %r>' % self.id

base_framework/platform_tools/IDF/app/api/model/createResultInfo.py

@@ -0,0 +1,31 @@
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, String, TIMESTAMP, text, JSON
+from ....common.sqlSession import to_dict
+
+Base = declarative_base()
+Base.to_dict = to_dict
+
+
+class CreateResult(Base):
+    __tablename__ = 'create_data_result'
+    create_data_result_id = Column(String(120), primary_key=True, comment='执行结果的id')
+    create_data_info_id = Column(String(120), unique=True, comment='传入参数的id')
+    create_data_detail_id = Column(String(120), unique=True, comment='基础信息的id')
+    request_parameter = Column(JSON, unique=True, comment='请求参数')
+    result_info = Column(JSON, unique=True, comment='造数结果')
+    team_name = Column(String(100), unique=True, comment='组名（项目名）')
+    module_name = Column(String(100), unique=True, comment='模块名称')
+    class_name = Column(String(120), unique=True, comment='类名称')
+    file_name = Column(String(255), unique=True, comment='文件名称')
+    method_name = Column(String(120), unique=True, comment='方法名称')
+    tag = Column(String(1000), unique=True, comment='标签')
+    status = Column(Integer, unique=True, comment='状态')
+    method_function_detail = Column(String(5000), unique=True, comment='方法描述')
+    del_flag = Column(Integer, unique=True, comment='0：未删除；1：已删除')
+    creator = Column(String(100), unique=True, comment='创建人')
+    created_time = Column(TIMESTAMP, server_default=text('CURRENT_TIMESTAMP'), comment='创建时间')
+    modified_time = Column(TIMESTAMP, server_default=text('CURRENT_TIMESTAMP'),
+                           server_onupdate=text('CURRENT_TIMESTAMP'), comment='更新时间')
+
+    def __repr__(self):
+        return '<create_data_result_id %r>' % self.create_data_result_id

base_framework/platform_tools/IDF/app/api/service/createDataDetailService.py

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+from ..dao.createDataDetailDao import CreateDetailDao
+
+
+class CreateDetailService(object):
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def get_all_detail_list_no_filters_page(session):
+        scene_list, total = CreateDetailDao.get_all_detail_list_no_filters(session)
+        return scene_list, total
+
+    @staticmethod
+    def get_detail_list_no_filters_page(session, page, limit):
+        scene_list, total = CreateDetailDao.get_detail_list_no_filters(session, page=page, limit=limit)
+        return scene_list, total
+
+    @staticmethod
+    def get_detail_list_by_filters_page(session, filter_list, page, limit):
+        ret, err_msg = CreateDetailDao.get_detail_list_by_filters(session, filter_list, page=page, limit=limit)
+        return ret, err_msg
+
+    @staticmethod
+    def get_detail_list_by_filters_team_page(session, filter_list, list_team_name, page, limit):
+        ret, err_msg = CreateDetailDao.get_detail_list_by_filters_by_team(session, filter_list,
+                                                                          list_team_name=list_team_name,
+                                                                          page=page, limit=limit)
+        return ret, err_msg
+
+    @staticmethod
+    def get_detail_list_no_filters_team_page(session, list_team_name, page, limit):
+        scene_list, total = CreateDetailDao.get_detail_list_no_filters_by_team(session, list_team_name=list_team_name,
+                                                                               page=page, limit=limit)
+        return scene_list, total
+
+    @staticmethod
+    def get_detail_simple_data_by_filters(session, filter_list):
+        ret = CreateDetailDao.get_detail_simple_by_filters(session, filter_list)
+        return ret
+
+    @staticmethod
+    def get_create_detail_info_by_id(session, create_data_detail_id):
+        err_msg = CreateDetailDao.get_create_detail_info_by_id(session, create_data_detail_id)
+        return err_msg
+
+    @staticmethod
+    def create_service_detail_data(session, create_info):
+        ret = CreateDetailDao.save_detail_info_record(session, create_info)
+        return ret
+
+    @staticmethod
+    def update_service_detail_data(session, update_info, create_data_detail_id):
+        err_msg = CreateDetailDao.update_detail_info_record(session, update_info, create_data_detail_id)
+        return err_msg
+
+    @staticmethod
+    def delete_service_detail_data(session, create_data_detail_id):
+        bf_dao = CreateDetailDao()
+        del_info = bf_dao.delete_detail_info_record(session, create_data_detail_id)
+        return del_info

base_framework/platform_tools/IDF/app/api/service/createDataDictService.py

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+from ..dao.createDataDictDao import CreateDictDao
+
+
+class CreateDictService(object):
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def get_dict_list_no_filters_page(session, page, limit):
+        scene_list, total = CreateDictDao.get_dict_list_no_filters(session, page=page, limit=limit)
+        return scene_list, total
+
+    @staticmethod
+    def get_dict_list_by_filters_page(session, filter_list, page, limit):
+        ret, total = CreateDictDao.get_dict_list_by_filters(session, filter_list, page=page, limit=limit)
+        return ret, total
+
+    @staticmethod
+    def get_dict_list_by_team_filters_page(session, filter_list, list_team_name, page, limit):
+        ret, total = CreateDictDao.get_dict_list_by_team_filters(session, filter_list, list_team_name, page=page,
+                                                                 limit=limit)
+        return ret, total
+
+    @staticmethod
+    def get_dict_simple_data_by_filters(session, filter_list):
+        ret = CreateDictDao.get_dict_simple_by_filters(session, filter_list)
+        return ret
+
+    @staticmethod
+    def create_service_dict_data(session, create_info):
+        ret = CreateDictDao.save_dict_info_record(session, create_info)
+        return ret
+
+    @staticmethod
+    def update_service_dict_data(session, update_info, create_dict_data_id):
+        err_msg = CreateDictDao.update_dict_info_record(session, update_info, create_dict_data_id)
+        return err_msg

base_framework/platform_tools/IDF/app/api/service/createDataGroupService.py

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+from ..dao.createGroupUserDao import CreateGroupDao
+
+
+class CreateGroupService(object):
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def get_service_group_list_no_filters_page(session, page, limit):
+        scene_list, total = CreateGroupDao.get_group_list_no_filters(session, page=page, limit=limit)
+        return scene_list, total
+
+    @staticmethod
+    def get_service_group_list_all_data(session):
+        scene_list = CreateGroupDao.get_group_all_data(session)
+        return scene_list
+
+    @staticmethod
+    def get_service_group_info_data_by_email(session, email):
+        scene_list = CreateGroupDao.get_group_detail_info_by_email(session, email)
+        return scene_list

base_framework/platform_tools/IDF/app/api/service/createDataInfoService.py

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+from ..dao.createDataInfoDao import CreateInfoDao
+
+
+class CreateInfoService(object):
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def get_service_info_data(session,filter_list):
+        ret, err_msg = CreateInfoDao.get_data_info(session,filter_list)
+        return ret, err_msg
+
+    @staticmethod
+    def get_data_simple_data_by_filters(session, filter_list):
+        ret = CreateInfoDao.get_data_simple_by_filters(session, filter_list)
+        return ret
+
+    @staticmethod
+    def get_create_data_info_by_id(session, sid):
+        scene_obj = CreateInfoDao.get_create_data_info_by_id(session, sid)
+        return scene_obj
+
+    @staticmethod
+    def get_create_data_info_by_detail_id(session, detail_id):
+        scene_obj = CreateInfoDao.get_create_data_info_by_detail_id(session, detail_id)
+        return scene_obj
+
+    @staticmethod
+    def create_service_info_data(session, create_info):
+        ret = CreateInfoDao.save_data_info_record(session, create_info)
+        return ret
+
+    @staticmethod
+    def update_service_info_data(session, update_info,create_data_info_id):
+        err_msg = CreateInfoDao.update_data_info_record(session,update_info,create_data_info_id)
+        return err_msg

base_framework/platform_tools/IDF/app/api/service/createDataNumberService.py

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+from ..dao.createDataNumberDao import CreateNumberDao
+
+
+class CreateNumberService(object):
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def get_service_number_all_no_filters(session):
+        ret = CreateNumberDao.get_number_no_filters(session)
+        return ret
+
+    @staticmethod
+    def get_service_number_simple_by_filters(session, filter_list):
+        ret = CreateNumberDao.get_number_simple_by_filters(session, filter_list)
+        return ret
+
+    @staticmethod
+    def get_service_number_by_id(session, create_data_detail_id):
+        err_msg, success = CreateNumberDao.get_number_info_by_id(session, create_data_detail_id)
+        return err_msg, success
+
+    @staticmethod
+    def create_service_number_data(session, create_info):
+        ret = CreateNumberDao.save_number_info(session, create_info)
+        return ret
+
+    @staticmethod
+    def update_service_number_data(session, update_info, create_data_detail_id):
+        err_msg = CreateNumberDao.update_number_info(session, update_info, create_data_detail_id)
+        return err_msg

base_framework/platform_tools/IDF/app/api/service/createDataResultService.py

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+from ..dao.createDataResultDao import CreateResultDao
+
+
+class CreateResultService(object):
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def get_result_list_no_filters_page(session, page, limit):
+        scene_list, total = CreateResultDao.get_result_list_no_filters(session, page=page, limit=limit)
+        return scene_list, total
+
+    @staticmethod
+    def get_result_list_no_team_filters_page(session, list_team_name, page, limit):
+        scene_list, total = CreateResultDao.get_result_list_no_team_filters(session, list_team_name, page=page,
+                                                                            limit=limit)
+        return scene_list, total
+
+    @staticmethod
+    def get_result_list_by_filters_page(session, filter_list, page, limit):
+        ret, err_msg = CreateResultDao.get_result_list_by_filters(session, filter_list, page=page, limit=limit)
+        return ret, err_msg
+
+    @staticmethod
+    def get_result_list_by_team_filters_page(session, filter_list, list_team_name, page, limit):
+        ret, err_msg = CreateResultDao.get_result_list_by_team_filters(session, filter_list,
+                                                                       list_team_name=list_team_name,
+                                                                       page=page, limit=limit)
+        return ret, err_msg
+
+    @staticmethod
+    def get_result_simple_data_by_filters(session, filter_list):
+        ret = CreateResultDao.get_result_simple_by_filters(session, filter_list)
+        return ret
+
+    @staticmethod
+    def get_create_result_by_id(session, create_data_result_id):
+        err_msg = CreateResultDao.get_result_detail_info_by_id(session, create_data_result_id)
+        return err_msg
+
+    @staticmethod
+    def create_result_data(session, create_info):
+        ret = CreateResultDao.save_result_info_record(session, create_info)
+        return ret
+
+    @staticmethod
+    def update_service_result_data(session, update_info, sid):
+        err_msg = CreateResultDao.update_result_record(session, update_info, sid)
+        return err_msg
+
+    @staticmethod
+    def get_service_result_numbers_by_month(session, create_data_detail_id, one_month_ago_str):
+        err_msg = CreateResultDao.get_result_numbers_by_month(session, create_data_detail_id, one_month_ago_str)
+        return err_msg

base_framework/platform_tools/IDF/app/api/views.py

@@ -0,0 +1,593 @@
+# encoding: UTF-8
+from flask import Blueprint, request
+
+from ...common.apiResponse import ApiResponse
+
+from .controller.createDataInfoController import CreateDataInfoController
+from .controller.createDataDetailController import CreateDataDetailController
+from .controller.createDataDictController import CreateDataDictController
+from .controller.createDataResultController import CreateDataResultController
+from .controller.commonController import CommonController
+from .controller.scrapyController import ScrapyController
+from .controller.userController import UserController
+
+api = Blueprint('api', __name__)
+
+
+@api.route('/add/info/data', methods=['POST'])
+def add_info_data():
+    """新增造数请求参数数据
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | create_data_info_id |  true  | query |  int  | 基本信息的id |
+        | create_data_detail_id |  true  | query |  int  | 详细信息的id |
+        | className |  true  | query |  string  | 类名 |
+        | methodName |  true  | query |  string  | 方法名 |
+        | request_parameter |  true  | query |  string  | 请求参数 |
+
+        ### 请求
+        ```json
+        {"create_data_info_id":"","create_data_detail_id":102222,"className":"","methodName":"","request_parameter":{}}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "data":true,"success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    access_token = request.headers['accesstoken']
+    controller = CreateDataInfoController(req_json, access_token)
+    ret = controller.create_info_data()
+    if ret:
+        return ApiResponse.build_failure(5000, data=ret)
+    return ApiResponse.build_success(20000, data=True)
+
+
+@api.route('/edit/info/data', methods=['POST'])
+def edit_info_data():
+    """编辑造数请求参数数据
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | create_data_info_id |  true  | query |  int  | 基本信息的id |
+        | create_data_detail_id |  true  | query |  int  | 详细信息的id |
+        | className |  true  | query |  string  | 类名 |
+        | methodName |  true  | query |  string  | 方法名 |
+        | request_parameter |  true  | query |  string  | 请求参数 |
+
+        ### 请求
+        ```json
+        {"create_data_info_id":"","create_data_detail_id":102222,"className":"","methodName":"","request_parameter":{}}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x ", "data":true,"success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    access_token = request.headers['accesstoken']
+    controller = CreateDataInfoController(req_json, access_token)
+    ret = controller.update_info_data()
+    if ret:
+        return ApiResponse.build_failure(5000, data=ret)
+    return ApiResponse.build_success(20000, data=True)
+
+
+@api.route('/delete/detail/data', methods=['POST'])
+def delete_detail_data():
+    """删除造数详情数据
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | create_data_detail_id |  true  | query |  int  | 详细信息的id |
+
+        ### 请求
+        ```json
+        {"create_data_detail_id":102222}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "删除成功", "data":true,"success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    access_token = request.headers['accesstoken']
+    controller = CreateDataDetailController(req_json, access_token)
+    ret = controller.delete_detail_data()
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/create/data/detail/list', methods=['POST'])
+def get_keywors_detail_list():
+    """查询造数关键字基本信息列表页数据
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | pageNo |  true  | query |  int  | 基本信息的id |
+        | pageSize |  true  | query |  int  | 详细信息的id |
+        | detail_name |  true  | query |  string  | 基本描述信息 |
+        | team_name |  true  | query |  string  | 业务线 |
+        | file_name |  true  | query |  string  | 业务对应业务线名称 |
+        | module_name |  true  | query |  string  | 模块名称 |
+
+        ### 请求
+        ```json
+        {"pageNo":1,"pageSize":10,"dict_value":"","team_name":""}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "data":list[{},{}],"success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = CreateDataDetailController(req_json, accesstoken)
+    ret = controller.get_detail_query_advance()
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/create/data/detail/advance', methods=['POST'])
+def get_keywors_detail_advance():
+    """查询造数关键字基本信息详情页数据
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | create_data_detail_id |  true  | query |  int  | 基本信息的id |
+
+        ### 请求
+        ```json
+        {"create_data_detail_id":123}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "data":{},"success":True}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = CreateDataDetailController(req_json, accesstoken)
+    ret = controller.get_detail_advance()
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/keyword/run', methods=['POST'])
+def run_keywords():
+    """执行造数
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | create_data_info_id |  true  | query |  string  | 基本信息的id |
+        | create_data_detail_id |  true  | query |  string  | 详细信息的id |
+        | dict_key |  true  | query |  string  | 组名 |
+        | get_tag |  true  | query |  string  | 标签，备注说明 |
+        | request_parameter |  true  | query |  string  | 请求参数 |
+
+        ### 请求
+        ```json
+        {"create_data_info_id":"12","create_data_detail_id":"13","dict_key":"StudentEvent","get_tag":"get_student_classroom","request_parameter":""}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    access_token = request.headers['accesstoken']
+    controller = CreateDataDetailController(req_json, access_token)
+    data = controller.run_keyword_data()
+    if data.get("message") == "造数成功":
+        return ApiResponse.build_success(20000, message="造数成功", data=data.get("data"))
+    return ApiResponse.build_failure(40012, msg=data.get("message"))
+
+
+@api.route('/create/data/result/list', methods=['POST'])
+def get_keywors_result_list():
+    """查询造数关键字造数结果列表页数据
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | pageNo |  true  | query |  int  | 页码 |
+        | pageSize |  true  | query |  int  | 页码规格 |
+        | detail_name |  true  | query |  string  | 详细描述信息 |
+        | team_name |  true  | query |  string  | 业务线 |
+        | get_tag |  true  | query |  string  | 标签，备注 |
+
+        ### 请求
+        ```json
+        {"pageNo":1,"pageSize":10,"detail_name":"","team_name":"","get_tag":""}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "data":list[{},{}],"success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = CreateDataResultController(req_json, accesstoken)
+    ret = controller.get_result_query_list()
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/create/data/result/advance', methods=['POST'])
+def get_keywors_result_advance():
+    """查询造数结果的详情信息
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | create_data_result_id |  true  | query |  int  | 基本信息的id |
+
+        ### 请求
+        ```json
+        {"create_data_result_id":123}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "data":{},"success":True}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = CreateDataResultController(req_json, accesstoken)
+    ret = controller.get_result_advance()
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/add/dict/data', methods=['POST'])
+def edit_dict_data():
+    """编辑造数关键字进行的映射
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | create_dict_data_id |  true  | query |  int  | 基本信息的id |
+        | data_type |  true  | query |  int  | 详细信息的id |
+        | dict_key |  true  | query |  string  | 映射的key |
+        | dict_value |  true  | query |  string  | 字段映射对应的名称 |
+        | team_name |  true  | query |  string  | 组名 |
+        | created_time |  true  | query |  string  | 创建时间 |
+        | modified_time |  true  | query |  string  | 修改时间 |
+
+        ### 请求
+        ```json
+        {"create_dict_data_id":"e757b5cd-cec5-11ed-ae4a-c8b29bebcb51","team_name":"用户","data_type":3,"dict_key":"common","dict_value":"公共","created_time":"202303301440","modified_time":"202304111341"}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "data":list[{},{}],"success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = CreateDataDictController(req_json, accesstoken)
+    ret = controller.update_dict_data()
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/dict/data/page', methods=['POST'])
+def get_dict_data_list():
+    """查询造数关键字配置列表
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | pageNo |  true  | query |  int  | 基本信息的id |
+        | pageSize |  true  | query |  int  | 详细信息的id |
+        | dict_value |  true  | query |  string  | 配置值 |
+        | team_name |  true  | query |  string  | 业务线 |
+
+        ### 请求
+        ```json
+        {"pageNo":1,"pageSize":10,"detail_name":"","team_name":"","file_name":"","module_name":""}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "data":list[{},{}],"success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = CreateDataDictController(req_json, accesstoken)
+    ret = controller.get_dict_list_data()
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/get/pull/git', methods=['POST'])
+def get_new_git_info():
+    """获取git上的最新代码到本地
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | fileName |  true  | query |  string  | 传入需要抓取的文件名称 |
+        | team |  true  | query |  string  | 业务线名称 |
+        | username |  true  | query |  string  | git地址用户名 |
+        | password |  true  | query |  string  | git地址密码 |
+
+        ### 请求
+        ```json
+        {"team":"USER","fileName":"","username":"","password":""}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    # accesstoken = request.headers['accesstoken']
+    accesstoken = "22233"
+    controller = ScrapyController(req_json, accesstoken)
+    ret = controller.get_git_pull()
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/get/eureka', methods=['POST'])
+def get_eureka_ip():
+    """更新eureka上的ip地址
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | team |  true  | query |  string  | 业务线名称 |
+
+        ### 请求
+        ```json
+        {"team":"USER"}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = ScrapyController(req_json, accesstoken)
+    ret = controller.get_eureka_ip()
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/create/data/detail/scrapy', methods=['POST'])
+def scrapy_entery_db():
+    """查找出全部的可用方法与描述进行录库
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | fileName |  true  | query |  string  | 传入需要抓取的文件名称 |
+        | team |  true  | query |  string  | 业务线名称 |
+        | username |  true  | query |  string  | git地址用户名 |
+        | password |  true  | query |  string  | git地址密码 |
+
+        ### 请求
+        ```json
+        {"team":"USER","fileName":"","username":"","password":""}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    # accesstoken = request.headers['accesstoken']
+    accesstoken = "123"
+    controller = ScrapyController(req_json, accesstoken)
+    ret = controller.scrapy_enter_db()
+    if ret != "抓取成功":
+        return ApiResponse.build_failure(40012, msg=ret)
+    return ApiResponse.build_success(20000, message=ret)
+
+
+@api.route('/get/team/name', methods=['POST'])
+def get_team_name():
+    """获取各个业务线的数据字典,用于查询
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | data_type |  true  | query |  int  | 类型 |
+        | team_name |  true  | query |  string  | 组名 |
+
+        ### 请求
+        ```json
+        {"data_type":2,"team_name":""}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "data":"","success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = CreateDataDictController(req_json, accesstoken)
+    ret = controller.get_team_name()
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/create/data/detail/delete', methods=['POST'])
+def delete_data_detail():
+    """删除造数关键字基本信息
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | create_data_detail_id |  true  | query |  int  | 基本信息的id |
+
+        ### 请求
+        ```json
+        {"create_data_detail_id":""}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "data":true,"success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = CreateDataDetailController(req_json, accesstoken)
+    ret = controller.delete_detail_data()
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/create/data/info/add', methods=['POST'])
+def add_keywors_data():
+    """增加造数关键字的请求参数
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | create_data_info_id |  true  | query |  string  | 基本信息的id |
+        | create_data_detail_id |  true  | query |  string  | 详细信息的id |
+        | className |  true  | query |  string  | 类名 |
+        | methodName |  true  | query |  string  | 方法名 |
+        | request_parameter |  true  | query |  string  | 请求参数 |
+
+        ### 请求
+        ```json
+        {"create_data_info_id":"12","create_data_detail_id":"13","className":"StudentEvent","methodName":"get_student_classroom","request_parameter":""}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = CreateDataInfoController(req_json, accesstoken)
+    err_msg = controller.create_info_data()
+    if err_msg:
+        return ApiResponse.build_failure(40012, msg=err_msg)
+    return ApiResponse.build_success(20000)
+
+
+@api.route('/create/data/info/list', methods=['POST'])
+def get_keywors_data_list():
+    """查询造数关键字请求列表页数据
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | create_data_info_id |  true  | query |  string  | 基本信息的id |
+        | create_data_detail_id |  true  | query |  string  | 详细信息的id |
+        | className |  true  | query |  string  | 类名 |
+        | methodName |  true  | query |  string  | 方法名 |
+        | request_parameter |  true  | query |  string  | 请求参数 |
+
+        ### 请求
+        ```json
+        {"create_data_info_id":"12","create_data_detail_id":"13","className":"StudentEvent","methodName":"get_student_classroom","request_parameter":""}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = CreateDataInfoController(req_json, accesstoken)
+    ret = controller.create_info_data()
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/Login', methods=['POST'])
+def get_user_login():
+    """判断登录，根据登录信息获取邮箱
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | username |  true  | query |  string  | 用户名 |
+        | password |  true  | query |  string  | 密码 |
+
+        ### 请求
+        ```json
+        {"username":2,"password":""}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "data":"","success":}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = UserController(req_json, accesstoken)
+    ret = controller.get_user_email()
+    if ret.get("code") != 20000:
+        return ApiResponse.build_failure(40012, msg=ret.get("message"))
+    return ApiResponse.build_success(20000, data=ret.get("data"))
+
+
+@api.route('/create/data/detail/approve', methods=['POST'])
+def approve_detail_info():
+    """对关键字进行审核
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        | create_data_detail_id |  true  | query |  int  | 基本信息的id |
+
+        ### 请求
+        ```json
+        {"create_data_detail_id":123}
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "data":{},"success":True}
+        ```
+        @@@
+    """
+    req_json = request.get_json()
+    accesstoken = request.headers['accesstoken']
+    controller = CreateDataDetailController(req_json, accesstoken)
+    ret = controller.approve_detail_status()
+    if ret.get("code") != 20000:
+        return ApiResponse.build_failure(40012, msg=ret.get("message"))
+    return ApiResponse.build_success(20000, data=ret)
+
+
+@api.route('/update/month/use/number', methods=['GET'])
+def update_month_use_number():
+    """每月使用次数更新，定时任务
+        @@@
+        ### 参数
+        |  参数名 | 是否必传 | 请求类型 |参数类型 |  参数描述 |
+        |-------|---------|--------|--------|----------|
+        ### 请求
+        ```json
+        ```
+        ### 响应
+        ```json
+        {"code": x, "message": "x", "data":{},"success":True}
+        ```
+        @@@
+    """
+    controller = CommonController()
+    ret = controller.daily_task_update_month_number()
+    if ret.get("code") != 20000:
+        return ApiResponse.build_failure(40012, msg=ret.get("message"))
+    return ApiResponse.build_success(20000, data=ret)