initial commit

apps/project/tools/auto_create_data.py

@@ -0,0 +1,249 @@
+"""该模块主要自动生成静态分析、代码审查以及文档审查的设计需求、测试项、用例"""
+from apps.project.models import (
+    Project,
+    Dut,
+    Design,
+    TestDemand,
+    TestDemandContent,
+    TestDemandContentStep,
+    Case,
+    CaseStep
+)
+
+def auto_create_jt_and_dm(user_name: str, dut_qs: Dut, project_obj: Project):
+    """传入源代码dut以及测试人员名称username，自动在dut下面生成静态分析和代码审查设计需求、测试项、用例"""
+    # 先查询dut_qs下面有多少design，以便写里面的key
+    design_index = dut_qs.rsField.count()
+    # 1.1.自动创建design静态分析
+    jt_design_create_dict = {
+        'ident': 'JTFX',
+        'name': '静态分析',
+        'demandType': '6',
+        'description': "依据相关的要求，利用静态分析工具对被测软件全部源程序进行控制流分析、"
+                       "数据流分析进行分析，并统计软件质量度量信息，给出软件源代码检查结果",
+        'title': '静态分析',
+        'key': ''.join([dut_qs.key, '-', str(design_index)]),
+        'level': '2',
+        'chapter': '/',
+        'project': project_obj,
+        'round': dut_qs.round,
+        'dut': dut_qs
+    }
+    design_index += 1
+    new_design_jt: Design = Design.objects.create(**jt_design_create_dict)
+    # 1.1.1.自动创建demand静态分析
+    jt_demand_create_dict = {
+        'ident': 'JTFX',
+        'name': '静态分析',
+        'adequacy': '1）对软件全部源代码进行静态分析；\a'
+                    '2）对度量指标不满足指标要求的模块，应进行专项代码审查；\a'
+                    '3）按照控制流和数据流分析表单，对软件的控制流和数据流进行分析。',
+        'priority': '2',
+        'testType': '15',
+        'testMethod': ["3"],
+        'testDesciption': '对被测软件全部源程序进行静态分析，'
+                          '对控制流、数据流进行分析，验证软件是否满足控制流和数据流要求，'
+                          '并依据质量特性需求统计质量度量信息',
+        'title': '静态分析',
+        'key': ''.join([new_design_jt.key, '-', '0']),
+        'level': '3',
+        'project': project_obj,
+        'round': new_design_jt.round,
+        'dut': new_design_jt.dut,
+        'design': new_design_jt,
+    }
+    new_demand_jt = TestDemand.objects.create(**jt_demand_create_dict)
+    new_demand_content_obj = TestDemandContent.objects.create(testDemand=new_demand_jt, subName='静态分析')
+    TestDemandContentStep.objects.create(testDemandContent=new_demand_content_obj,
+                                         operation='根据静态分析的审查项和技术要求以及被测软件质量特性需求，'
+                                                   '编制检查单。使用静态分析工具Testbed和klocwork进行静态分析，对程序进行检查：\a'
+                                                   '1）使用静态分析工具统计软件质量度量信息；\a'
+                                                   '2）使用静态分析工具对软件进行规则检查；\a'
+                                                   '3）使用静态分析工具结合人工分析对控制流和数据流进行分析。')
+    new_case_jt = Case.objects.create(
+        ident='JTFX',
+        name='静态分析',
+        initialization='已获取全部被测件源代码程序，静态分析工具准备齐备',
+        premise='提交的代码出自委托方受控库，是委托方正式签署外发的',
+        summarize='依据委托方的要求进行静态分析，验证软件质量度量和编码规则是否满足军标要求',
+        designPerson=user_name,
+        testPerson=user_name,
+        monitorPerson=user_name,
+        project=project_obj,
+        isLeaf=True,
+        round=new_demand_jt.round,
+        dut=new_demand_jt.dut,
+        design=new_demand_jt.design,
+        test=new_demand_jt,
+        title='静态分析',
+        key=''.join([new_demand_jt.key, '-', '0']),
+        level='4'
+    )
+    CaseStep.objects.create(case=new_case_jt,
+                            operation='使用LDRA TestBed软件和Klocwork软件工具对被测软件'
+                                      '全部源程序进行静态分析，并配合人工以及检查单进行分析',
+                            expect='静态审查单全部通过，且源代码满足编码规则和质量度量要求',
+                            result='静态度量结果符合国军标要求，静态分析审查单全部通过', )
+    # 1.2.自动创建代码审查design
+    dm_design_create_dict = {
+        'ident': 'DMSC',
+        'name': '代码审查',
+        'demandType': '6',
+        'description': "依据相关要求及软件文档开展针对软件程序代码的代码审查",
+        'title': '代码审查',
+        'key': ''.join([dut_qs.key, '-', str(design_index)]),
+        'level': '2',
+        'chapter': '/',
+        'project': dut_qs.project,
+        'round': dut_qs.round,
+        'dut': dut_qs
+    }
+    new_design_dm = Design.objects.create(**dm_design_create_dict)
+    dm_demand_create_dict = {
+        'ident': 'DMSC',
+        'name': '代码审查',
+        'adequacy': '根据代码审查单的审查项，工具审查完成全部代码的审查，人工审查完成关键模块的审查，'
+                    '审查中发现的问题均得到有效处理。',
+        'priority': '2',
+        'testType': '2',
+        'testMethod': ["3"],
+        'title': '代码审查',
+        'testDesciption': '通过人工审查及借助klocwork、Testbed工具辅助分析的方式开展代码审查，'
+                          '审查代码和设计的一致性、代码执行标准的情况、代码逻辑表达的正确性、'
+                          '代码结构的合理性以及代码的可读性。人工审查中发现的问题，审查人员应及时记录。',
+        'key': ''.join([new_design_dm.key, '-', '0']),
+        'level': '3',
+        'project': project_obj,
+        'round': new_design_dm.round,
+        'dut': new_design_dm.dut,
+        'design': new_design_dm,
+    }
+    new_demand_dm = TestDemand.objects.create(**dm_demand_create_dict)
+    new_content_obj = TestDemandContent.objects.create(
+        testDemand=new_demand_dm,
+        subName='代码审查'
+    )
+    TestDemandContentStep.objects.create(
+        testDemandContent=new_content_obj,
+        operation='使用klocwork、testbed工具根据本大纲附录B中的代码审查单对代码审查范围内的源代码开展四个方面的审查，'
+                  '人工对所选模块进行如下四个方面的审查：\a'
+                  '1）编程准则检查：依据编程准则的要求，对程序的编码与编程准则进行符合性检查；\a'
+                  '2）代码流程审查：审查程序代码的条件判别、控制流程、数据处理等满足设计要求；\a'
+                  '3）软件结构审查：依据设计文档，审查程序代码的结构设计的合理性，包括程序结构设计和数据结构设计；\a'
+                  '4）需求实现审查：依据需求文档及其他相关资料，审查程序代码的需求层的功能实现是否正确。',
+    )
+    new_case_dm = Case.objects.create(
+        ident='DMSC',
+        name='代码审查',
+        initialization='代码已提交',
+        premise='提交的代码出自委托方受控库，是委托方正式签署外发的',
+        summarize='通过人工审查及借助工具辅助分析的方式开展代码审查，审查代码编程准则的符合性、'
+                  '代码流程实现的正确性、代码结构的合理性以及代码实现需求的正确性；人工审查中发现的问题，审查人员应及时记录',
+        designPerson=user_name,
+        testPerson=user_name,
+        monitorPerson=user_name,
+        project=project_obj,
+        isLeaf=True,
+        round=new_demand_dm.round,
+        dut=new_demand_dm.dut,
+        design=new_demand_dm.design,
+        test=new_demand_dm,
+        title='代码审查',
+        key=''.join([new_demand_dm.key, '-', '0']),
+        level='4'
+    )
+    CaseStep.objects.create(case=new_case_dm,
+                            operation='通过人工审查及借助工具辅助分析的方式开展代码审查，审查代码编程准则的符合性、'
+                                      '代码流程实现的正确性、代码结构的合理性以及代码实现需求的正确性；'
+                                      '人工审查中发现的问题，审查人员应及时记录',
+                            expect='代码设计正确，满足审查单要求，无不符合项',
+                            result='代码设计正确，满足审查单要求，无不符合项', )
+
+def auto_create_wd(user_name: str, dut_qs: Dut, project_obj: Project):
+    """传入用户名、在dut下创建、项目对象，自动创建文档审查的设计需求、测试项、测试用例"""
+    # 先查询dut_qs下有多少desgin，然后设置key
+    design_index = dut_qs.rsField.count()
+    # 1.1.自动创建文档审查design
+    wd_design_create_dict = {
+        'ident': 'WDSC',
+        'name': '文档审查',
+        'demandType': '6',
+        'description': "依据相关要求，逐项检查被测文档的齐套性、完整性、一致性和准确性是否满足要求",
+        'title': '文档审查',
+        'key': ''.join([dut_qs.key, '-', str(design_index)]),
+        'level': '2',
+        'chapter': '/',
+        'project': project_obj,
+        'round': dut_qs.round,
+        'dut': dut_qs
+    }
+    new_wd_design_obj: Design = Design.objects.create(**wd_design_create_dict)
+    # 1.1.1.自动创建demand文档审查
+    wd_demand_create_dict = {
+        'ident': 'WDSC',
+        'name': '文档审查',
+        'adequacy': '按照审查单审查文档的齐套性、完整性、一致性、准确性。',
+        'priority': '1',
+        'testType': '8',
+        'testMethod': ["3"],
+        'title': '文档审查',
+        'testDesciption': '本次文档审查包括的内容如下：\a'
+                          '1）软件研制总结报告\a'
+                          '2）软件开发计划\a'
+                          '3）软件运行方案说明\a'
+                          '4）软件接口需求规格说明\a'
+                          '5）软件系统设计说明\a'
+                          '6）软件接口设计说明\a'
+                          '7）软件需求规格说明\a'
+                          '8）软件配置项设计说明\a'
+                          '9）软件测试说明\a'
+                          '10）软件测试报告\a'
+                          '11）产品规格说明\a'
+                          '12）软件版本说明\a'
+                          '13）软件用户手册\a'
+                          '14）固件保障手册',
+        'key': ''.join([new_wd_design_obj.key, '-', '0']),
+        'level': '3',
+        'project': project_obj,
+        'round': new_wd_design_obj.round,
+        'dut': new_wd_design_obj.dut,
+        'design': new_wd_design_obj,
+    }
+    new_wd_demand_obj = TestDemand.objects.create(**wd_demand_create_dict)
+    new_wd_content_obj = TestDemandContent.objects.create(testDemand=new_wd_demand_obj, subName='文档审查')
+    TestDemandContentStep.objects.create(
+        testDemandContent=new_wd_content_obj,
+        operation='根据文档审查表人工逐项检查，检查此项目文档的齐套性、完整性、规范性：\a'
+                  '1）使用人工审查方法，按照附录A中文档齐套性审查单检查需求类、设计类、用户类、测试类文档是否齐套；\a'
+                  '2）使用人工审查方法，按照附录A中需求规格说明审查单对软件需求规格说明逐项检查；\a'
+                  '3）使用人工审查方法，按照附录A中软件设计文档审查单逐项检查。'
+    )
+    new_wd_case_obj = Case.objects.create(
+        ident='WDSC',
+        name='文档审查',
+        initialization='开发方已提交被测文档',
+        premise='提交的文档出自委托方受控库，是委托方正式签署外发的',
+        summarize='测试人员阅读文档，依据文档检查单对软件文档进行审查，审查文档内容是否完整、'
+                  '文档描述是否准确、文档格式是否规范、文档是否文文一致',
+        designPerson=user_name,
+        testPerson=user_name,
+        monitorPerson=user_name,
+        project=project_obj,
+        isLeaf=True,
+        round=new_wd_demand_obj.round,
+        dut=new_wd_demand_obj.dut,
+        design=new_wd_demand_obj.design,
+        test=new_wd_demand_obj,
+        title='文档审查',
+        key=''.join([new_wd_demand_obj.key, '-', '0']),
+        level='4'
+    )
+    CaseStep.objects.create(case=new_wd_case_obj,
+                            operation='按照测试需求中文档齐套性检查单检查需求类、设计类、用户类、测试类文档是否齐套',
+                            expect='文档齐套性检查单全部通过，软件文档齐套',
+                            result='文档齐套性检查单全部通过，软件文档齐套', )
+    CaseStep.objects.create(case=new_wd_case_obj,
+                            operation='按照测试需求中文档需求规格说明、设计文档等审查单，对相关文档进行审查',
+                            expect='文档满足完整性、准确性、规范性和一致性的要求',
+                            result='文档检查单全部审查通过，文档内容完整、文档描述准确、'
+                                   '文档格式规范、文档文文一致', )

apps/project/tools/copyCase.py

@@ -0,0 +1,163 @@
+from typing import Tuple, Any
+from copy import deepcopy
+from django.shortcuts import get_object_or_404
+from apps.project.models import Project
+from ninja.errors import HttpError
+
+# 1. case被移动到某测试项下面
+def case_move_to_test(project_id: int, case_key: str, demand_key: str) -> Tuple[str, Any]:
+    """移动case到某个测试项下面，传入project_id，case的key，测试项的key，renturn -> 元组(旧case的key,新case的key)"""
+    same_root_flag = False
+    if '-'.join(case_key.split('-')[:-1]) == demand_key:
+        same_root_flag = True
+    # 判断是否移动到自己所属的demand的，直接返回不操作
+    if same_root_flag:
+        raise HttpError(500, message='无法移动到自己所属测试项里面')
+    project_qs = get_object_or_404(Project, id=project_id)
+    case = project_qs.pcField.filter(key=case_key).first()
+    demand_origin = case.test  # 未变化之前case对应的测试项
+    demand = project_qs.ptField.filter(key=demand_key).first()  # 新的demand对象
+    case.ident = demand.ident
+    case.test = demand
+    case.round = demand.round
+    case.dut = demand.dut
+    case.design = demand.design
+    # 查询被拖拽到的demand有多少用例，用于设置key
+    case.key = "".join([demand.key, '-', str(demand.tcField.count())])
+    case.save()
+    # 因为移动要删除之前demand的用例，所以需要重新设置key
+    index = 0
+    for c in demand_origin.tcField.all():
+        c.key = "".join([demand_origin.key, '-', str(index)])
+        c.save()
+        index += 1
+    return case_key, case.key
+
+# 2.case复制到测试项中
+def case_copy_to_test(project_id: int, case_key: str, demand_key: str) -> Tuple[str, Any]:
+    # 初始化内容
+    project_qs = get_object_or_404(Project, id=project_id)
+    case = project_qs.pcField.filter(key=case_key).first()
+    demand = project_qs.ptField.filter(key=demand_key).first()
+    origin_case = deepcopy(case)
+    case.id = None
+    case.ident = demand.ident
+    case.test = demand
+    case.round = demand.round
+    case.dut = demand.dut
+    case.design = demand.design
+    case.key = "".join([demand.key, '-', str(demand.tcField.count())])
+    case.save()
+    # 用例步骤也要复制一份过去
+    for case_step in origin_case.step.all():
+        case_step.id = None
+        case_step.case = case
+        case_step.save()
+    return case_key, case.key
+
+# 3.（需要拆分）拖拽用例到用例的函数,TODO:必须拆分
+def case_to_case_copy_or_move(project_id: int, drag_key: str, drop_key: str, move: bool, position: int):
+    """待优化和上面一样：TODO:封装多个函数理清思路"""
+    project_qs = get_object_or_404(Project, id=project_id)
+    drag_case = project_qs.pcField.filter(key=drag_key).first()
+    drag_demand = drag_case.test
+    drop_case = project_qs.pcField.filter(key=drop_key).first()
+    drop_demand = drop_case.test
+    # 判断是否移动到同级
+    same_root_flag = False
+    if drag_key.split('-')[:-2] == drop_key.split('-')[:-2]:
+        same_root_flag = True
+    if move:
+        # 1.移动到同级demand - 只需要改变2个key
+        if same_root_flag:
+            case_list = list(drag_demand.tcField.all())  # 这是已经排序的
+            case_list.pop(case_list.index(drag_case))
+            # 移动出去后，查看现在drop_case索引
+            drop_case_index = case_list.index(drop_case)
+            if position == 0 or position == 1:  # 1和0就是往下放，首先drop的位置是不变的
+                case_list.insert(drop_case_index + 1, drag_case)
+            elif position == -1:
+                case_list.insert(drop_case_index, drag_case)
+            # 已经排序好了就开始修改key
+            ca_index = 0
+            for ca in case_list:
+                ca.key = "".join([drag_demand.key, '-', str(ca_index)])
+                ca.save()
+                ca_index += 1
+        # 2.移动到非同级demand
+        else:
+            drag_case.ident = drop_demand.ident
+            drag_case.test = drop_demand
+            drag_case.round = drop_demand.round
+            drag_case.dut = drop_demand.dut
+            drag_case.design = drop_demand.design
+            drag_case.save()  # 到这里drag_case已经放入了drop_demand
+            # 查询所有的drop_demand的所有用例
+            drop_case_list = list(drop_demand.tcField.all())
+            drop_case_list.pop(drop_case_list.index(drag_case))
+            drop_case_index = drop_case_list.index(drop_case)
+            if position == 0 or position == 1:  # 1和0就是往下放，首先drop的位置是不变的
+                drop_case_list.insert(drop_case_index + 1, drag_case)
+            elif position == -1:
+                drop_case_list.insert(drop_case_index, drag_case)
+            ca_ind = 0
+            for ca in drop_case_list:
+                ca.key = "".join([drop_demand.key, '-', str(ca_ind)])
+                ca.save()
+                ca_ind += 1
+            # 因为移动要删除之前demand的用例，所以需要重新设置key
+            index = 0
+            for c in drag_demand.tcField.all():
+                c.key = "".join([drag_demand.key, '-', str(index)])
+                c.save()
+                index += 1
+    # 如果是复制
+    else:
+        origin_drag_case = deepcopy(drag_case)  # 深度复制被拖拽的case
+        # 同一个测试项内用例的复制，还要看顺序
+        if same_root_flag:
+            drag_case.id = None
+            drag_case.save()
+            # 开始插入到被拖拽case上下
+            case_sx_list = list(drag_demand.tcField.all())
+            case_sx_list.pop(case_sx_list.index(drag_case))
+            drop_case_in = case_sx_list.index(drop_case)
+            if position == 0 or position == 1:  # 1和0就是往下放，首先drop的位置是不变的
+                case_sx_list.insert(drop_case_in + 1, drag_case)
+            elif position == -1:
+                case_sx_list.insert(drop_case_in, drag_case)
+            ind = 0
+            for cas in case_sx_list:
+                cas.key = "".join([drag_demand.key, '-', str(ind)])
+                cas.save()
+                ind += 1
+            # 根据origin复制步骤
+            for c_step in origin_drag_case.step.all():
+                c_step.id = None
+                c_step.case = drag_case  # 外键设置为新用例
+                c_step.save()
+        else:
+            drag_case.id = None
+            drag_case.ident = drop_demand.ident
+            drag_case.test = drop_demand
+            drag_case.round = drop_demand.round
+            drag_case.dut = drop_demand.dut
+            drag_case.design = drop_demand.design
+            drag_case.save()
+            cases_list = list(drop_demand.tcField.all())
+            cases_list.pop(cases_list.index(drag_case))
+            drop_case_idx = cases_list.index(drop_case)
+            if position == 0 or position == 1:  # 1和0就是往下放，首先drop的位置是不变的
+                cases_list.insert(drop_case_idx + 1, drag_case)
+            elif position == -1:
+                cases_list.insert(drop_case_idx, drag_case)
+            cas_idx = 0
+            for cas in cases_list:
+                cas.key = "".join([drop_demand.key, '-', str(cas_idx)])
+                cas.save()
+                cas_idx += 1
+            # 复制用例步骤
+            for cs_step in origin_drag_case.step.all():
+                cs_step.id = None
+                cs_step.case = drag_case  # 外键设置为新用例
+                cs_step.save()

apps/project/tools/copyDemand.py

@@ -0,0 +1,48 @@
+from copy import deepcopy
+from django.shortcuts import get_object_or_404
+from apps.project.models import Project
+
+def demand_copy_to_design(project_id: int, demand_key: str, design_id: int, depth: bool = False):
+    """注意传入项目id，测试项是key，设计需求是id"""
+    project_qs = get_object_or_404(Project, id=project_id)
+    design = project_qs.psField.filter(id=design_id).first()
+    demand = project_qs.ptField.filter(key=demand_key).first()
+    # 1.这里先要根据老的demand取出其步骤，并深度复制
+    origin_demand = deepcopy(demand)
+    demand.id = None
+    demand.title = '(复制)' + demand.title
+    demand.name = '(复制)' + demand.name
+    demand.dut = design.dut
+    demand.round = design.round
+    demand.design = design
+    demand.ident += '(复制)'
+    # 先查询目标design下面有多少个demand，然后key+1
+    demand.key = "".join([design.key, '-', str(design.dtField.count())])
+    demand.save()
+    for content_obj in origin_demand.testQField.all():
+        content_origin = deepcopy(content_obj)
+        content_obj.id = None
+        content_obj.testDemand = demand
+        content_obj.save()
+        for step_obj in content_origin.testStepField.all():
+            step_obj.testDemandContent = content_obj
+            step_obj.id = None
+            step_obj.save()
+    # 2.如果depth=True，则复制用例过去
+    if depth:
+        for case in origin_demand.tcField.all():
+            origin_case = deepcopy(case)
+            case.id = None
+            case.round = demand.round
+            case.dut = demand.dut
+            case.design = demand.design
+            case.test = demand
+            # 处理新case的key
+            case_key_lastkey = case.key.split("-")[-1]
+            case.key = "".join([demand.key, '-', case_key_lastkey])
+            case.save()
+            for case_step in origin_case.step.all():
+                case_step.id = None
+                case_step.case = case
+                case_step.save()
+    return demand.key

apps/project/tools/delete_change_key.py

@@ -0,0 +1,82 @@
+"""
+本模块主要解决删除父级节点后，其他同级节点的key会重排，重排后子节点没有重排问题
+"""
+from apps.project.models import Round, Dut, Design, TestDemand
+
+# 0.round删除后，重新排子节点
+def round_delete_sub_node_key(round: Round):
+    for dut in round.rdField.all():
+        remain_dut_key: str = dut.key.split('-')[-1]
+        dut_key_list = [round.key, remain_dut_key]
+        dut.key = '-'.join(dut_key_list)
+        dut.save()
+        for design in dut.rsField.all():
+            # 取出design的key最后一位，该位是正确的
+            remain_key: str = design.key.split('-')[-1]
+            key_list = dut.key.split('-')
+            key_list.append(remain_key)
+            design.key = "-".join(key_list)
+            design.save()
+            for demand in design.dtField.all():
+                remain_demand_key = demand.key.split('-')[-1]
+                demand_key_list = design.key.split('-')
+                demand_key_list.append(remain_demand_key)
+                demand.key = '-'.join(demand_key_list)
+                demand.save()
+                for case in demand.tcField.all():
+                    remain_case_key = case.key.split('-')[-1]
+                    case_key_list = demand.key.split('-')
+                    case_key_list.append(remain_case_key)
+                    case.key = '-'.join(case_key_list)
+                    case.save()
+
+# 1.dut删除后，重排同级子节点
+def dut_delete_sub_node_key(dut: Dut):
+    """
+    传入一个删除同级dut后，遍历的dut对象，这里dut的key已经正确，依据该key遍历子节点修改key
+    :param dut: dut对象
+    :return: None
+    """
+    for design in dut.rsField.all():
+        # 取出design的key最后一位，该位是正确的
+        remain_key: str = design.key.split('-')[-1]
+        key_list = dut.key.split('-')
+        key_list.append(remain_key)
+        design.key = "-".join(key_list)
+        design.save()
+        for demand in design.dtField.all():
+            remain_demand_key = demand.key.split('-')[-1]
+            demand_key_list = design.key.split('-')
+            demand_key_list.append(remain_demand_key)
+            demand.key = '-'.join(demand_key_list)
+            demand.save()
+            for case in demand.tcField.all():
+                remain_case_key = case.key.split('-')[-1]
+                case_key_list = demand.key.split('-')
+                case_key_list.append(remain_case_key)
+                case.key = '-'.join(case_key_list)
+                case.save()
+
+# 2.design删除后，重排同级子节点
+def design_delete_sub_node_key(design: Design):
+    for demand in design.dtField.all():
+        remain_demand_key = demand.key.split('-')[-1]
+        demand_key_list = design.key.split('-')
+        demand_key_list.append(remain_demand_key)
+        demand.key = '-'.join(demand_key_list)
+        demand.save()
+        for case in demand.tcField.all():
+            remain_case_key = case.key.split('-')[-1]
+            case_key_list = demand.key.split('-')
+            case_key_list.append(remain_case_key)
+            case.key = '-'.join(case_key_list)
+            case.save()
+
+# 3.demand删除后，重排case的key顺序
+def demand_delete_sub_node_key(demand: TestDemand):
+    for case in demand.tcField.all():
+        remain_case_key = case.key.split('-')[-1]
+        case_key_list = demand.key.split('-')
+        case_key_list.append(remain_case_key)
+        case.key = '-'.join(case_key_list)
+        case.save()

apps/project/tools/keyTools.py

@@ -0,0 +1,342 @@
+"""该模块：选择节点新创建一个轮次，数据为选中节点"""
+import re
+from copy import deepcopy
+from apps.project.models import Project, Round, Dut, Design, TestDemand, Case
+
+class TreeKey(object):
+    """生成一个dict，展示复制的节点tree_dict是解析后的属性名称"""
+    """递归写法：
+            def slide(key_list):
+            tree_dict = {}
+            for key in key_list:
+                split_list = key.split('-', 1)
+                if split_list[0] not in tree_dict:
+                    tree_dict[split_list[0]] = []
+                    if len(split_list) > 1:
+                        tree_dict[split_list[0]].append(split_list[1])
+                    else:
+                        tree_dict[split_list[0]] = 'all'
+                else:
+                    if isinstance(tree_dict[split_list[0]], list):
+                        if len(split_list) > 1:
+                            tree_dict[split_list[0]].append(split_list[1])
+                        else:
+                            tree_dict[split_list[0]] = 'all'
+        
+            for k, v in tree_dict.items():
+                if isinstance(v, list):
+                    tree_dict[k] = slide(v)
+            return tree_dict
+        
+        key_l = ['0-1-1-0', '0-1-2-1', '0-2-0-1']
+        print(slide(key_l))
+    """
+
+    def __init__(self, key_list):
+        self.tree_dict = {}
+        if key_list is None:
+            self.key_list = []
+            return
+        self.key_list = deepcopy(key_list)
+        res_dict = self.list_dict(self.key_list)
+        for k, v in res_dict.items():
+            if isinstance(v, list):
+                res_dict[k] = self.list_dict(v)
+                for k1, v1 in res_dict[k].items():
+                    if isinstance(v1, list):
+                        res_dict[k][k1] = self.list_dict(v1)
+                        for k2, v2 in res_dict[k][k1].items():
+                            if isinstance(v2, list):
+                                res_dict[k][k1][k2] = self.list_dict(v2)
+                                for k3, v3 in res_dict[k][k1][k2].items():
+                                    if isinstance(v3, list):
+                                        res_dict[k][k1][k2][k3] = self.list_dict(v3)
+        self.tree_dict = res_dict
+
+    def list_dict(self, key_list) -> dict:
+        tree_dict = {}
+        for key in key_list:
+            split_list = key.split('-', 1)
+            if len(split_list) == 1:
+                tree_dict[split_list[0]] = 'all'
+            else:
+                if split_list[0] not in tree_dict:
+                    tree_dict[split_list[0]] = []
+                if isinstance(tree_dict[split_list[0]], list):
+                    tree_dict[split_list[0]].append(split_list[1])
+        return tree_dict
+
+    def copy_tree(self, round_count: int, project_obj: Project):
+        for round_k, round_v in self.tree_dict.items():
+            # 1.这是轮次层级，如果为'all'，则复制整个轮次到第二轮
+            if round_v == 'all':
+                round_obj: Round = Round.objects.filter(key=round_k, project=project_obj).first()
+                round_obj.remark = f"第{round_count + 1}轮测试"
+                round_obj.ident = round_obj.ident.replace(round_obj.ident[-1], f'{round_count + 1}')
+                round_obj.name = f"第{round_count + 1}轮测试"
+                round_obj.title = f"第{round_count + 1}轮测试"
+                round_obj.key = f"{round_count}"
+                round_obj.id = None
+                round_obj.save()
+                round_origin: Round = Round.objects.filter(key=round_k, project=project_obj).first()
+                dut_qs = round_origin.rdField.all()
+                for dut in dut_qs:
+                    dut_origin = deepcopy(dut)
+                    dut.ident = re.sub(r"-R\d+-", f'-R{round_count + 1}-', dut.ident)
+                    dut.key = f"{round_count}-{dut.key.split('-')[-1]}"
+                    dut.round = round_obj
+                    dut.id = None
+                    dut.save()
+                    design_qs = dut_origin.rsField.all()
+                    for i, design in enumerate(design_qs):
+                        design_origin = deepcopy(design)
+                        design.key = dut.key + f"-{i}"
+                        design.dut = dut
+                        design.round = round_obj
+                        design.id = None
+                        design.save()
+                        demand_qs = design_origin.dtField.all()
+                        for j, demand in enumerate(demand_qs):
+                            demand_origin = deepcopy(demand)
+                            # 需要将demand_item也复制一份
+                            demand.key = design.key + f"-{j}"
+                            demand.design = design
+                            demand.dut = dut
+                            demand.round = round_obj
+                            demand.id = None
+                            demand.save()
+                            for content_obj in demand_origin.testQField.all():
+                                content_origin = deepcopy(content_obj)
+                                content_obj.testDemand = demand
+                                content_obj.id = None
+                                content_obj.save()
+                                # 需要将DemandContentStep也要复制一份
+                                for step_obj in content_origin.testStepField.all():
+                                    step_obj.testDemandContent = content_obj
+                                    step_obj.id = None
+                                    step_obj.save()
+                            case_qs = demand_origin.tcField.all()
+                            for k, case in enumerate(case_qs):
+                                case_origin = deepcopy(case)
+                                case.key = demand.key + f"-{k}"
+                                case.test = demand
+                                case.design = design
+                                case.dut = dut
+                                case.round = round_obj
+                                case.id = None
+                                case.save()
+                                for step_obj in case_origin.step.all():
+                                    step_obj.case = case
+                                    step_obj.id = None
+                                    step_obj.save()
+            # 2.如果不是all，下面有值
+            if isinstance(round_v, dict):
+                # 2.1 如果字典，则先要创建轮次
+                round_obj: Round = Round.objects.filter(key=round_k, project=project_obj).first()
+                round_obj.remark = f"第{round_count + 1}轮测试"
+                round_obj.ident = round_obj.ident.replace(round_obj.ident[-1], f'{round_count + 1}')
+                round_obj.name = f"第{round_count + 1}轮测试"
+                round_obj.title = f"第{round_count + 1}轮测试"
+                round_obj.key = f"{round_count}"
+                round_obj.id = None
+                round_obj.save()
+                dut_index = 1
+                for dut_k, dut_v in round_v.items():
+                    # 2.1 如果dut_v是all，那么从该dut整体复制
+                    dut_key_origin = round_k + "-" + dut_k
+                    if dut_v == 'all':
+                        # 查询原始dut
+                        dut_obj = Dut.objects.filter(key=dut_key_origin, project=project_obj).first()
+                        dut_obj.ident = dut_obj.ident[:11] + str(dut_index)
+                        dut_obj.ident = re.sub(r"-R\d+-", f'-R{round_count + 1}-', dut_obj.ident)
+                        dut_obj.key = f"{round_count}-{dut_index - 1}"
+                        dut_obj.round = round_obj
+                        dut_obj.id = None
+                        dut_obj.save()
+                        dut_origin = Dut.objects.filter(key=dut_key_origin, project=project_obj).first()
+                        design_qs = dut_origin.rsField.all()
+                        for i, design in enumerate(design_qs):
+                            design_origin = deepcopy(design)
+                            design.key = dut_obj.key + f"-{i}"
+                            design.dut = dut_obj
+                            design.round = round_obj
+                            design.id = None
+                            design.save()
+                            demand_qs = design_origin.dtField.all()
+                            for j, demand in enumerate(demand_qs):
+                                demand_origin = deepcopy(demand)
+                                # 需要将demand_item也复制一份
+                                demand.key = design.key + f"-{j}"
+                                demand.design = design
+                                demand.dut = dut_obj
+                                demand.round = round_obj
+                                demand.id = None
+                                demand.save()
+                                for content_obj in demand_origin.testQField.all():
+                                    content_origin = deepcopy(content_obj)
+                                    content_obj.testDemand = demand
+                                    content_obj.id = None
+                                    content_obj.save()
+                                    # 需要将DemandContentStep也要复制一份
+                                    for step_obj in content_origin.testStepField.all():
+                                        step_obj.testDemandContent = content_obj
+                                        step_obj.id = None
+                                        step_obj.save()
+                                case_qs = demand_origin.tcField.all()
+                                for k, case in enumerate(case_qs):
+                                    case_origin = deepcopy(case)
+                                    case.key = demand.key + f"-{k}"
+                                    case.test = demand
+                                    case.design = design
+                                    case.dut = dut_obj
+                                    case.round = round_obj
+                                    case.id = None
+                                    case.save()
+                                    for step_obj in case_origin.step.all():
+                                        step_obj.case = case
+                                        step_obj.id = None
+                                        step_obj.save()
+
+                    if isinstance(dut_v, dict):
+                        dut_obj = Dut.objects.filter(key=dut_key_origin, project=project_obj).first()
+                        dut_obj.ident = dut_obj.ident[:11] + str(dut_index)
+                        dut_obj.ident = re.sub(r"-R\d+-", f'-R{round_count + 1}-', dut_obj.ident)
+                        dut_obj.key = f"{round_count}-{dut_index - 1}"
+                        dut_obj.round = round_obj
+                        dut_obj.id = None
+                        dut_obj.save()
+                        design_index = 1
+                        for design_k, design_v in dut_v.items():
+                            design_key_origin = round_k + "-" + dut_k + "-" + design_k
+                            if design_v == 'all':
+                                design_obj = Design.objects.filter(key=design_key_origin, project=project_obj).first()
+                                design_obj.key = f"{dut_obj.key}-{design_index - 1}"
+                                design_obj.dut = dut_obj
+                                design_obj.round = round_obj
+                                design_obj.id = None
+                                design_obj.save()
+                                design_origin = Design.objects.filter(key=design_key_origin,
+                                                                      project=project_obj).first()
+                                demand_qs = design_origin.dtField.all()
+                                for j, demand in enumerate(demand_qs):
+                                    demand_origin = deepcopy(demand)
+                                    # 需要将demand_item也复制一份
+                                    demand.key = design_obj.key + f"-{j}"
+                                    demand.design = design_obj
+                                    demand.dut = dut_obj
+                                    demand.round = round_obj
+                                    demand.id = None
+                                    demand.save()
+                                    for content_obj in demand_origin.testQField.all():
+                                        content_origin = deepcopy(content_obj)
+                                        content_obj.testDemand = demand
+                                        content_obj.id = None
+                                        content_obj.save()
+                                        for step_obj in content_origin.testStepField.all():
+                                            step_obj.testDemandContent = content_obj
+                                            step_obj.id = None
+                                            step_obj.save()
+                                    case_qs = demand_origin.tcField.all()
+                                    for k, case in enumerate(case_qs):
+                                        case_origin = deepcopy(case)
+                                        case.key = demand.key + f"-{k}"
+                                        case.test = demand
+                                        case.design = design_obj
+                                        case.dut = dut_obj
+                                        case.round = round_obj
+                                        case.id = None
+                                        case.save()
+                                        for step_obj in case_origin.step.all():
+                                            step_obj.case = case
+                                            step_obj.id = None
+                                            step_obj.save()
+
+                            if isinstance(design_v, dict):
+                                design_obj = Design.objects.filter(key=design_key_origin, project=project_obj).first()
+                                design_obj.key = f"{round_count}-{dut_index - 1}-{design_index - 1}"
+                                design_obj.dut = dut_obj
+                                design_obj.round = round_obj
+                                design_obj.id = None
+                                design_obj.save()
+                                demand_index = 1
+                                for demand_k, demand_v in design_v.items():
+                                    demand_key_origin = round_k + "-" + dut_k + "-" + design_k + "-" + demand_k
+                                    if demand_v == 'all':
+                                        demand_obj = TestDemand.objects.filter(key=demand_key_origin,
+                                                                               project=project_obj).first()
+                                        demand_obj.key = f"{design_obj.key}-{demand_index - 1}"
+                                        demand_obj.design = design_obj
+                                        demand_obj.dut = dut_obj
+                                        demand_obj.round = round_obj
+                                        demand_obj.id = None
+                                        demand_obj.save()
+                                        demand_origin = TestDemand.objects.filter(key=demand_key_origin,
+                                                                                  project=project_obj).first()
+                                        for content_obj in demand_origin.testQField.all():
+                                            content_origin = deepcopy(content_obj)
+                                            content_obj.testDemand = demand_obj
+                                            content_obj.id = None
+                                            content_obj.save()
+                                            for step_obj in content_origin.testStepField.all():
+                                                step_obj.testDemandContent = content_obj
+                                                step_obj.id = None
+                                                step_obj.save()
+                                        case_qs = demand_origin.tcField.all()
+                                        for k, case in enumerate(case_qs):
+                                            case_origin = deepcopy(case)
+                                            case.key = demand_obj.key + f"-{k}"
+                                            case.test = demand_obj
+                                            case.design = design_obj
+                                            case.dut = dut_obj
+                                            case.round = round_obj
+                                            case.id = None
+                                            case.save()
+                                            for step_obj in case_origin.step.all():
+                                                step_obj.case = case
+                                                step_obj.id = None
+                                                step_obj.save()
+
+                                    if isinstance(demand_v, dict):
+                                        demand_obj = TestDemand.objects.filter(key=demand_key_origin,
+                                                                               project=project_obj).first()
+                                        demand_obj.key = f"{round_count}-{dut_index - 1}-{design_index - 1}-{demand_index - 1}"
+                                        demand_obj.design = design_obj
+                                        demand_obj.dut = dut_obj
+                                        demand_obj.round = round_obj
+                                        demand_obj.id = None
+                                        demand_obj.save()
+                                        demand_origin = TestDemand.objects.filter(key=demand_key_origin,
+                                                                                  project=project_obj).first()
+                                        for content_obj in demand_origin.testQField.all():
+                                            content_origin = deepcopy(content_obj)
+                                            content_obj.testDemand = demand_obj
+                                            content_obj.id = None
+                                            content_obj.save()
+                                            for step_obj in content_origin.testStepField.all():
+                                                step_obj.testDemandContent = content_obj
+                                                step_obj.id = None
+                                                step_obj.save()
+                                        case_index = 1
+                                        for case_k, case_v in demand_v.items():
+                                            case_key_origin = round_k + "-" + dut_k + "-" + design_k + "-" + demand_k + "-" + case_k
+                                            if case_v == 'all':
+                                                case_obj = Case.objects.filter(key=case_key_origin,
+                                                                               project=project_obj).first()
+                                                case_obj.key = f"{demand_obj.key}-{case_index}"
+                                                case_obj.test = demand_obj
+                                                case_obj.dut = dut_obj
+                                                case_obj.design = design_obj
+                                                case_obj.round = round_obj
+                                                case_obj.id = None
+                                                case_obj.save()
+                                                case_origin = Case.objects.filter(key=case_key_origin,
+                                                                                  project=project_obj).first()
+                                                for step_obj in case_origin.step.all():
+                                                    step_obj.case = case_obj
+                                                    step_obj.id = None
+                                                    step_obj.save()
+
+                                            case_index += 1
+                                    demand_index += 1
+                            design_index += 1
+                    dut_index += 1