update 问卷管理、优化标签管理接口

Modules/Indicators/Tags/TagsImpl.py

@@ -11,16 +11,29 @@ class TagsImpl(object):
     @staticmethod
     def search_tags(**kwargs):
         """标签搜索"""
+        if kwargs['tag_category'] == 'func':
+            category = '函数'
+        elif kwargs['tag_category'] == 'api':
+            category = '接口'
+        elif kwargs['tag_category'] == 'model':
+            category = '模型'
+        elif kwargs['tag_category'] == 'question':
+            category = '问题'
+        elif kwargs['tag_category'] == 'questionnaire':
+            category = '问卷'
+        else:
+            category = None
+
         total = DB_TEST.find_all_data_with_count(
             '模型数据',
             '标签数据',
-            {'标签名称': {"$regex": kwargs['tag_name']}, '标签类别': kwargs['tag_category']}
+            {'标签名称': {"$regex": kwargs['tag_name']}, '标签类别': category}
         )
 
         records = DB_TEST.find_data_by_page_with_sort(
             '模型数据',
             '标签数据',
-            {'标签名称': {"$regex": kwargs['tag_name']}, '标签类别': kwargs['tag_category']},
+            {'标签名称': {"$regex": kwargs['tag_name']}, '标签类别': category},
             ['标签ID', '标签名称', '创建日期'],
             {'创建日期': -1},
             kwargs['page_size'],
@@ -43,6 +56,10 @@ class TagsImpl(object):
             tag_category = '接口'
         elif kwargs['tag_category'] == 'model':
             tag_category = '模型'
+        elif kwargs['tag_category'] == 'question':
+            tag_category = '问题'
+        elif kwargs['tag_category'] == 'questionnaire':
+            tag_category = '问卷'
         else:
             tag_category = None
 
@@ -60,16 +77,16 @@ class TagsImpl(object):
         """获取标签关联数据"""
         if kwargs['tag_category'] == 'func':
             tag_category = '函数'
-            tag_associate = '关联函数'
         elif kwargs['tag_category'] == 'api':
             tag_category = '接口'
-            tag_associate = '关联接口'
         elif kwargs['tag_category'] == 'model':
             tag_category = '模型'
-            tag_associate = '关联模型'
+        elif kwargs['tag_category'] == 'question':
+            tag_category = '问题'
+        elif kwargs['tag_category'] == 'questionnaire':
+            tag_category = '问卷'
         else:
             tag_category = None
-            tag_associate = None
 
         page_size = kwargs['page_size']
         page_no = kwargs['page_no'] * page_size - 1 if kwargs['page_no'] != 1 else 0
@@ -78,7 +95,7 @@ class TagsImpl(object):
             '模型数据',
             '标签数据',
             {'标签ID': kwargs['tag_id'], '标签类别': tag_category},
-            tag_associate
+            '关联数据'
         )
 
         records = DB_TEST.find_data_with_aggregate(
@@ -86,11 +103,11 @@ class TagsImpl(object):
             '标签数据',
             [
                 {"$match": {"标签ID": kwargs['tag_id'], "标签类别": tag_category}},
-                {"$project": {'_id': 0, tag_associate: {"$slice": ["${}".format(tag_associate), page_no, page_size]}}}
+                {"$project": {'_id': 0, '关联数据': {"$slice": ["${}".format('关联数据'), page_no, page_size]}}}
             ]
         )
 
-        result = records[0][tag_associate]
+        result = records[0]['关联数据']
 
         return {
             "total": len(total),
@@ -116,9 +133,7 @@ class TagsImpl(object):
         obj.tag_id = TagsUtils.TagsUtils.make_new_cid()
         obj.tag_field = filed
         obj.tag_category = category
-        obj.associate_func = list()
-        obj.associate_api = list()
-        obj.associate_question = list()
+        obj.associate_data = list()
         obj.create_date = time.strftime('%Y-%m-%d', time.localtime())
         DB_TEST.upsert_single_data(
             '模型数据',
@@ -129,103 +144,58 @@ class TagsImpl(object):
         return '新增成功'
 
     @staticmethod
-    def cancel_associate_func(**kwargs):
-        """取消关联函数"""
-        tag_id = kwargs['tag_id']
-        func_id = kwargs['func_id']
-
-        DB_TEST.update_single_data_by_pull(
-            '模型数据',
-            '标签数据',
-            {'标签ID': tag_id},
-            {"关联函数": {"函数ID": func_id}}
-        )
-
-        return '取消关联成功'
-
-    @staticmethod
-    def associate_func(**kwargs):
-        """关联函数"""
+    def associate_tags(**kwargs):
+        """关联标签"""
         data = kwargs['data']
 
-        obj = TagObj.AssociateFunc()
-        obj.func_id = data['func_id']
-        obj.func_name = data['func_name']
+        obj = TagObj.AssociateData()
+        type_ = data['associate_type']
+        if type_ == 'func':
+            obj.func_id = data['associate_id']
+            obj.func_name = data['associate_name']
+        elif type_ == 'api':
+            obj.api_id = data['associate_id']
+            obj.api_name = data['associate_name']
+        elif type_ == 'question':
+            obj.question_id = data['associate_id']
+            obj.question_name = data['associate_name']
+        elif type_ == 'questionnaire':
+            obj.questionnaire_id = data['associate_id']
+            obj.questionnaire_name = data['associate_name']
 
         for item in data['tags_id']:
             DB_TEST.update_single_data_by_add(
                 '模型数据',
                 '标签数据',
                 {'标签ID': item},
-                {"关联函数": obj.fields_toggle()}
+                {"关联数据": obj.fields_toggle()}
             )
 
         return '关联成功'
 
     @staticmethod
-    def associate_api(**kwargs):
-        """关联接口"""
-        data = kwargs['data']
-
-        obj = TagObj.AssociateApi()
-        obj.api_id = data['api_id']
-        obj.api_name = data['api_name']
-
-        for item in data['tags_id']:
-            DB_TEST.update_single_data_by_add(
-                '模型数据',
-                '标签数据',
-                {'标签ID': item},
-                {"关联接口": obj.fields_toggle()}
-            )
-
-        return '关联成功'
-
-    @staticmethod
-    def cancel_associate_api(**kwargs):
-        """取消关联接口"""
+    def cancel_associate_tags(**kwargs):
+        """取消关联标签"""
         tag_id = kwargs['tag_id']
-        api_id = kwargs['api_id']
+        questionnaire_id = kwargs['associate_id']
+        associate_type = kwargs['associate_type']
+
+        if associate_type == 'func':
+            _id = '函数ID'
+        elif associate_type == 'api':
+            _id = '接口ID'
+        elif associate_type == 'question':
+            _id = '问题ID'
+        elif associate_type == 'questionnaire':
+            _id = '问卷ID'
+        else:
+            _id = None
 
         DB_TEST.update_single_data_by_pull(
             '模型数据',
             '标签数据',
             {'标签ID': tag_id},
-            {"关联接口": {"接口ID": api_id}}
-        )
-
-        return '取消关联成功'
-
-    @staticmethod
-    def associate_question(**kwargs):
-        """关联问题"""
-        data = kwargs['data']
-
-        obj = TagObj.AssociateQuestion()
-        obj.question_id = data['question_id']
-        obj.question_name = data['question_name']
-
-        for item in data['tags_id']:
-            DB_TEST.update_single_data_by_add(
-                '模型数据',
-                '标签数据',
-                {'标签ID': item},
-                {"关联问题": obj.fields_toggle()}
-            )
-
-        return '关联成功'
-
-    @staticmethod
-    def cancel_associate_question(**kwargs):
-        """取消关联问题"""
-        tag_id = kwargs['tag_id']
-        question_id = kwargs['question_id']
-
-        DB_TEST.update_single_data_by_pull(
-            '模型数据',
-            '标签数据',
-            {'标签ID': tag_id},
-            {"关联问题": {"问题ID": question_id}}
+            {"关联数据": {_id: questionnaire_id}}
         )
 
         return '取消关联成功'

Modules/Indicators/Tags/TagsObj.py

@@ -67,50 +67,38 @@ class IndexObj(SpecObject):
 class TagObj(SpecObject):
     """标签"""
 
-    class AssociateFunc(SpecObject):
-        """关联函数"""
+    class AssociateData(SpecObject):
+        """关联数据"""
         func_id = ValidateAttr(field='func_id', type=str)
         func_name = ValidateAttr(field='func_name', type=str)
+        api_id = ValidateAttr(field='api_id', type=str)
+        api_name = ValidateAttr(field='api_name', type=str)
+        question_id = ValidateAttr(field='question_id', type=str)
+        question_name = ValidateAttr(field='question_name', type=str)
+        questionnaire_id = ValidateAttr(field='questionnaire_id', type=str)
+        questionnaire_name = ValidateAttr(field='questionnaire_name', type=str)
 
         fields_map = {
             "func_id": "函数ID",
-            "func_name": "函数名称"
-        }
-
-    class AssociateApi(SpecObject):
-        """关联接口"""
-        api_id = ValidateAttr(field='api_id', type=str)
-        api_name = ValidateAttr(field='api_name', type=str)
-
-        fields_map = {
+            "func_name": "函数名称",
             "api_id": "接口ID",
-            "api_name": "接口名称"
-        }
-
-    class AssociateQuestion(SpecObject):
-        """关联问题"""
-        question_id = ValidateAttr(field='question_id', type=str)
-        question_name = ValidateAttr(field='question_name', type=str)
-
-        fields_map = {
+            "api_name": "接口名称",
             "question_id": "问题ID",
-            "question_name": "问题名称"
+            "question_name": "问题名称",
+            "questionnaire_id": "问卷ID",
+            "questionnaire_name": "问卷名称"
         }
 
     tag_id = ValidateAttr(field='tag_id', type=str)
     tag_field = ValidateAttr(field='tag_field', type=str)
     tag_category = ValidateAttr(field='tag_category', type=str)
-    associate_func = ValidateAttr(field='associate_func', instance_list=AssociateFunc)
-    associate_api = ValidateAttr(field='associate_api', instance_list=AssociateApi)
-    associate_question = ValidateAttr(field='associate_question', instance_list=AssociateQuestion)
+    associate_data = ValidateAttr(field='associate_data', instance_list=AssociateData)
     create_date = ValidateAttr(field='create_date', func=Validate.date_format)
 
     fields_map = {
         "tag_id": "标签ID",
         "tag_field": "标签名称",
         "tag_category": "标签类别",
-        "associate_func": "关联函数",
-        "associate_api": "关联接口",
-        "associate_question": "关联问题",
+        "associate_data": "关联数据",
         "create_date": "创建日期"
     }

Modules/Indicators/Tags/TagsRoutes.py

@@ -72,88 +72,31 @@ def new_tags_route():
         return {"info": e.__str__()}, e.status_code
 
 
-@tags_route.route('/cancel_associate_func', methods=['GET'])
-def cancel_associate_func_route():
-    """取消关联函数"""
+@tags_route.route('/associate_tags', methods=['POST'])
+def associate_data_route():
+    """标签关联问卷"""
     try:
-        RouteParamsCheck(request.args, ["tag_id", "func_id"]).required()
-        tag_id = request.args['tag_id']
-        func_id = request.args['func_id']
-        impl = TagsImpl()
-        result = impl.cancel_associate_func(tag_id=tag_id, func_id=func_id)
-        return {"info": "关联函数", "result": result}, 200
-
-    except APIReturnError as e:
-        return {"info": e.__str__()}, e.status_code
-
-
-@tags_route.route('/associate_func', methods=['POST'])
-def associate_func_route():
-    """关联函数"""
-    try:
-        RouteParamsCheck(request.json, ["tags_id", "func_id", "func_name"]).required()
+        RouteParamsCheck(request.json, ["tags_id", "associate_id", "associate_name", "associate_type"]).required()
         data = request.json
         impl = TagsImpl()
-        result = impl.associate_func(data=data)
-        return {"info": "关联函数", "result": result}, 200
+        result = impl.associate_tags(data=data)
+        return {"info": "关联标签", "result": result}, 200
 
     except APIReturnError as e:
         return {"info": e.__str__()}, e.status_code
 
 
-@tags_route.route('/associate_api', methods=['POST'])
-def associate_api_route():
-    """关联接口"""
+@tags_route.route('/cancel_associate_questionnaire', methods=['GET'])
+def cancel_associate_questionnaire_route():
+    """取消关联问卷"""
     try:
-        RouteParamsCheck(request.json, ["tags_id", "api_id", "api_name"]).required()
-        data = request.json
-        impl = TagsImpl()
-        result = impl.associate_api(data=data)
-        return {"info": "关联接口", "result": result}, 200
-
-    except APIReturnError as e:
-        return {"info": e.__str__()}, e.status_code
-
-
-@tags_route.route('/cancel_associate_api', methods=['GET'])
-def cancel_associate_api_route():
-    """取消关联接口"""
-    try:
-        RouteParamsCheck(request.args, ["tag_id", "api_id"]).required()
+        RouteParamsCheck(request.args, ["tag_id", "associate_id", "associate_type"]).required()
         tag_id = request.args['tag_id']
-        api_id = request.args['api_id']
+        associate_id = request.args['associate_id']
+        associate_type = request.args['associate_type']
         impl = TagsImpl()
-        result = impl.cancel_associate_api(tag_id=tag_id, api_id=api_id)
-        return {"info": "关联接口", "result": result}, 200
+        result = impl.cancel_associate_tags(tag_id=tag_id, associate_id=associate_id, associate_type=associate_type)
+        return {"info": "关联标签", "result": result}, 200
 
     except APIReturnError as e:
         return {"info": e.__str__()}, e.status_code
-
-
-@tags_route.route('/associate_question', methods=['POST'])
-def associate_question_route():
-    """关联问题"""
-    try:
-        RouteParamsCheck(request.json, ["tags_id", "question_id", "question_name"]).required()
-        data = request.json
-        impl = TagsImpl()
-        result = impl.associate_question(data=data)
-        return {"info": "关联问题", "result": result}, 200
-
-    except APIReturnError as e:
-        return {"info": e.__str__()}, e.status_code
-
-
-@tags_route.route('/cancel_associate_question', methods=['GET'])
-def cancel_associate_question_route():
-    """取消关联问题"""
-    try:
-        RouteParamsCheck(request.args, ["tag_id", "question_id"]).required()
-        tag_id = request.args['tag_id']
-        question_id = request.args['question_id']
-        impl = TagsImpl()
-        result = impl.cancel_associate_question(tag_id=tag_id, question_id=question_id)
-        return {"info": "关联问题", "result": result}, 200
-
-    except APIReturnError as e:
-        return {"info": e.__str__()}, e.status_code

Modules/Questionnaire/QuestionnaireObj.py

@@ -0,0 +1,51 @@
+from Utils.ObjUtil import SpecObject
+from Utils.ValidateUtil import ValidateAttr, Validate
+
+
+class QuestionnaireObj(SpecObject):
+    """问卷类"""
+
+    class Section(SpecObject):
+        """小节"""
+
+        class Content(SpecObject):
+            """内容详情"""
+            topic = ValidateAttr(field="topic", type=str)
+            version = ValidateAttr(field="version", type=str)
+            question_id = ValidateAttr(field="question_id", type=str)
+            weight = ValidateAttr(field="weight", type=[int, float])
+
+            fields_map = {
+                "topic": "题目",
+                "version": "题型",
+                "question_id": "问题ID",
+                "weight": "权重"
+            }
+
+        section_name = ValidateAttr(field='section_name', type=str)
+        section_content = ValidateAttr(field='section_content', instance_list=Content)
+        total = ValidateAttr(field='total', type=int)
+
+        fields_map = {
+            "section_name": "小节名称",
+            "section_content": "小节内容",
+            "total": "合计"
+        }
+
+    questionnaire_id = ValidateAttr(field='questionnaire_id', type=str)
+    questionnaire_name = ValidateAttr(field='questionnaire_name', type=str)
+    questionnaire_score = ValidateAttr(field='questionnaire_score', type=int)
+    tags = ValidateAttr(field='tags', type=list)
+    author = ValidateAttr(field='author', type=str)
+    date = ValidateAttr(field='date', func=Validate.date_format)
+    section = ValidateAttr(field='section', instance_list=Section)
+
+    fields_map = {
+        "questionnaire_id": "问卷ID",
+        "questionnaire_name": "问卷名称",
+        "questionnaire_score": "问卷分值",
+        "tags": "标签",
+        "author": "作者",
+        "date": "日期",
+        "section": "小节"
+    }

Modules/Questionnaire/QuestionnaireRoutes.py

@@ -0,0 +1,82 @@
+from flask import Blueprint, request
+
+from Modules.Questionnaire.QuestionnaireUtils import QuestionnaireUtils
+from Modules.Questionnaire.Questionnairelmpl import QuestionnaireImpl
+from Utils.ErrorUtil import APIReturnError
+from Utils.RouteUtil import RouteParamsCheck
+
+questionnaire_route = Blueprint('questionnaire', __name__)
+
+
+@questionnaire_route.route('/questionnaire_id', methods=['GET'])
+def questionnaire_id_route():
+    """新建问卷id"""
+    try:
+        impl = QuestionnaireUtils()
+        result = impl.make_new_cid()
+        return {"info": "新建问卷ID", "问卷ID": result}, 200
+    except APIReturnError as e:
+        return {"info": e.__str__()}, e.status_code
+
+
+@questionnaire_route.route('/new_questionnaire', methods=['POST'])
+def new_questionnaire_route():
+    """新建问卷"""
+    try:
+        RouteParamsCheck(req=request.json, params=[
+            "questionnaire_id", "questionnaire_name", "questionnaire_score", "section", "author", "tags"
+        ]).required()
+        data = request.json
+        impl = QuestionnaireImpl()
+        result = impl.new_questionnaire(data=data)
+        return {"info": "新建问卷", "result": result}, 200
+    except APIReturnError as e:
+        return {"info": e.__str__()}, e.status_code
+
+
+@questionnaire_route.route('/search_questionnaire', methods=['POST'])
+def search_questionnaire_route():
+    """查询问卷"""
+    try:
+        RouteParamsCheck(req=request.json, params=["sort", "page_no", "page_size"]).required()
+        data = request.json
+        impl = QuestionnaireImpl()
+        result = impl.search_questionnaire(data=data)
+        return {"info": "查询问卷", "result": result}, 200
+    except APIReturnError as e:
+        return {"info": e.__str__()}, e.status_code
+
+
+@questionnaire_route.route('/operate_questionnaire', methods=['GET', 'POST'])
+def operate_questionnaire_route():
+    """查看/编辑问卷"""
+    try:
+        if request.method == 'GET':
+            RouteParamsCheck(request.args, ["qid"]).required()
+            qid = request.args["qid"]
+            impl = QuestionnaireImpl()
+            result = impl.view_questionnaire(qid=qid)
+            return {"info": "查看问卷", "result": result}, 200
+        if request.method == 'POST':
+            RouteParamsCheck(request.json, [
+                "questionnaire_id", "questionnaire_name", "questionnaire_score", "section", "author", "tags"
+            ]).required()
+            data = request.json
+            impl = QuestionnaireImpl()
+            result = impl.edit_questionnaire(data=data)
+            return {"info": "编辑问卷", "result": result}, 200
+    except APIReturnError as e:
+        return {"info": e.__str__()}, e.status_code
+
+
+@questionnaire_route.route('/delete_questionnaire', methods=['GET'])
+def delete_questionnaire_route():
+    """删除问卷"""
+    try:
+        RouteParamsCheck(request.args, ["qid"]).required()
+        qid = request.args["qid"]
+        impl = QuestionnaireImpl()
+        result = impl.delete_questionnaire(qid=qid)
+        return {"info": "删除问卷", "result": result}, 200
+    except APIReturnError as e:
+        return {"info": e.__str__()}, e.status_code

Modules/Questionnaire/QuestionnaireUtils.py

@@ -0,0 +1,18 @@
+from DBHelper.MongoHelperInstance import DB_TEST
+from Utils.CommonUtil import CommonUtils
+
+
+class QuestionnaireUtils(object):
+
+    @staticmethod
+    def make_new_cid():
+        new_cid = CommonUtils.random_code(8)
+        case = DB_TEST.find_single_column(
+            "模型数据",
+            "问卷数据",
+            {"问卷ID": new_cid},
+            "问卷ID"
+        ) is not None
+        while case:
+            new_cid = CommonUtils.random_code(8)
+        return new_cid

Modules/Questionnaire/Questionnairelmpl.py

@@ -0,0 +1,232 @@
+import time
+
+from DBHelper.MongoHelperInstance import DB_TEST
+from Modules.Questionnaire.QuestionnaireObj import QuestionnaireObj
+
+
+class QuestionnaireImpl(object):
+    """问卷类"""
+
+    @staticmethod
+    def new_questionnaire(**kwargs):
+        """新建问卷"""
+        data = kwargs['data']
+
+        case = DB_TEST.find_single_column(
+            "模型数据",
+            "问卷数据",
+            {"问卷ID": data['questionnaire_id']},
+            "问卷ID"
+        )
+        if case:
+            return '问卷ID已存在'
+
+        quest = QuestionnaireObj()
+        quest.questionnaire_id = data['questionnaire_id']
+        quest.questionnaire_name = data['questionnaire_name']
+        quest.questionnaire_score = data['questionnaire_score']
+        quest.author = data['author']
+        quest.date = time.strftime('%Y-%m-%d', time.localtime())
+        quest.tags = data['tags']
+        quest.section = list()
+
+        for section_ in data['section']:
+            section = quest.Section()
+            section.section_name = section_['section_name']
+            section.total = section_['total']
+            section.section_content = list()
+            for content_ in section_['section_content']:
+                content = section.Content()
+                content.topic = content_['topic']
+                content.version = content_['version']
+                content.question_id = content_['question_id']
+                content.weight = content_['weight']
+                section.section_content.append(content)
+            quest.section.append(section)
+
+        DB_TEST.upsert_single_data(
+            '模型数据',
+            '问卷数据',
+            {'问卷名称': data['questionnaire_name']},
+            quest.fields_toggle()
+        )
+
+        return '新建成功'
+
+    @staticmethod
+    def search_questionnaire(**kwargs):
+        """查询问卷"""
+
+        def make_search_body(param):
+            body = dict()
+            search_keys = list(param.keys())
+            if 'questionnaire_name' in search_keys:
+                body['问卷名称'] = {"$regex": param['questionnaire_name']}
+
+            if 'author' in search_keys:
+                body['作者'] = param['author']
+
+            if 'tags' in search_keys:
+                body['标签'] = {"$in": param['tags']}
+
+            return body
+
+        def make_sort_body(param):
+            if param == 'asc':
+                body = {"日期": 1}
+            else:
+                body = {"日期": -1}
+
+            return body
+
+        data = kwargs['data']
+        sort = data['sort']
+        page_size = int(data['page_size'])
+        page_no = int(data['page_no'])
+        search_body = make_search_body(data)
+        sort_body = make_sort_body(sort)
+        page_size = 10 if page_size > 10 else page_size
+
+        total = DB_TEST.find_all_data_with_count(
+            '模型数据',
+            '问卷数据',
+            search_body
+        )
+
+        records = DB_TEST.find_data_by_page_with_sort(
+            '模型数据',
+            '问卷数据',
+            search_body,
+            ['问卷ID', '问卷名称', '作者', '日期', '标签'],
+            sort_body,
+            page_size,
+            page_no
+        )
+
+        return_list = list()
+        if records:
+            for record in records:
+                return_dict = dict()
+                return_dict['questionnaire_id'] = record['问卷ID']
+                return_dict['questionnaire_name'] = record['问卷名称']
+                return_dict['author'] = record['作者']
+                return_dict['date'] = record['日期']
+                return_dict['tags'] = record['标签']
+                return_list.append(return_dict)
+
+        result = {
+            "total": total,
+            "records": return_list
+        }
+
+        return result
+
+    @staticmethod
+    def view_questionnaire(**kwargs):
+        """查看问卷"""
+        qid = kwargs['qid']
+        record = DB_TEST.find_single_data(
+            '模型数据',
+            '问卷数据',
+            {'问卷ID': qid},
+            ['问卷ID', '问卷名称', '问卷分值', '标签', '小节', '日期', '作者']
+        )
+
+        return_dict = dict()
+        if record:
+            return_dict['questionnaire_id'] = record['问卷ID']
+            return_dict['questionnaire_name'] = record['问卷名称']
+            return_dict['questionnaire_score'] = record['问卷分值']
+            return_dict['tags'] = record['标签']
+            return_dict['date'] = record['日期']
+            return_dict['author'] = record['作者']
+            return_dict['section'] = list()
+
+            for section in record['小节']:
+                section_ = dict()
+                section_['section_name'] = section['小节名称']
+                section_['total'] = section['合计']
+                section_['section_content'] = list()
+                for content in section['小节内容']:
+                    content_ = dict()
+                    content_['topic'] = content['题目']
+                    content_['version'] = content['题型']
+                    content_['question_id'] = content['问题ID']
+                    content_['weight'] = content['权重']
+                    section_['section_content'].append(content_)
+                return_dict['section'].append(section_)
+
+        return return_dict
+
+    @staticmethod
+    def edit_questionnaire(**kwargs):
+        """编辑问卷"""
+        data = kwargs['data']
+        question_name = DB_TEST.find_single_column(
+            '模型数据',
+            '问卷数据',
+            {'问卷ID': data['questionnaire_id']},
+            '问卷名称'
+        )
+        if not question_name:
+            return '问卷不存在'
+
+        quest = QuestionnaireObj()
+        quest.questionnaire_id = data['questionnaire_id']
+        quest.questionnaire_name = data['questionnaire_name']
+        quest.questionnaire_score = data['questionnaire_score']
+        quest.author = data['author']
+        quest.date = time.strftime('%Y-%m-%d', time.localtime())
+        quest.tags = data['tags']
+        quest.section = list()
+
+        for section_ in data['section']:
+            section = quest.Section()
+            section.section_name = section_['section_name']
+            section.total = section_['total']
+            section.section_content = list()
+            for content_ in section_['section_content']:
+                content = section.Content()
+                content.topic = content_['topic']
+                content.version = content_['version']
+                content.question_id = content_['question_id']
+                content.weight = content_['weight']
+                section.section_content.append(content)
+            quest.section.append(section)
+
+        DB_TEST.update_single_data(
+            '模型数据',
+            '问卷数据',
+            {'问卷ID': data['questionnaire_id']},
+            quest.fields_toggle()
+        )
+
+        return '编辑成功'
+
+    @staticmethod
+    def delete_questionnaire(**kwargs):
+        """删除问卷"""
+        qid = kwargs['qid']
+
+        tags = DB_TEST.find_single_column(
+            '模型数据',
+            '问卷数据',
+            {'问卷ID': qid},
+            '标签'
+        )
+        # 删除标签关联的问题
+        for tag in tags:
+            DB_TEST.update_single_data_by_pull(
+                '模型数据',
+                '标签数据',
+                {'标签名称': tag},
+                {"关联数据": {"问卷ID": qid}}
+            )
+        # 删除问题
+        DB_TEST.delete_single_data(
+            '模型数据',
+            '问卷数据',
+            {'问卷ID': qid}
+        )
+
+        return '操作成功'

Modules/Questions/QuestionsImpl.py

@@ -293,7 +293,7 @@ class QuestionImpl(object):
             setting.assigned = decision['assigned']
             quest.decision_setting = setting
 
-        DB_TEST.upsert_single_data(
+        DB_TEST.update_single_data(
             '模型数据',
             '问题数据',
             {'问题ID': data['question_id']},
@@ -324,7 +324,7 @@ class QuestionImpl(object):
         # 删除问题
         DB_TEST.delete_single_data(
             '模型数据',
-            '标签数据',
+            '问题数据',
             {'问题ID': qid}
         )
 

Modules/Questions/QuestionsRoutes.py

@@ -67,7 +67,7 @@ def operate_question_route():
         return {"info": e.__str__()}, e.status_code
 
 
-@question_route.route('/delete_question', methods=['GET', 'POST'])
+@question_route.route('/delete_question', methods=['GET'])
 def delete_question_route():
     """删除问题"""
     try:

app.py

@@ -6,6 +6,7 @@ from Modules.Indicators.Tags.TagsRoutes import tags_route
 from Modules.Interface.InterfaceRoutes import interface_route
 from Modules.Interface.InterfaceSetRoutes import apiset_route
 from Modules.Models.Score.ScoreRoutes import score_model_route
+from Modules.Questionnaire.QuestionnaireRoutes import questionnaire_route
 from Modules.Questions.QuestionsRoutes import question_route
 
 app = Flask(__name__)
@@ -19,6 +20,7 @@ app.register_blueprint(interface_route, url_prefix='/rating/interface')
 app.register_blueprint(apiset_route, url_prefix='/rating/interface/apiset')
 app.register_blueprint(score_model_route, url_prefix='/rating/score_model')
 app.register_blueprint(question_route, url_prefix='/rating/question')
+app.register_blueprint(questionnaire_route, url_prefix='/rating/questionnaire')
 
 
 @app.route('/admin/version')