733 lines
36 KiB
Python
733 lines
36 KiB
Python
from datetime import date, timedelta
|
||
from pathlib import Path
|
||
from ninja_extra import api_controller, ControllerBase, route
|
||
from django.db import transaction
|
||
from django.shortcuts import get_object_or_404
|
||
from django.db.models import Q, QuerySet
|
||
from docxtpl import DocxTemplate
|
||
from typing import Optional
|
||
from docx import Document
|
||
from ninja_extra.permissions import IsAuthenticated
|
||
from ninja_jwt.authentication import JWTAuth
|
||
# 导入模型
|
||
from apps.project.models import Project, Dut, TestDemand, Problem
|
||
# 工具类函数
|
||
from apps.createDocument.extensions import util
|
||
from utils.chen_response import ChenResponse
|
||
from apps.createDocument.extensions.util import create_bg_docx, get_round1_problem
|
||
from utils.util import get_str_dict, get_list_dict, create_problem_grade_str, create_str_testType_list, \
|
||
create_demand_summary, create_problem_type_str, create_problem_table, create_problem_type_table, \
|
||
get_str_abbr
|
||
# 根据轮次生成测评内容文档context
|
||
from apps.createDocument.extensions.content_result_tool import create_round_context
|
||
from apps.createDocument.extensions.zhui import create_bg_round1_zhui
|
||
from apps.createDocument.extensions.solve_problem import create_one_problem_dit
|
||
from utils.path_utils import project_path
|
||
from apps.createDocument.extensions.util import delete_dir_files
|
||
from apps.createDocument.extensions.parse_rich_text import RichParser
|
||
from apps.createDocument.extensions.documentTime import DocTime
|
||
# 导入生成日志记录模块
|
||
from apps.createSeiTaiDocument.extensions.logger import GenerateLogger
|
||
|
||
# @api_controller("/generateBG", tags=['生成报告文档系列'], auth=JWTAuth(), permissions=[IsAuthenticated])
|
||
@api_controller("/generateBG", tags=['生成报告文档系列'])
|
||
class GenerateControllerBG(ControllerBase):
|
||
logger = GenerateLogger('测评报告')
|
||
|
||
# important：删除之前的文件
|
||
@route.get('/create/deleteBGDocument', url_name='delete-bg-document')
|
||
def delete_bg_document(self, id: int):
|
||
project_path_str = project_path(id)
|
||
save_path = Path.cwd() / 'media' / project_path_str / 'output_dir/bg'
|
||
delete_dir_files(save_path)
|
||
|
||
@route.get("/create/techyiju", url_name="create-techyiju")
|
||
@transaction.atomic
|
||
def create_techyiju(self, id: int):
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
duties_qs = project_obj.pdField.filter(Q(type='XQ') | Q(type='SJ') | Q(type='XY'))
|
||
std_documents = []
|
||
for duty in duties_qs:
|
||
one_duty = {'doc_name': duty.name, 'ident_version': duty.ref + '-' + duty.version,
|
||
'publish_date': duty.release_date, 'source': duty.release_union}
|
||
std_documents.append(one_duty)
|
||
# 添加大纲到这里
|
||
## 判断是否为鉴定
|
||
doc_name = f'{project_obj.name}软件测评大纲'
|
||
if project_obj.report_type == '9':
|
||
doc_name = f'{project_obj.name}软件鉴定测评大纲'
|
||
# 时间控制类
|
||
timer = DocTime(id)
|
||
# 这里大纲版本升级如何处理
|
||
dg_duty = {'doc_name': doc_name, 'ident_version': f'PT-{project_obj.ident}-TO-1.00',
|
||
'publish_date': timer.dg_cover_time, 'source': project_obj.test_unit}
|
||
std_documents.append(dg_duty)
|
||
# 需要添加说明、记录
|
||
sm_duty = {'doc_name': f'{project_obj.name}软件测试说明',
|
||
'ident_version': f'PT-{project_obj.ident}-TD-1.00',
|
||
'publish_date': timer.sm_cover_time, 'source': project_obj.test_unit}
|
||
jl_duty = {'doc_name': f'{project_obj.name}软件测试记录',
|
||
'ident_version': f'PT-{project_obj.ident}-TN',
|
||
'publish_date': timer.jl_cover_time, 'source': project_obj.test_unit}
|
||
# 循环所有轮次，除了第一轮
|
||
std_documents.extend([sm_duty, jl_duty])
|
||
rounds = project_obj.pField.exclude(key='0')
|
||
name_list = ['一', '二', '三', '四', '五', '六', '七', '八', '九', '十']
|
||
index = 1
|
||
for r in rounds:
|
||
hsm_duty = {'doc_name': f'{project_obj.name}软件第{name_list[index]}轮测试说明',
|
||
'ident_version': f'PT-{project_obj.ident}-TD{str(index + 1)}-1.00',
|
||
'publish_date': r.beginTime, 'source': project_obj.test_unit}
|
||
hjl_duty = {'doc_name': f'{project_obj.name}软件第{name_list[index]}轮测试记录',
|
||
'ident_version': f'PT-{project_obj.ident}-TN{str(index + 1)}',
|
||
'publish_date': r.endTime, 'source': project_obj.test_unit}
|
||
std_documents.extend([hsm_duty, hjl_duty])
|
||
index += 1
|
||
# 生成二级文档
|
||
context = {
|
||
'std_documents': std_documents
|
||
}
|
||
return create_bg_docx("技术依据文件.docx", context, id)
|
||
|
||
# 测评地点和时间接口
|
||
@route.get('/create/timeaddress')
|
||
@transaction.atomic
|
||
def create_timeaddress(self, id: int):
|
||
timer = DocTime(id)
|
||
context = timer.bg_address_time()
|
||
return create_bg_docx('测评时间和地点.docx', context, id)
|
||
|
||
# 在报告生成多个版本被测软件基本信息
|
||
@route.get('/create/baseInformation', url_name='create-baseInformation')
|
||
def create_information(self, id: int):
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
languages = get_list_dict('language', project_obj.language)
|
||
language_list = []
|
||
for language in languages:
|
||
language_list.append(language.get('ident_version'))
|
||
|
||
# 获取轮次
|
||
rounds = project_obj.pField.all()
|
||
round_list = []
|
||
for r in rounds:
|
||
round_dict = {}
|
||
# 获取SO的dut
|
||
so_dut: Dut = r.rdField.filter(type='SO').first()
|
||
if so_dut:
|
||
round_dict['version'] = so_dut.version
|
||
round_dict['line_count'] = int(so_dut.total_lines)
|
||
round_dict['effective_line'] = int(so_dut.effective_lines)
|
||
round_list.append(round_dict)
|
||
|
||
context = {
|
||
'project_name': project_obj.name,
|
||
'soft_type': project_obj.get_soft_type_display(),
|
||
'security_level': get_str_dict(project_obj.security_level, 'security_level'),
|
||
'runtime': get_str_dict(project_obj.runtime, 'runtime'),
|
||
'devplant': get_str_dict(project_obj.devplant, 'devplant'),
|
||
'language': "\a".join(language_list),
|
||
'recv_date': project_obj.beginTime.strftime("%Y-%m-%d"),
|
||
'dev_unit': project_obj.dev_unit,
|
||
'version_info': round_list
|
||
}
|
||
return create_bg_docx('被测软件基本信息.docx', context, id)
|
||
|
||
# 生成测评完成情况
|
||
@route.get('/create/completionstatus', url_name='create-completionstatus')
|
||
def create_completionstatus(self, id: int):
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
# 找到第一轮轮次对象、第二轮轮次对象
|
||
round1 = project_obj.pField.filter(key='0').first()
|
||
# 第一轮测试项个数
|
||
round1_demand_qs = round1.rtField.all()
|
||
# 第一轮用例个数
|
||
round1_case_qs = round1.rcField.all()
|
||
# 这部分找出第一轮的所有测试类型，输出字符串，并排序
|
||
test_type_set: set = set()
|
||
for case in round1_case_qs:
|
||
demand: TestDemand = case.test
|
||
test_type_set.add(demand.testType)
|
||
round1_testType_list = list(
|
||
map(lambda x: x['ident_version'], get_list_dict('testType', list(test_type_set))))
|
||
# 这里找出第一轮，源代码被测件，并获取版本
|
||
so_dut = round1.rdField.filter(type='SO').first()
|
||
so_dut_verson = "$请添加第一轮的源代码信息$"
|
||
if so_dut:
|
||
so_dut_verson = so_dut.version
|
||
# 这里找出除第一轮的其他轮次
|
||
rounds = project_obj.pField.exclude(key='0')
|
||
rounds_str_chinese = ['一', '二', '三', '四', '五', '六', '七', '八', '九', '十']
|
||
round_list = []
|
||
for r in rounds:
|
||
# 找所属dut的so-dut
|
||
so_dut = r.rdField.filter(type='SO').first()
|
||
# 找出上一轮dut的so-dut
|
||
last_problem_count = Problem.objects.filter(
|
||
case__round__key=str(int(r.key) - 1)).distinct().count()
|
||
current_round_problem_count = Problem.objects.filter(case__round__key=r.key).distinct().count()
|
||
if current_round_problem_count > 0:
|
||
current_round_description = f'引入新问题{current_round_problem_count}个'
|
||
else:
|
||
current_round_description = '经测试软件更改正确，并且未引入新的问题'
|
||
r_dict = {
|
||
'version': so_dut.version if so_dut else '$请添加该轮次源代码信息$',
|
||
'round_index': rounds_str_chinese[int(r.key)],
|
||
'last_problem_count': last_problem_count,
|
||
'current_round_description': current_round_description,
|
||
'start_year': r.beginTime.year,
|
||
'start_month': r.beginTime.month,
|
||
'end_year': (r.beginTime + timedelta(days=4)).year, # 这里只是简单+4有待商榷
|
||
'end_month': (r.beginTime + timedelta(days=4)).month,
|
||
}
|
||
round_list.append(r_dict)
|
||
|
||
# 这部分找到第一轮的问题
|
||
problem_qs = get_round1_problem(project_obj)
|
||
context = {
|
||
'is_JD': True if project_obj.report_type == '9' else False,
|
||
'project_name': project_obj.name,
|
||
'start_time_year': project_obj.beginTime.year,
|
||
'start_time_month': project_obj.beginTime.month,
|
||
'round1_case_count': round1_case_qs.count(),
|
||
'round1_demand_count': round1_demand_qs.count(),
|
||
'round1_testType_str': '、'.join(round1_testType_list),
|
||
'testType_count': len(round1_testType_list),
|
||
'round1_version': so_dut_verson,
|
||
'round1_problem_count': len(problem_qs),
|
||
'end_time_year': date.today().year,
|
||
'end_time_month': date.today().month,
|
||
'round_list': round_list
|
||
}
|
||
# 注入时间
|
||
timer = DocTime(id)
|
||
context.update(**timer.bg_completion_situation())
|
||
return create_bg_docx('测评完成情况.docx', context, id)
|
||
|
||
# 生成综述
|
||
@route.get('/create/summary', url_name='create-summary')
|
||
def create_summary(self, id: int):
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
# 找出所有问题单
|
||
problem_qs = project_obj.projField.all()
|
||
problem_grade_dict = {}
|
||
problem_type_dict = {}
|
||
# 建议问题统计
|
||
problem_suggest_count = 0
|
||
problem_suggest_solved_count = 0
|
||
for problem in problem_qs:
|
||
grade_key: str = get_str_dict(problem.grade, 'problemGrade')
|
||
type_key: str = get_str_dict(problem.type, 'problemType')
|
||
# 问题等级字典-计数
|
||
if grade_key in problem_grade_dict.keys():
|
||
problem_grade_dict[grade_key] += 1
|
||
else:
|
||
problem_grade_dict[grade_key] = 1
|
||
# 问题类型字典-计数
|
||
if type_key in problem_type_dict.keys():
|
||
problem_type_dict[type_key] += 1
|
||
else:
|
||
problem_type_dict[type_key] = 1
|
||
# 建议问题统计
|
||
if problem.grade == '3':
|
||
problem_suggest_count += 1
|
||
if problem.status == '1':
|
||
problem_suggest_solved_count += 1
|
||
problem_grade_list = []
|
||
problem_type_list = []
|
||
for key, value in problem_grade_dict.items():
|
||
problem_grade_list.append("".join([f"{key}问题", f"{value}个"]))
|
||
for key, value in problem_type_dict.items():
|
||
problem_type_list.append("".join([f"{key}", f"{value}个"]))
|
||
# 用来生成建议问题信息
|
||
if problem_suggest_count > 0 and problem_suggest_count - problem_suggest_solved_count > 0:
|
||
all_str = (f"测评过程中提出了{problem_suggest_count}个建议改进，"
|
||
f"其中{problem_suggest_solved_count}个建议改进已修改，"
|
||
f"剩余{problem_suggest_count - problem_suggest_solved_count}个未修改并经总体单位认可同意")
|
||
elif problem_suggest_count > 0 and problem_suggest_count - problem_suggest_solved_count == 0:
|
||
all_str = (f"测评过程中提出了{problem_suggest_count}个建议改进，"
|
||
f"全部建议问题已修改")
|
||
else:
|
||
all_str = f"测评过程中未提出建议项。"
|
||
|
||
context = {
|
||
'problem_count': problem_qs.count(),
|
||
'problem_grade_str': "、".join(problem_grade_list),
|
||
'problem_type_str': '、'.join(problem_type_list),
|
||
'all_str': all_str,
|
||
}
|
||
return create_bg_docx('综述.docx', context, id)
|
||
|
||
# 生成测试内容和结果[报告非常关键的一环-大模块]
|
||
@route.get('/create/contentandresults_1', url_name='create-contentandresults_1')
|
||
@transaction.atomic
|
||
def create_content_results_1(self, id: int):
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
project_ident = project_obj.ident
|
||
# ~~~~首轮信息~~~~
|
||
round1 = project_obj.pField.filter(key='0').first() # !warning轮次1对象
|
||
|
||
# 1.处理首轮文档名称，新修改，这里取全部轮次的文档内容
|
||
doc_list = []
|
||
round1_duts = project_obj.pdField.filter(Q(type='SJ') | Q(type='XQ') | Q(type='XY'))
|
||
index = 1
|
||
for dut in round1_duts:
|
||
dut_dict = {
|
||
'name': dut.name,
|
||
'ident': dut.ref,
|
||
'version': dut.version,
|
||
'index': index
|
||
}
|
||
doc_list.append(dut_dict)
|
||
index += 1
|
||
|
||
# 2.处理首轮文档问题的统计 - 注意去重
|
||
problems = project_obj.projField.all().distinct() # !important:大变量-项目所有问题
|
||
problems_r1 = problems.filter(case__round__key='0') # !important:大变量-首轮的所有问题
|
||
problems_doc_r1 = problems_r1.filter(case__test__testType='8') # 第一轮所有文档问题
|
||
|
||
# 3.第一轮代码审查问题统计/版本
|
||
source_r1_dut = round1.rdField.filter(type='SO').first() # !warning:小变量-第一轮源代码对象
|
||
program_r1_problems = problems_r1.filter(case__test__testType='2')
|
||
|
||
# 4.第一轮代码走查问题统计/版本
|
||
zou_r1_problems = problems_r1.filter(case__test__testType='3')
|
||
# 找下是否存在代码走查测试项
|
||
r1_demand_qs = round1.rtField.filter(testType='3')
|
||
has_zou = True if r1_demand_qs.count() > 0 else False
|
||
|
||
# 5.第一轮静态分析问题统计
|
||
static_problems = problems_r1.filter(case__test__testType='15')
|
||
|
||
# 6.第一轮动态测试用例个数(动态测试-非静态分析、文档审查、代码审查、代码走查4个)
|
||
case_r1_qs = round1.rcField.filter(~Q(test__testType='2'), ~Q(test__testType='3'),
|
||
~Q(test__testType='8'),
|
||
~Q(test__testType='15'),
|
||
round__key='0') # !warning:中变量-第一轮动态测试用例qs
|
||
testType_list, testType_count = create_str_testType_list(case_r1_qs)
|
||
## 动态测试(第一轮)各个类型测试用例执行表/各个测试需求表
|
||
demand_r1_dynamic_qs = round1.rtField.filter(~Q(testType='2'), ~Q(testType='3'), ~Q(testType='8'),
|
||
~Q(testType='15')) # !warning:中变量:第一轮动态测试的测试项
|
||
summary_r1_demand_info, summry_r1_demandType_info = create_demand_summary(demand_r1_dynamic_qs,
|
||
project_ident)
|
||
|
||
# N.第一轮所有动态问题统计
|
||
problems_dynamic_r1 = problems_r1.filter(~Q(case__test__testType='2'), ~Q(case__test__testType='3'),
|
||
~Q(case__test__testType='8'),
|
||
~Q(case__test__testType='15')) # !critical:大变量:第一轮动态问题单qs
|
||
problem_dynamic_r1_type_str = create_problem_type_str(problems_dynamic_r1)
|
||
problem_dynamic_r1_grade_str = create_problem_grade_str(problems_dynamic_r1)
|
||
|
||
context = {
|
||
'project_name': project_obj.name,
|
||
'doc_list': doc_list,
|
||
'r1_doc_problem_count': problems_doc_r1.count(),
|
||
'r1_doc_problem_str':
|
||
f"{'，其中' + create_problem_grade_str(problems_doc_r1) if problems_doc_r1.count() > 0 else '即未发现问题'}",
|
||
'r1_version': source_r1_dut.version if source_r1_dut else "未录入首轮版本信息",
|
||
'r1_program_problem_count': program_r1_problems.count(),
|
||
'r1_program_problem_str':
|
||
f'{"，其中" + create_problem_grade_str(program_r1_problems) if program_r1_problems.count() > 0 else "即未发现问题"}',
|
||
'r1_zou_problem_count': zou_r1_problems.count(),
|
||
'r1_zou_problem_str': f'{"，其中" + create_problem_grade_str(zou_r1_problems) if zou_r1_problems.count() > 0 else "即未发现问题"}',
|
||
'has_zou': has_zou,
|
||
'r1_static_problem_count': static_problems.count(),
|
||
'r1_static_problem_str': f"{'，其中' + create_problem_grade_str(static_problems) if static_problems.count() > 0 else '即未发现问题'}",
|
||
'r1_case_count': case_r1_qs.count(),
|
||
'r1_case_testType': "、".join(testType_list),
|
||
'r1_case_testType_count': testType_count,
|
||
'r1_problem_counts': len(problems_dynamic_r1),
|
||
'r1_exe_info_all': summary_r1_demand_info,
|
||
'r1_exe_info_type': summry_r1_demandType_info,
|
||
'r1_dynamic_problem_str': problem_dynamic_r1_type_str,
|
||
'r1_dynamic_problem_grade_str': problem_dynamic_r1_grade_str,
|
||
}
|
||
return create_bg_docx("测试内容和结果_第一轮次.docx", context, id)
|
||
|
||
# 查询除第一轮以外，生成其他轮次测试内容和结果
|
||
@route.get('/create/contentandresults_2', url_name='create-contentandresults_2')
|
||
@transaction.atomic
|
||
def create_content_results_2(self, id: int):
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
# 查询除第一轮，其他有几轮
|
||
round_qs = project_obj.pField.filter(~Q(key='0'))
|
||
round_str_list = [item.key for item in round_qs]
|
||
# 每个轮次都需要生成一个测试内容和标题
|
||
project_path_str = project_path(id)
|
||
for round_str in round_str_list:
|
||
context = create_round_context(project_obj, round_str)
|
||
template_path = Path.cwd() / 'media' / project_path_str / 'form_template' / 'bg' / '测试内容和结果_第二轮次.docx'
|
||
doc = DocxTemplate(template_path)
|
||
doc.render(context)
|
||
try:
|
||
doc.save(
|
||
Path.cwd() / "media" / project_path_str / "output_dir/bg" / f"测试内容和结果_第{context['round_id']}轮次.docx")
|
||
except PermissionError:
|
||
ChenResponse(code=400, status=400, message='您已打开生成文件，请关闭后再试...')
|
||
|
||
# 软件问题统计
|
||
@route.get('/create/problem_statistics')
|
||
@transaction.atomic
|
||
def create_problem_statistics(self, id: int):
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
problems = project_obj.projField.all().distinct() # 项目所有问题单
|
||
context = {
|
||
'closed_count': problems.filter(status='1').count(),
|
||
'noclosed_count': problems.count() - problems.filter(status='1').count(),
|
||
'problem_table': create_problem_table(problems),
|
||
'problem_table_2': create_problem_type_table(problems)
|
||
}
|
||
return create_bg_docx("软件问题统计.docx", context, id)
|
||
|
||
# 测试有效性充分性说明
|
||
@route.get('/create/effect_and_adquacy', url_name='create-effect_and_adquacy')
|
||
@transaction.atomic
|
||
def create_effect_and_adquacy(self, id: int):
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
# 判断是否为鉴定
|
||
is_JD = False
|
||
if project_obj.report_type == '9':
|
||
is_JD = True
|
||
# 统计测试项数量
|
||
demand_qs = project_obj.ptField
|
||
# 统计用例个数
|
||
case_qs = project_obj.pcField
|
||
# 测试用例的类型统计个数
|
||
testType_list, testType_count = create_str_testType_list(case_qs.all())
|
||
# 问题单总个数
|
||
problem_qs = project_obj.projField
|
||
|
||
context = {
|
||
'project_name': project_obj.name,
|
||
'demand_count': demand_qs.count(),
|
||
'case_count': case_qs.count(),
|
||
'testType_list': "、".join(testType_list),
|
||
'testType_count': testType_count,
|
||
'problem_count': problem_qs.count(),
|
||
'is_JD': is_JD,
|
||
}
|
||
return create_bg_docx('测试有效性充分性说明.docx', context, id)
|
||
|
||
# 需求指标符合性情况
|
||
@route.get('/create/demand_effective', url_name='create-demand_effective')
|
||
@transaction.atomic
|
||
def create_demand_effective(self, id: int):
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
# 查询所有需求规格说明的 - 设计需求
|
||
round1_design_qs = project_obj.psField.filter(round__key='0', dut__type='XQ') # qs:第一轮需求文档的设计需求
|
||
# 将第一轮需求文档名称
|
||
dut_name = f"《{project_obj.name}软件需求规格说明》"
|
||
data_list = []
|
||
design_index = 1
|
||
for design in round1_design_qs:
|
||
# 如果为“/”则写为隐含需求
|
||
if design.chapter.strip() == '/':
|
||
design_dict = {'source': "隐含需求"}
|
||
else:
|
||
design_dict = {'source': "".join([dut_name, design.name, ':', design.chapter])}
|
||
# 将设计需求描述筛入
|
||
rich_parser = RichParser(design.description)
|
||
p_list = rich_parser.get_final_p_list()
|
||
design_dict['description'] = '\a'.join(p_list)
|
||
# 找出其中所有demand
|
||
demand_qs = design.dtField.all()
|
||
if not demand_qs.exists():
|
||
design_dict['demands'] = '未关联测试项'
|
||
else:
|
||
demand_list = []
|
||
index = 0
|
||
for demand in demand_qs:
|
||
index += 1
|
||
demand_abbr = get_str_abbr(demand.testType, 'testType')
|
||
demand_list.append(f'{index}、XQ_{demand_abbr}_{demand.ident}-{demand.name}')
|
||
design_dict['demands'] = '\a'.join(demand_list)
|
||
# 通过还是未通过
|
||
design_dict['pass'] = '通过'
|
||
design_dict['index'] = design_index
|
||
data_list.append(design_dict)
|
||
design_index += 1
|
||
|
||
# ~~~~指标符合性表~~~~
|
||
data_yz_list = []
|
||
# qs:第一轮需求文档的设计需求
|
||
has_YZ = False
|
||
round1_design_yz_qs = project_obj.psField.filter(round__key='0', dut__type='YZ')
|
||
if round1_design_yz_qs.exists():
|
||
has_YZ = True
|
||
# 如果有研制总要求的dut，继续
|
||
for design in round1_design_yz_qs:
|
||
rich_parser2 = RichParser(design.description)
|
||
p_list = rich_parser2.get_final_p_list()
|
||
design_dict = {
|
||
'yz_des': "".join([design.chapter, '章节：', design.name, '\a', '\a'.join(p_list)])}
|
||
# 找出其中所有demand
|
||
demand_qs = design.dtField.all()
|
||
if not demand_qs.exists():
|
||
design_dict['demands'] = '未关联测评大纲条款'
|
||
else:
|
||
# 大纲条款的列表
|
||
demand_list = []
|
||
demand_step_list = []
|
||
index = 0
|
||
for demand in demand_qs:
|
||
index += 1
|
||
demand_list.append(f'{index}、{demand.ident}-{demand.name}')
|
||
# 测试需求步骤的列表
|
||
step_list = []
|
||
for step in demand.testQField.all():
|
||
step_list.append(step.subName)
|
||
demand_step_list.append('\a'.join(step_list))
|
||
|
||
design_dict['demands'] = '\a'.join(demand_list)
|
||
design_dict['steps'] = '\a'.join(demand_step_list)
|
||
|
||
# 通过还是未通过
|
||
design_dict['pass'] = '通过'
|
||
data_yz_list.append(design_dict)
|
||
# 处理没有steps字段
|
||
if 'steps' not in design_dict:
|
||
design_dict['steps'] = '该设计需求未关联测评大纲条款'
|
||
|
||
context = {
|
||
'data_list': data_list,
|
||
'data_yz_list': data_yz_list,
|
||
'has_YZ': has_YZ,
|
||
}
|
||
return create_bg_docx('需求指标符合性情况.docx', context, id)
|
||
|
||
# 软件质量评价
|
||
@route.get('/create/quality_evaluate', url_name='create-quality_evaluate')
|
||
@transaction.atomic
|
||
def create_quality_evaluate(self, id: int):
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
# 找出最后一轮
|
||
rounds = project_obj.pField.order_by('-key') # qs：轮次
|
||
last_dut_so: Optional[Dut] = None
|
||
for round in rounds:
|
||
# 查询其源代码dut
|
||
dut_so = round.rdField.filter(type='SO').first()
|
||
if dut_so:
|
||
last_dut_so = dut_so
|
||
break
|
||
# 计算千行缺陷率
|
||
problem_count = project_obj.projField.count()
|
||
# 如果没有轮次信息则返回错误
|
||
if not last_dut_so:
|
||
return ChenResponse(code=400, status=400, message='您还未创建轮次，请进入工作区创建')
|
||
# 计算注释率
|
||
## 总行数
|
||
total_lines = int(last_dut_so.total_lines)
|
||
## 有效注释行
|
||
effective_comment_lines = int(last_dut_so.comment_lines)
|
||
comment_ratio = (effective_comment_lines / total_lines) * 100
|
||
context = {
|
||
'last_version': last_dut_so.version, # 最后轮次代码版本
|
||
'comment_percent': format(comment_ratio, '.4f'), # 最后轮次代码注释率
|
||
'qian_comment_rate': format(problem_count / int(last_dut_so.total_lines) * 1000, '.4f'),
|
||
'avg_function_lines': "XXXX",
|
||
'avg_cyclomatic': 'XXXX',
|
||
'avg_fan_out': 'XXXX',
|
||
}
|
||
# 判断是否有metrics一对一模型关联
|
||
if hasattr(last_dut_so, 'metrics'):
|
||
context['avg_function_lines'] = str(last_dut_so.metrics.avg_function_lines)
|
||
context['avg_cyclomatic'] = str(last_dut_so.metrics.avg_cyclomatic)
|
||
context['avg_fan_out'] = str(last_dut_so.metrics.avg_fan_out)
|
||
return create_bg_docx('软件质量评价.docx', context, id)
|
||
|
||
# 软件总体结论
|
||
@route.get('/create/entire', url_name='create-entire')
|
||
@transaction.atomic
|
||
def create_entire(self, id: int):
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
# 是否鉴定
|
||
is_JD = False
|
||
if project_obj.report_type == '9':
|
||
is_JD = True
|
||
# 找出最后一轮并且有源代码的dut
|
||
rounds = project_obj.pField.order_by('-key') # qs：轮次
|
||
last_dut_so: Optional[Dut] = None
|
||
for round in rounds:
|
||
# 查询其源代码dut
|
||
dut_so = round.rdField.filter(type='SO').first()
|
||
if dut_so:
|
||
last_dut_so = dut_so
|
||
break
|
||
# 找出所有被测件协议（XY）、需求规格说明（XQ）、设计说明（SJ）
|
||
duties_qs = project_obj.pdField.filter(Q(type='XQ') | Q(type='SJ') | Q(type='XY'))
|
||
# ***Inspect-start***
|
||
if not last_dut_so:
|
||
self.logger.model = '测评报告'
|
||
self.logger.write_warning_log('总体结论', f'项目没创建轮次，请检查')
|
||
return None
|
||
# ***Inspect-end***
|
||
context = {
|
||
'name': project_obj.name,
|
||
'last_version': last_dut_so.version,
|
||
'is_JD': is_JD,
|
||
'dut_list': [
|
||
{
|
||
'index': index + 1,
|
||
'name': dut_single.name,
|
||
'ref': dut_single.ref,
|
||
'version': dut_single.version,
|
||
} for index, dut_single in enumerate(duties_qs)
|
||
],
|
||
'last_dut_so_ref': last_dut_so.ref,
|
||
}
|
||
return create_bg_docx('总体结论.docx', context, id)
|
||
|
||
# 研总需求追踪 - 注意生成每个轮次的追踪
|
||
@route.get('/create/yzxq_track', url_name='create-yzxq_track')
|
||
@transaction.atomic
|
||
def create_yzxq_track(self, id: int):
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
# 是否是鉴定的变量，如果为鉴定，则需要研总的追踪
|
||
is_JD = False
|
||
if project_obj.report_type == '9':
|
||
is_JD = True
|
||
# 查询多少个轮次
|
||
round_count = project_obj.pField.count()
|
||
round_str_list = [str(i) for i in range(round_count)]
|
||
# 生成研总的design_list
|
||
design_list_all = []
|
||
for round_str in round_str_list:
|
||
# 找寻轮次里面源代码版本
|
||
dut_version = 'XXX'
|
||
dut_so = Dut.objects.filter(round__key=round_str, type='SO').first()
|
||
if dut_so:
|
||
dut_version = dut_so.version
|
||
if is_JD:
|
||
design_list_yz = create_bg_round1_zhui(project_obj, dut_str='YZ', round_str=round_str)
|
||
one_table_dict = {
|
||
'design_list': design_list_yz,
|
||
'version': 'V' + dut_version,
|
||
'title': '研制总要求'
|
||
}
|
||
design_list_all.append(one_table_dict)
|
||
design_list_xq = create_bg_round1_zhui(project_obj, dut_str='XQ', round_str=round_str)
|
||
one_table_dict_xq = {
|
||
'design_list': design_list_xq,
|
||
'version': 'V' + dut_version,
|
||
'title': '需求规格说明'
|
||
}
|
||
design_list_all.append(one_table_dict_xq)
|
||
else:
|
||
design_list_xq = create_bg_round1_zhui(project_obj, dut_str='XQ', round_str=round_str)
|
||
one_table_dict_xq = {
|
||
'design_list': design_list_xq,
|
||
'version': 'V' + dut_version,
|
||
'title': '需求规格说明'
|
||
}
|
||
design_list_all.append(one_table_dict_xq)
|
||
context = {
|
||
'design_list_all': design_list_all,
|
||
}
|
||
|
||
# 手动渲染tpl文档
|
||
project_path_str = project_path(id)
|
||
input_file = Path.cwd() / 'media' / project_path_str / 'form_template' / 'bg' / '研总需归追踪.docx'
|
||
temporary_file = Path.cwd() / 'media' / project_path_str / 'form_template' / 'bg' / 'temporary' / '研总需归追踪_temp.docx'
|
||
out_put_file = Path.cwd() / 'media' / project_path_str / 'output_dir' / 'bg' / '研总需归追踪.docx'
|
||
doc = DocxTemplate(input_file)
|
||
doc.render(context)
|
||
doc.save(temporary_file)
|
||
# 通过docx合并单元格
|
||
if temporary_file.is_file():
|
||
try:
|
||
docu = Document(temporary_file)
|
||
# 循环找到表格
|
||
for table in docu.tables:
|
||
util.merge_all_cell(table)
|
||
# 储存到合适位置
|
||
docu.save(out_put_file)
|
||
return ChenResponse(code=200, status=200, message='文档生成成功...')
|
||
except PermissionError:
|
||
return ChenResponse(code=400, status=400, message='请检查文件是否打开，如果打开则关闭...')
|
||
else:
|
||
return ChenResponse(code=400, status=400, message='中间文档未找到，请检查你模版是否存在...')
|
||
|
||
# 生成问题汇总表
|
||
@route.get('/create/problems_summary', url_name='create-problem_summary')
|
||
@transaction.atomic
|
||
def create_problem_summary(self, id: int):
|
||
tpl_doc = Path.cwd() / "media" / project_path(id) / "form_template" / "bg" / "问题汇总表.docx"
|
||
doc = DocxTemplate(tpl_doc)
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
problem_prefix = "_".join(['PT', project_obj.ident])
|
||
problems = project_obj.projField
|
||
# 先查询有多少轮次
|
||
round_count = project_obj.pField.count()
|
||
round_str_list = [str(x) for x in range(round_count)]
|
||
data_list = []
|
||
for round_str in round_str_list:
|
||
# 查询所属当前轮次的SO-dut
|
||
so_dut = Dut.objects.filter(round__key=round_str, type='SO').first()
|
||
round_dict = {
|
||
'static': [],
|
||
'dynamic': [],
|
||
'version': so_dut.version if so_dut else "v1.0",
|
||
}
|
||
# 找出轮次中静态问题
|
||
r1_static_problems = problems.filter(case__round__key=round_str,
|
||
case__test__testType__in=['2', '3', '8', '15']).distinct()
|
||
for problem in r1_static_problems:
|
||
problem_dict = create_one_problem_dit(problem, problem_prefix, doc)
|
||
round_dict['static'].append(problem_dict)
|
||
|
||
# 找出轮次中动态问题
|
||
r1_dynamic_problems = problems.filter(case__round__key=round_str).exclude(
|
||
case__test__testType__in=['2', '3', '8', '15']).distinct()
|
||
for problem in r1_dynamic_problems:
|
||
problem_dict = create_one_problem_dit(problem, problem_prefix, doc)
|
||
round_dict['dynamic'].append(problem_dict)
|
||
data_list.append(round_dict)
|
||
|
||
context = {
|
||
'data_list': data_list
|
||
}
|
||
|
||
doc.render(context)
|
||
try:
|
||
doc.save(Path.cwd() / "media" / project_path(id) / "output_dir/bg" / "问题汇总表.docx")
|
||
return ChenResponse(status=200, code=200, message="文档生成成功！")
|
||
except PermissionError as e:
|
||
return ChenResponse(status=400, code=400, message="模版文件已打开，请关闭后再试，{0}".format(e))
|
||
|
||
# 生成摸底清单
|
||
@route.get('/create/modi_list', url_name='create-modi-list')
|
||
@transaction.atomic
|
||
def create_modi_list(self, id: int):
|
||
tpl_doc = Path.cwd() / "media" / project_path(id) / "form_template" / "bg" / "摸底清单.docx"
|
||
doc = DocxTemplate(tpl_doc)
|
||
project_obj = get_object_or_404(Project, id=id)
|
||
# 查询所有轮次“摸底测试”的测试项
|
||
demands_qs = project_obj.ptField.all()
|
||
modi_list = []
|
||
for demand in demands_qs:
|
||
one_modi = {}
|
||
testType_str = get_str_dict(demand.testType, 'testType')
|
||
if "摸底" in testType_str:
|
||
# 1.找到设计需求章节号以及描述
|
||
design = demand.design
|
||
one_modi['source'] = f"{design.chapter}-{design.name}" if design.chapter != '/' else "隐含需求"
|
||
one_modi['desc'] = "\a".join(RichParser(design.description).get_final_p_list())
|
||
# 2.找所有的case
|
||
case_qs = demand.tcField.all()
|
||
one_modi['result'] = []
|
||
for case in case_qs:
|
||
# 找case的步骤
|
||
for step in case.step.all():
|
||
if step.passed == '1': # 只获取通过的
|
||
one_modi['result'].append("\a".join(RichParser(step.result).get_final_p_list()))
|
||
modi_list.append(one_modi)
|
||
# 渲染上下文
|
||
context = {
|
||
'modi_list': modi_list,
|
||
}
|
||
doc.render(context)
|
||
try:
|
||
doc.save(Path.cwd() / "media" / project_path(id) / "output_dir/bg" / "摸底清单.docx")
|
||
return ChenResponse(status=200, code=200, message="文档生成成功！")
|
||
except PermissionError as e:
|
||
return ChenResponse(status=400, code=400, message="模版文件已打开，请关闭后再试，{0}".format(e))
|