test-version22
/
MeterSphere
mirror of https://gitee.com/fit2cloud-feizhiyun/MeterSphere.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

refactor(消息管理): 重构模板默认值

This commit is contained in:
guoyuqi 2023-10-17 09:29:45 +08:00 committed by f2c-ci-robot[bot]
parent bc9cada46e
commit e69b0bb25a
14 changed files with 746 additions and 604 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
backend/framework/domain/src/main/resources/migration/3.0.0/dml/V3.0.0_11_1__data.sql
View File

@ -243,8 +243,13 @@ INSERT INTO message_task_blob(id, template) VALUES (@test_plan_task_delete_id, '
SET @test_plan_task_execute_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@test_plan_task_execute_id, 'EXECUTE_COMPLETED', 'OPERATOR', @robot_in_site_id, 'TEST_PLAN_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.test_plan_task_execute_completed');
INSERT INTO message_task_blob(id, template) VALUES (@test_plan_task_execute_id, 'message.test_plan_task_execute_completed');
VALUES (@test_plan_task_execute_id, 'EXECUTE_SUCCESSFUL', 'CREATE_USER', @robot_in_site_id, 'TEST_PLAN_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.test_plan_task_execute_success');
INSERT INTO message_task_blob(id, template) VALUES (@test_plan_task_execute_id, 'message.test_plan_task_execute');
SET @test_plan_task_execute_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@test_plan_task_execute_id, 'EXECUTE_FAILED', 'OPERATOR', @robot_in_site_id, 'TEST_PLAN_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.test_plan_task_execute_failed');
INSERT INTO message_task_blob(id, template) VALUES (@test_plan_task_execute_id, 'message.test_plan_task_execute');
SET @test_plan_task_report_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
@ -272,11 +277,6 @@ Insert into message_task(id, event, receiver, project_robot_id, task_type, test_
VALUES (@bug_comment_id, 'COMMENT', 'CREATE_USER', @robot_in_site_id, 'BUG_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.bug_task_comment');
INSERT INTO message_task_blob(id, template) VALUES (@bug_comment_id, 'message.bug_task_comment');
SET @bug_comment_at_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@bug_comment_at_id, 'COMMENT', 'CREATE_USER', @robot_in_site_id, 'BUG_TASK_AT', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.bug_task_comment');
INSERT INTO message_task_blob(id, template) VALUES (@bug_comment_at_id, 'message.bug_task_at_comment');
SET @bug_sync_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@bug_sync_id, 'EXECUTE_COMPLETED', 'OPERATOR', @robot_in_site_id, 'BUG_SYNC_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.bug_sync_task_execute_completed');
@ -298,15 +298,31 @@ Insert into message_task(id, event, receiver, project_robot_id, task_type, test_
VALUES (@functional_delete_id, 'DELETE', 'CREATE_USER', @robot_in_site_id, 'FUNCTIONAL_CASE_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.functional_case_task_delete');
INSERT INTO message_task_blob(id, template) VALUES (@functional_delete_id, 'message.functional_case_task_delete');
SET @functional_review_passed_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@functional_review_passed_id, 'REVIEW_PASSED', 'CREATE_USER', @robot_in_site_id, 'FUNCTIONAL_CASE_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.functional_case_task_review_passed');
INSERT INTO message_task_blob(id, template) VALUES (@functional_review_passed_id, 'message.functional_case_task_review');
SET @functional_review_fail_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@functional_review_fail_id, 'REVIEW_FAIL', 'CREATE_USER', @robot_in_site_id, 'FUNCTIONAL_CASE_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.functional_case_task_review_fail');
INSERT INTO message_task_blob(id, template) VALUES (@functional_review_fail_id, 'message.functional_case_task_review');
SET @functional_execute_passed_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@functional_execute_passed_id, 'EXECUTE_PASSED', 'CREATE_USER', @robot_in_site_id, 'FUNCTIONAL_CASE_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.functional_case_task_execute_passed');
INSERT INTO message_task_blob(id, template) VALUES (@functional_execute_passed_id, 'message.functional_case_task_plan');
SET @functional_execute_fail_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@functional_execute_fail_id, 'EXECUTE_FAIL', 'CREATE_USER', @robot_in_site_id, 'FUNCTIONAL_CASE_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.functional_case_task_execute_fail');
INSERT INTO message_task_blob(id, template) VALUES (@functional_execute_fail_id, 'message.functional_case_task_plan');
SET @functional_comment_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@functional_comment_id, 'COMMENT', 'CREATE_USER', @robot_in_site_id, 'FUNCTIONAL_CASE_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.functional_case_task_comment');
INSERT INTO message_task_blob(id, template) VALUES (@functional_comment_id, 'message.functional_case_task_comment');
SET @functional_comment_at_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@functional_comment_at_id, 'COMMENT', 'CREATE_USER', @robot_in_site_id, 'FUNCTIONAL_CASE_TASK_AT', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.functional_case_task_comment');
INSERT INTO message_task_blob(id, template) VALUES (@functional_comment_at_id, 'message.functional_case_task_at_comment');
SET @case_creator_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
@ -323,11 +339,6 @@ Insert into message_task(id, event, receiver, project_robot_id, task_type, test_
VALUES (@case_delete_id, 'DELETE', 'CREATE_USER', @robot_in_site_id, 'CASE_REVIEW_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.case_review_task_delete');
INSERT INTO message_task_blob(id, template) VALUES (@case_delete_id, 'message.case_review_task_delete');
SET @case_execute_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@case_execute_id, 'EXECUTE_REVIEW', 'CREATE_USER', @robot_in_site_id, 'CASE_REVIEW_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.case_review_task_execute_review');
INSERT INTO message_task_blob(id, template) VALUES (@case_execute_id, 'message.case_review_task_execute_review');
SET @case_review_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@case_review_id, 'REVIEW_COMPLETED', 'CREATE_USER', @robot_in_site_id, 'CASE_REVIEW_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.case_review_task_review_completed');
@ -447,56 +458,29 @@ Insert into message_task(id, event, receiver, project_robot_id, task_type, test_
VALUES (@load_report_id, 'DELETE', 'CREATE_USER', @robot_in_site_id, 'LOAD_REPORT_TASK', 'NONE', '100001100001', true, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.load_report_task_delete');
INSERT INTO message_task_blob(id, template) VALUES (@load_report_id, 'message.load_report_task_delete');
SET @load_report_id = UUID_SHORT();
-- 初始化Jenkins消息数据
SET @jenkins_execute_successful_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@load_report_id, 'EXECUTE_SUCCESSFUL', 'CREATE_USER', @robot_in_site_id, 'JENKINS_UI_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.jenkins_ui_task_execute_successful');
INSERT INTO message_task_blob(id, template) VALUES (@load_report_id, 'message.jenkins_ui_task_execute');
VALUES (@jenkins_execute_successful_id, 'EXECUTE_SUCCESSFUL', 'CREATE_USER', @robot_in_site_id, 'JENKINS_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.jenkins_task_execute_successful');
INSERT INTO message_task_blob(id, template) VALUES (@jenkins_execute_successful_id, 'message.jenkins_task_execute');
SET @load_report_id = UUID_SHORT();
SET @jenkins_execute_failed_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@load_report_id, 'EXECUTE_FAILED', 'CREATE_USER', @robot_in_site_id, 'JENKINS_UI_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.jenkins_ui_task_execute_failed');
INSERT INTO message_task_blob(id, template) VALUES (@load_report_id, 'message.jenkins_ui_task_execute');
VALUES (@jenkins_execute_failed_id, 'EXECUTE_FAILED', 'CREATE_USER', @robot_in_site_id, 'JENKINS_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.jenkins_task_execute_failed');
INSERT INTO message_task_blob(id, template) VALUES (@jenkins_execute_failed_id, 'message.jenkins_task_execute');
SET @load_report_id = UUID_SHORT();
-- 初始化定时任务消息数据
SET @schedule_open_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@load_report_id, 'EXECUTE_SUCCESSFUL', 'CREATE_USER', @robot_in_site_id, 'JENKINS_API_SCENARIO_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.jenkins_api_scenario_task_execute_successful');
INSERT INTO message_task_blob(id, template) VALUES (@load_report_id, 'message.jenkins_api_scenario_task_execute');
VALUES (@schedule_open_id, 'OPEN', 'CREATE_USER', @robot_in_site_id, 'SCHEDULE_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.schedule_task_open');
INSERT INTO message_task_blob(id, template) VALUES (@schedule_open_id, 'message.schedule_task_open');
SET @load_report_id = UUID_SHORT();
SET @schedule_close_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@load_report_id, 'EXECUTE_FAILED', 'CREATE_USER', @robot_in_site_id, 'JENKINS_API_SCENARIO_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.jenkins_api_scenario_task_execute_failed');
INSERT INTO message_task_blob(id, template) VALUES (@load_report_id, 'message.jenkins_api_scenario_task_execute');
VALUES (@schedule_close_id, 'CLOSE', 'CREATE_USER', @robot_in_site_id, 'SCHEDULE_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.schedule_task_close');
INSERT INTO message_task_blob(id, template) VALUES (@schedule_close_id, 'message.schedule_task_close');
SET @load_report_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@load_report_id, 'EXECUTE_SUCCESSFUL', 'CREATE_USER', @robot_in_site_id, 'JENKINS_API_CASE_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.jenkins_api_case_task_execute_successful');
INSERT INTO message_task_blob(id, template) VALUES (@load_report_id, 'message.jenkins_api_case_task_execute');
SET @load_report_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@load_report_id, 'EXECUTE_FAILED', 'CREATE_USER', @robot_in_site_id, 'JENKINS_API_CASE_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.jenkins_api_case_task_execute_failed');
INSERT INTO message_task_blob(id, template) VALUES (@load_report_id, 'message.jenkins_api_case_task_execute');
SET @load_report_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@load_report_id, 'EXECUTE_SUCCESSFUL', 'CREATE_USER', @robot_in_site_id, 'JENKINS_LOAD_CASE_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.jenkins_load_case_task_execute_successful');
INSERT INTO message_task_blob(id, template) VALUES (@load_report_id, 'message.jenkins_load_case_task_execute');
SET @load_report_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@load_report_id, 'EXECUTE_FAILED', 'CREATE_USER', @robot_in_site_id, 'JENKINS_LOAD_CASE_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.jenkins_load_case_task_execute_failed');
INSERT INTO message_task_blob(id, template) VALUES (@load_report_id, 'message.jenkins_load_case_task_execute');
SET @load_report_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@load_report_id, 'EXECUTE_SUCCESSFUL', 'CREATE_USER', @robot_in_site_id, 'JENKINS_TEST_PLAN_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.jenkins_test_plan_task_execute_successful');
INSERT INTO message_task_blob(id, template) VALUES (@load_report_id, 'message.jenkins_test_plan_task_execute');
SET @load_report_id = UUID_SHORT();
Insert into message_task(id, event, receiver, project_robot_id, task_type, test_id, project_id, enable, create_user, create_time, update_user, update_time, use_default_template, use_default_subject, subject)
VALUES (@load_report_id, 'EXECUTE_FAILED', 'CREATE_USER', @robot_in_site_id, 'JENKINS_TEST_PLAN_TASK', 'NONE', '100001100001', false, 'admin', unix_timestamp() * 1000, 'admin', unix_timestamp() * 1000, true, true, 'message.title.jenkins_test_plan_task_execute_failed');
INSERT INTO message_task_blob(id, template) VALUES (@load_report_id, 'message.jenkins_test_plan_task_execute');
-- set innodb lock wait timeout to default
SET SESSION innodb_lock_wait_timeout = DEFAULT;

74
backend/framework/sdk/src/main/resources/i18n/project.properties
View File

@ -131,11 +131,9 @@ message.api_definition_task=接口文档
message.api_scenario_task=接口场景
message.ui_scenario_task=UI自动化
message.load_test_task=测试用例
message.jenkins_ui_task=Jenkins的UI用例任务
message.jenkins_api_scenario_task=Jenkins的接口场景任务
message.jenkins_api_case_task=Jenkins的接口用例任务
message.jenkins_load_case_task=Jenkins的性能用例任务
message.jenkins_test_plan_task=Jenkins的测试计划任务
message.jenkins_task=执行
message.batch_execution=批量执行
message.manual_execution=手动执行
message.test_plan_management=测试计划
message.bug_management=缺陷管理
message.case_management=用例管理
@ -143,12 +141,17 @@ message.api_test_management=接口测试
message.ui_test_management=UI测试
message.load_test_management=性能测试
message.jenkins_task_management=Jenkins
message.schedule_task_management=定时任务
message.create=创建
message.update=更新
message.delete=删除
message.execute_completed=执行完成
message.comment=评论
message.execute_review=执行评审
message.at=被@
message.replay=被回复
message.review_passed=评审通过
message.review_fail=评审不通过
message.review_at=评审被@
message.review_completed=评审完成
message.case_create=创建用例
message.case_update=更新用例
@ -161,17 +164,23 @@ message.scenario_execute_fake_error=场景执行误报
message.scenario_execute_failed=场景执行失败
message.execute_successful=执行成功
message.execute_failed=执行失败
message.execute_passed=执行通过
message.execute_fail=执行不通过
message.execute_at=执行被@
message.open=开启
message.close=关闭
message.create_user=创建人
message.follow_people=关注人
message.operator=操作人
message.trigger_mode=触发方式
message.jenkins_name=名称
message.custom_field=自定义字段
message.case_field=用例字段
message.report_field=报告字段
message.test_plan_task_create=${OPERATOR}创建了测试计划:${name}
message.test_plan_task_update=${OPERATOR}更新了测试计划:${name}
message.test_plan_task_delete=${OPERATOR}删除了测试计划:${name}
message.test_plan_task_execute_completed=${OPERATOR}执行完成了测试计划:${name}
message.schedule_execute_completed_test_plan=${OPERATOR}通过定时任务执行了测试计划:${name}
message.test_plan_task_execute=${OPERATOR}执行了测试计划:${name}
message.test_plan_report_task_delete=${OPERATOR}删除了测试计划报告:${name}
message.bug_task_create=${OPERATOR}创建了缺陷:${title}
message.bug_task_update=${OPERATOR}更新了缺陷:${title}
@ -180,17 +189,20 @@ message.bug_task_comment=${OPERATOR}评论了你的缺陷:${title}
message.bug_task_at_comment=${OPERATOR}评论了缺陷:${title} 并@了你
message.bug_task_reply_comment=${OPERATOR}在缺陷 ${title} 回复了你的评论
message.bug_sync_task_execute_completed=${OPERATOR}同步了${total}条缺陷
message.bug_schedule_task_execute_completed=${OPERATOR}通过定时任务同步了${total}条缺陷
message.functional_case_task_create=${OPERATOR}创建了功能用例:${name}
message.functional_case_task_update=${OPERATOR}更新了功能用例:${name}
message.functional_case_task_delete=${OPERATOR}删除了功能用例:${name}
message.functional_case_task_comment=${OPERATOR}评论了你的功能用例:${name}
message.functional_case_task_review=${OPERATOR}评审了${reviewName}${name}
message.functional_case_task_review_at=${OPERATOR}在${reviewName}${name}@了你
message.functional_case_task_plan=${OPERATOR}评审了${testPlanName}${name}
message.functional_case_task_plan_at=${OPERATOR}在${testPlanName}${name}@了你
message.functional_case_task_at_comment=${OPERATOR}评论了功能用例:${name} 并@了你
message.functional_case_task_reply_comment=${OPERATOR}在用例 ${name} 回复了你的评论
message.case_review_task_create=${OPERATOR}创建了用例评审:${name}
message.case_review_task_update=${OPERATOR}更新了用例评审:${name}
message.case_review_task_delete=${OPERATOR}删除了用例评审:${name}
message.case_review_task_execute_review=${OPERATOR}评审了功能用例:${name}
message.case_review_task_review_completed=${OPERATOR}完成了用例评审:${name}
message.api_definition_task_create=${OPERATOR}创建了接口文档:${name}
message.api_definition_task_update=${OPERATOR}更新了接口文档:${name}
@ -203,30 +215,28 @@ message.api_scenario_task_create=${OPERATOR}创建了接口场景:${name}
message.api_scenario_task_update=${OPERATOR}更新了接口场景:${name}
message.api_scenario_task_delete=${OPERATOR}删除了接口场景:${name}
message.api_scenario_task_scenario_execute=${OPERATOR}执行了接口场景:${name}
message.api_schedule_task_execute_completed=${OPERATOR}通过定时任务执行了接口场景:${name}
message.api_report_task_delete=${OPERATOR}删除了接口报告:${name}
message.ui_scenario_task_create=${OPERATOR}创建了UI用例:${name}
message.ui_scenario_task_update=${OPERATOR}更新了UI用例:${name}
message.ui_scenario_task_delete=${OPERATOR}删除了UI用例:${name}
message.ui_scenario_task_execute=${OPERATOR}执行了UI用例:${name}
message.ui_schedule_task_execute_completed=${OPERATOR}通过定时任务执行了UI用例:${name}
message.ui_report_task_delete=${OPERATOR}删除了UI报告:${name}
message.load_test_task_create=${OPERATOR}创建了性能用例:${name}
message.load_test_task_update=${OPERATOR}更新了性能用例:${name}
message.load_test_task_delete=${OPERATOR}删除了性能用例:${name}
message.load_test_task_execute_completed=${OPERATOR}执行了性能用例:${name}
message.load_schedule_task_execute_completed=${OPERATOR}通过定时任务执行了性能用例:${name}
message.load_report_task_delete=${OPERATOR}删除了性能报告:${name}
message.jenkins_api_scenario_task_execute=Jenkins执行了接口场景:${name}
message.jenkins_api_case_task_execute=Jenkins执行了接口用例:${name}
message.jenkins_load_case_task_execute=Jenkins执行了性能用例:${name}
message.jenkins_test_plan_task_execute=Jenkins执行了测试计划:${name}
message.jenkins_ui_task_execute=Jenkins执行了UI用例:${name}
message.jenkins_task_execute=Jenkins执行了:${name}
message.schedule_task_open=${OPERATOR}开启了定时任务:${name}
message.schedule_task_close=${OPERATOR}关闭了定时任务:${name}
message.title.test_plan_task_create=测试计划创建通知
message.title.test_plan_task_update=测试计划更新通知
message.title.test_plan_task_delete=测试计划删除通知
message.title.test_plan_task_execute_completed=测试计划执行完成通知
message.title.test_plan_task_execute_success=测试计划执行成功通知
message.title.test_plan_task_execute_failed=测试计划执行失败通知
message.title.bug_task_create=缺陷创建通知
message.title.bug_task_update=缺陷更新通知
message.title.bug_task_delete=缺陷删除通知
@ -236,10 +246,17 @@ message.title.functional_case_task_create=功能用例创建通知
message.title.functional_case_task_update=功能用例更新通知
message.title.functional_case_task_delete=功能用例删除通知
message.title.functional_case_task_comment=功能用例评论通知
message.title.functional_case_task_review_passed=用例评审通过通知
message.title.functional_case_task_review_fail=用例评审不通过通知
message.title.functional_case_task_review_at=用例评审通知
message.title.functional_case_task_execute_passed=用例执行通过通知
message.title.functional_case_task_execute_fail=用例执行不通过通知
message.title.functional_case_task_execute_at=用例执行通知
message.title.case_review_task_create=用例评审创建通知
message.title.case_review_task_update=用例评审更新通知
message.title.case_review_task_delete=用例评审删除通知
message.title.case_review_task_execute_review=用例评审执行通知
message.title.case_review_task_review_completed=用例评审评审完成通知
message.title.api_definition_task_create=接口文档创建通知
message.title.api_definition_task_update=接口文档更新通知
@ -256,30 +273,23 @@ message.title.api_scenario_task_delete=接口场景删除通知
message.title.api_scenario_task_scenario_execute_successful=接口场景执行成功通知
message.title.api_scenario_task_scenario_execute_fake_error=接口场景执误报通知
message.title.api_scenario_task_scenario_execute_failed=接口场景执行失败通知
message.title.api_schedule_task_execute_completed=接口场景执行完成通知
message.title.api_report_task_delete=接口报告删除通知
message.title.ui_scenario_task_create=UI用例创建通知
message.title.ui_scenario_task_update=UI用例更新通知
message.title.ui_scenario_task_delete=UI用例删除通知
message.title.ui_scenario_task_execute_successful=UI用例执行成功通知
message.title.ui_scenario_task_execute_failed=UI用例执行失败通知
message.title.ui_schedule_task_execute_completed=UI执行完成通知
message.title.ui_report_task_delete=UI报告删除通知
message.title.load_test_task_create=性能用例创建通知
message.title.load_test_task_update=性能用例更新通知
message.title.load_test_task_delete=性能用例删除通知
message.title.load_test_task_execute_completed=性能用例执行完成通知
message.title.load_report_task_delete=性能报告删除通知
message.title.jenkins_api_scenario_task_execute_successful=Jenkins执行接口场景成功通知
message.title.jenkins_api_scenario_task_execute_failed=Jenkins执行接口场景失败通知
message.title.jenkins_api_case_task_execute_successful=Jenkins执行接口用例成功通知
message.title.jenkins_api_case_task_execute_failed=Jenkins执行接口用例失败通知
message.title.jenkins_load_case_task_execute_successful=Jenkins执行性能用例成功通知
message.title.jenkins_load_case_task_execute_failed=Jenkins执行性能用例失败通知
message.title.jenkins_test_plan_task_execute_successful=Jenkins执行测试计划成功通知
message.title.jenkins_test_plan_task_execute_failed=Jenkins执行测试计划失败通知
message.title.jenkins_ui_task_execute_successful=Jenkins执行UI用例成功通知
message.title.jenkins_ui_task_execute_failed=Jenkins执行UI用例失败通知
message.title.jenkins_task_execute_successful=Jenkins任务执行成功通知
message.title.jenkins_task_execute_failed=Jenkins任务执行失败通知
message.title.schedule_task_open=
message.title.schedule_task_close=
resource_pool_not_exist=资源池不存在
#file management

69
backend/framework/sdk/src/main/resources/i18n/project_en_US.properties
View File

@ -164,11 +164,9 @@ message.api_definition_task=API documentation
message.api_scenario_task=API scenario
message.ui_scenario_task=UI automation
message.load_test_task=Test case
message.jenkins_ui_task=Jenkins tasks about UI
message.jenkins_api_scenario_task=Jenkins tasks about API scenario
message.jenkins_api_case_task=Jenkins tasks about an API case
message.jenkins_load_case_task=Jenkins tasks about a Load case
message.jenkins_test_plan_task=Jenkins tasks about test plan
message.jenkins_task=Execution
message.batch_execution=Batch execution
message.manual_execution=Manual execution
message.test_plan_management=Test Plan
message.bug_management=Bug management
message.case_management=Case management
@ -176,12 +174,17 @@ message.api_test_management=API test
message.ui_test_management=UI test
message.load_test_management=Load test
message.jenkins_task_management=Jenkins
message.schedule_task_management=Schedule task
message.create=Create
message.update=Update
message.delete=Delete
message.execute_completed=Execution completed
message.comment=Comment
message.execute_review=Execution review
message.at=quilt@
message.replay=Replied
message.review_passed=Passed the review
message.review_fail=The review failed
message.review_at=評審被@
message.review_completed=Review completed
message.case_create=Create case
message.case_update=Update case
@ -194,17 +197,23 @@ message.scenario_execute_fake_error=Scenario execution fake error
message.scenario_execute_failed=Scenario execution failed
message.execute_successful=Executed successfully
message.execute_failed=Execution failed
message.execute_passed=Execution passed
message.execute_fail=Execution failed
message.execute_at=Execution is @
message.open=turn on
message.close=closure
message.create_user=Create user
message.follow_people=Follow people
message.operator=Operator
message.trigger_mode=Trigger mode
message.jenkins_name=Name
message.custom_field=Custom fields
message.case_field=Case field
message.report_field=Report fields
message.test_plan_task_create=${OPERATOR} created the test plan: ${name}
message.test_plan_task_update=${OPERATOR} updated the test plan: ${name}
message.test_plan_task_delete=${OPERATOR} deleted the test plan: ${name}
message.test_plan_task_execute_completed=${OPERATOR}executed and completed the test plan: ${name}
message.schedule_execute_completed_test_plan=${OPERATOR}executed the test plan through scheduled tasks: ${name}
message.test_plan_task_execute=${OPERATOR} executed the test plan: ${name}
message.test_plan_report_task_delete=${OPERATOR} deleted test plan report: ${name}
message.bug_task_create=${OPERATOR} created a bug: ${title}
message.bug_task_update=${OPERATOR} updated a bug: ${title}
@ -213,17 +222,21 @@ message.bug_task_comment=${OPERATOR}commented on your bug: ${title}
message.bug_task_at_comment=${OPERATOR} commented on the bug: ${title} and @you
message.bug_task_reply_comment=${OPERATOR} in defect ${title} replied to your comment
message.bug_sync_task_execute_completed=${OPERATOR} synchronized ${total} bugs
message.bug_schedule_task_execute_completed=${OPERATOR}synchronized ${total} bugs through scheduled tasks
message.functional_case_task_create=${OPERATOR} created the functional case: ${name}
message.functional_case_task_update=${OPERATOR} updated the functional case: ${name}
message.functional_case_task_delete=${OPERATOR} deleted the functional case: ${name}
message.functional_case_task_comment=${OPERATOR} commented on your functional case: ${name}
message.functional_case_task_review=${OPERATOR} reviewed ${reviewName} ${name}
message.functional_case_task_review_at=${OPERATOR} @ you in ${reviewName} ${name}
message.functional_case_task_plan=${OPERATOR} reviewed ${testPlanName} ${name}
message.functional_case_task_plan_at=${OPERATOR} @ you in ${testPlanName} ${name}
message.functional_case_task_at_comment=${OPERATOR} commented on functional case: ${name} and @you
message.functional_case_task_reply_comment=${OPERATOR} in use case ${name} replied to your comment
message.case_review_task_create=${OPERATOR} created the case review: ${name}
message.case_review_task_update=${OPERATOR} updated the case review: ${name}
message.case_review_task_delete=${OPERATOR} deleted the case review: ${name}
message.case_review_task_execute_review=${OPERATOR}reviewed the functional case: ${name}
message.case_review_task_review_completed=${OPERATOR} completed the case review: ${name}
message.api_definition_task_create=${OPERATOR} created the API documentation: ${name}
message.api_definition_task_update=${OPERATOR} updated the API documentation: ${name}
@ -236,29 +249,25 @@ message.api_scenario_task_create=${OPERATOR}created the API scenario: ${name}
message.api_scenario_task_update=${OPERATOR} updated the API scenario: ${name}
message.api_scenario_task_delete=${OPERATOR} deleted the API scenario: ${name}
message.api_scenario_task_scenario_execute=${OPERATOR} executed the API scenario: ${name}
message.api_schedule_task_execute_completed=${OPERATOR}executed the API scenario through a scheduled task: ${name}
message.api_report_task_delete=${OPERATOR} deleted API report: ${name}
message.ui_scenario_task_create=${OPERATOR} created the UI case: ${name}
message.ui_scenario_task_update=${OPERATOR} updated the UI case: ${name}
message.ui_scenario_task_delete=${OPERATOR} deleted the UI case: ${name}
message.ui_scenario_task_execute=${OPERATOR} executed the UI case: ${name}
message.ui_schedule_task_execute_completed=${OPERATOR}executed the UI case through a scheduled task: ${name}
message.ui_report_task_delete=${OPERATOR} deleted UI report: ${name}
message.load_test_task_create=${OPERATOR} created the load case: ${name}
message.load_test_task_update=${OPERATOR} updated the load case: ${name}
message.load_test_task_delete=${OPERATOR} deleted the load case: ${name}
message.load_test_task_execute_completed=${OPERATOR} executed the load case: ${name}
message.load_schedule_task_execute_completed=${OPERATOR}executed the load case through a scheduled task: ${name}
message.load_report_task_delete=${OPERATOR} deleted load report: ${name}
message.jenkins_api_scenario_task_execute=Jenkins executed the API scenario:${name}
message.jenkins_api_case_task_execute=Jenkins executed the API case:${name}
message.jenkins_load_case_task_execute=Jenkins executed the Load case:${name}
message.jenkins_test_plan_task_execute=Jenkins executed the test plan:${name}
message.jenkins_ui_task_execute=Jenkins executed the UI:${name}
message.jenkins_task_execute=Jenkins executed the ${name}
message.schedule_task_open=${OPERATOR} started a scheduled task: ${name}
message.schedule_task_close=${OPERATOR} closed the scheduled task: ${name}
message.title.test_plan_task_create=Test plan creation notification
message.title.test_plan_task_update=Test plan update notification
message.title.test_plan_task_delete=Test plan deletion notification
message.title.test_plan_task_execute_completed=Test plan execution completion notification
message.title.test_plan_task_execute_success=Test plan execution success notification
message.title.test_plan_task_execute_failed=Test plan execution failed notification
message.title.bug_task_create=Bug creation notification
message.title.bug_task_update=Bug update notification
message.title.bug_task_delete=Bug deletion notification
@ -268,11 +277,17 @@ message.title.functional_case_task_create=Functional case creation notification
message.title.functional_case_task_update=Functional case update notification
message.title.functional_case_task_delete=Functional case deletion notification
message.title.functional_case_task_comment=Functional case comment notification
message.title.functional_case_task_review_passed=Case review approval notification
message.title.functional_case_task_review_fail=Notification of failure in case review
message.title.functional_case_task_review_at=Case review notice
message.title.functional_case_task_execute_passed=Case execution via notification
message.title.functional_case_task_execute_fail=Case execution fails notification
message.title.functional_case_task_execute_at=Case execution notification
message.title.case_review_task_create=Case review creation notification
message.title.case_review_task_update=Case review update notification
message.title.case_review_task_delete=Case review deletion notification
message.title.case_review_task_execute_review=Case review execution notification
message.title.case_review_task_review_completed=Case review review completion notification
message.title.case_review_task_review_completed=Case review completion notification
message.title.api_definition_task_create=API document creation notification
message.title.api_definition_task_update=API document update notification
message.title.api_definition_task_delete=API document deletion notification
@ -288,14 +303,12 @@ message.title.api_scenario_task_delete=API scenario deletion notification
message.title.api_scenario_task_scenario_execute_successful=API scenario execution success notification
message.title.api_scenario_task_scenario_execute_fake_error=API scenario execution fake error notification
message.title.api_scenario_task_scenario_execute_failed=API scenario execution failure notification
message.title.api_schedule_task_execute_completed=API scenario execution completion notification
message.title.api_report_task_delete=API report deletion notification
message.title.ui_scenario_task_create=UI case creation notification
message.title.ui_scenario_task_update=UI case update notification
message.title.ui_scenario_task_delete=UI case deletion notification
message.title.ui_scenario_task_execute_successful=UI case execution success notification
message.title.ui_scenario_task_execute_failed=UI case execution failure notification
message.title.ui_schedule_task_execute_completed=UI execution completion notification
message.title.ui_report_task_delete=UI report deletion notification
message.title.load_test_task_create=Load case creation notification
message.title.load_test_task_update=Load case update notification
@ -304,16 +317,6 @@ message.title.load_test_task_execute_completed=Load case execution completion no
message.title.load_report_task_delete=Load report deletion notification
message.title.jenkins_task_execute_successful=Jenkins task execution success notification
message.title.jenkins_task_execute_failed=Jenkins task execution failure notification
message.title.jenkins_api_scenario_task_execute_successful=Jenkins執行介面場景成功通知
message.title.jenkins_api_scenario_task_execute_failed=Jenkins執行介面場景失敗通知
message.title.jenkins_api_case_task_execute_successful=Jenkins執行介面用例成功通知
message.title.jenkins_api_case_task_execute_failed=Jenkins執行介面用例失敗通知
message.title.jenkins_load_case_task_execute_successful=Jenkins執行性能用例成功通知
message.title.jenkins_load_case_task_execute_failed=Jenkins執行性能用例失敗通知
message.title.jenkins_test_plan_task_execute_successful=Jenkins執行測試計劃删成功通知
message.title.jenkins_test_plan_task_execute_failed=Jenkins執行測試計劃删失敗通知
message.title.jenkins_ui_task_execute_successful=Jenkins執行UI用例成功通知
message.title.jenkins_ui_task_execute_failed=Jenkins execution UI use case success notification
resource_pool_not_exist=Resource pool does not exist

69
backend/framework/sdk/src/main/resources/i18n/project_zh_CN.properties
View File

@ -164,11 +164,9 @@ message.api_definition_task=接口文档
message.api_scenario_task=接口场景
message.ui_scenario_task=UI自动化
message.load_test_task=测试用例
message.jenkins_ui_task=Jenkins的UI用例任务
message.jenkins_api_scenario_task=Jenkins的接口场景任务
message.jenkins_api_case_task=Jenkins的接口用例任务
message.jenkins_load_case_task=Jenkins的性能用例任务
message.jenkins_test_plan_task=Jenkins的测试计划任务
message.jenkins_task=执行
message.batch_execution=批量执行
message.manual_execution=手动执行
message.test_plan_management=测试计划
message.bug_management=缺陷管理
message.case_management=用例管理
@ -176,12 +174,17 @@ message.api_test_management=接口测试
message.ui_test_management=UI测试
message.load_test_management=性能测试
message.jenkins_task_management=Jenkins
message.schedule_task_management=定时任务
message.create=创建
message.update=更新
message.delete=删除
message.execute_completed=执行完成
message.comment=评论
message.execute_review=执行评审
message.at=被@
message.replay=被回复
message.review_passed=评审通过
message.review_fail=评审不通过
message.review_at=Reviewed by @
message.review_completed=评审完成
message.case_create=创建用例
message.case_update=更新用例
@ -194,17 +197,23 @@ message.scenario_execute_fake_error=场景执行误报
message.scenario_execute_failed=场景执行失败
message.execute_successful=执行成功
message.execute_failed=执行失败
message.execute_passed=执行通过
message.execute_fail=执行不通过
message.execute_at=执行被@
message.open=开启
message.close=关闭
message.create_user=创建人
message.follow_people=关注人
message.operator=操作人
message.trigger_mode=触发方式
message.jenkins_name=名称
message.custom_field=自定义字段
message.case_field=用例字段
message.report_field=报告字段
message.test_plan_task_create=${OPERATOR}创建了测试计划:${name}
message.test_plan_task_update=${OPERATOR}更新了测试计划:${name}
message.test_plan_task_delete=${OPERATOR}删除了测试计划:${name}
message.test_plan_task_execute_completed=${OPERATOR}执行完成了测试计划:${name}
message.schedule_execute_completed_test_plan=${OPERATOR}通过定时任务执行了测试计划:${name}
message.test_plan_task_execute=${OPERATOR}执行了测试计划:${name}
message.test_plan_report_task_delete=${OPERATOR}删除了测试计划报告:${name}
message.bug_task_create=${OPERATOR}创建了缺陷:${title}
message.bug_task_update=${OPERATOR}更新了缺陷:${title}
@ -213,17 +222,21 @@ message.bug_task_comment=${OPERATOR}评论了你的缺陷:${title}
message.bug_task_at_comment=${OPERATOR}评论了缺陷:${title} 并@了你
message.bug_task_reply_comment=${OPERATOR}在缺陷 ${title} 回复了你的评论
message.bug_sync_task_execute_completed=${OPERATOR}同步了${total}条缺陷
message.bug_schedule_task_execute_completed=${OPERATOR}通过定时任务同步了${total}条缺陷
message.functional_case_task_create=${OPERATOR}创建了功能用例:${name}
message.functional_case_task_update=${OPERATOR}更新了功能用例:${name}
message.functional_case_task_delete=${OPERATOR}删除了功能用例:${name}
message.functional_case_task_comment=${OPERATOR}评论了你的功能用例:${name}
message.functional_case_task_review=${OPERATOR}评审了${reviewName}${name}
message.functional_case_task_review_at=${OPERATOR}在${reviewName}${name}@了你
message.functional_case_task_plan=${OPERATOR}评审了${testPlanName}${name}
message.functional_case_task_plan_at=${OPERATOR}在${testPlanName}${name}@了你
message.functional_case_task_at_comment=${OPERATOR}评论了功能用例:${name} 并@了你
message.functional_case_task_reply_comment=${OPERATOR}在用例 ${name} 回复了你的评论
message.case_review_task_create=${OPERATOR}创建了用例评审:${name}
message.case_review_task_update=${OPERATOR}更新了用例评审:${name}
message.case_review_task_delete=${OPERATOR}删除了用例评审:${name}
message.case_review_task_execute_review=${OPERATOR}评审了功能用例:${name}
message.case_review_task_review_completed=${OPERATOR}完成了用例评审:${name}
message.api_definition_task_create=${OPERATOR}创建了接口文档:${name}
message.api_definition_task_update=${OPERATOR}更新了接口文档:${name}
@ -236,29 +249,26 @@ message.api_scenario_task_create=${OPERATOR}创建了接口场景:${name}
message.api_scenario_task_update=${OPERATOR}更新了接口场景:${name}
message.api_scenario_task_delete=${OPERATOR}删除了接口场景:${name}
message.api_scenario_task_scenario_execute=${OPERATOR}执行了接口场景:${name}
message.api_schedule_task_execute_completed=${OPERATOR}通过定时任务执行了接口场景:${name}
message.api_report_task_delete=${OPERATOR}删除了接口报告:${name}
message.ui_scenario_task_create=${OPERATOR}创建了UI用例:${name}
message.ui_scenario_task_update=${OPERATOR}更新了UI用例:${name}
message.ui_scenario_task_delete=${OPERATOR}删除了UI用例:${name}
message.ui_scenario_task_execute=${OPERATOR}执行了UI用例:${name}
message.ui_schedule_task_execute_completed=${OPERATOR}通过定时任务执行了UI用例:${name}
message.ui_report_task_delete=${OPERATOR}删除了UI报告:${name}
message.load_test_task_create=${OPERATOR}创建了性能用例:${name}
message.load_test_task_update=${OPERATOR}更新了性能用例:${name}
message.load_test_task_delete=${OPERATOR}删除了性能用例:${name}
message.load_test_task_execute_completed=${OPERATOR}执行了性能用例:${name}
message.load_schedule_task_execute_completed=${OPERATOR}通过定时任务执行了性能用例:${name}
message.load_report_task_delete=${OPERATOR}删除了性能报告:${name}
message.jenkins_api_scenario_task_execute=Jenkins执行了接口场景:${name}
message.jenkins_api_case_task_execute=Jenkins执行了接口用例:${name}
message.jenkins_load_case_task_execute=Jenkins执行了性能用例:${name}
message.jenkins_test_plan_task_execute=Jenkins执行了测试计划:${name}
message.jenkins_ui_task_execute=Jenkins执行了UI用例:${name}
message.jenkins_task_execute=Jenkins执行了:${name}
message.schedule_task_open=${OPERATOR}开启了定时任务:${name}
message.schedule_task_close=${OPERATOR}关闭了定时任务:${name}
message.title.test_plan_task_create=测试计划创建通知
message.title.test_plan_task_update=测试计划更新通知
message.title.test_plan_task_delete=测试计划删除通知
message.title.test_plan_task_execute_completed=测试计划执行完成通知
message.title.test_plan_task_execute_success=测试计划执行成功通知
message.title.test_plan_task_execute_failed=测试计划执行失败通知
message.title.bug_task_create=缺陷创建通知
message.title.bug_task_update=缺陷更新通知
message.title.bug_task_delete=缺陷删除通知
@ -268,10 +278,15 @@ message.title.functional_case_task_create=功能用例创建通知
message.title.functional_case_task_update=功能用例更新通知
message.title.functional_case_task_delete=功能用例删除通知
message.title.functional_case_task_comment=功能用例评论通知
message.title.functional_case_task_review_passed=用例评审通过通知
message.title.functional_case_task_review_fail=用例评审不通过通知
message.title.functional_case_task_review_at=用例评审通知
message.title.functional_case_task_execute_passed=用例执行通过通知
message.title.functional_case_task_execute_fail=用例执行不通过通知
message.title.functional_case_task_execute_at=用例执行通知
message.title.case_review_task_create=用例评审创建通知
message.title.case_review_task_update=用例评审更新通知
message.title.case_review_task_delete=用例评审删除通知
message.title.case_review_task_execute_review=用例评审执行通知
message.title.case_review_task_review_completed=用例评审评审完成通知
message.title.api_definition_task_create=接口文档创建通知
message.title.api_definition_task_update=接口文档更新通知
@ -288,30 +303,20 @@ message.title.api_scenario_task_delete=接口场景删除通知
message.title.api_scenario_task_scenario_execute_successful=接口场景执行成功通知
message.title.api_scenario_task_scenario_execute_fake_error=接口场景执误报通知
message.title.api_scenario_task_scenario_execute_failed=接口场景执行失败通知
message.title.api_schedule_task_execute_completed=接口场景执行完成通知
message.title.api_report_task_delete=接口报告删除通知
message.title.ui_scenario_task_create=UI用例创建通知
message.title.ui_scenario_task_update=UI用例更新通知
message.title.ui_scenario_task_delete=UI用例删除通知
message.title.ui_scenario_task_execute_successful=UI用例执行成功通知
message.title.ui_scenario_task_execute_failed=UI用例执行失败通知
message.title.ui_schedule_task_execute_completed=UI执行完成通知
message.title.ui_report_task_delete=UI报告删除通知
message.title.load_test_task_create=性能用例创建通知
message.title.load_test_task_update=性能用例更新通知
message.title.load_test_task_delete=性能用例删除通知
message.title.load_test_task_execute_completed=性能用例执行完成通知
message.title.load_report_task_delete=性能报告删除通知
message.title.jenkins_api_scenario_task_execute_successful=Jenkins执行接口场景成功通知
message.title.jenkins_api_scenario_task_execute_failed=Jenkins执行接口场景失败通知
message.title.jenkins_api_case_task_execute_successful=Jenkins执行接口用例成功通知
message.title.jenkins_api_case_task_execute_failed=Jenkins执行接口用例失败通知
message.title.jenkins_load_case_task_execute_successful=Jenkins执行性能用例成功通知
message.title.jenkins_load_case_task_execute_failed=Jenkins执行性能用例失败通知
message.title.jenkins_test_plan_task_execute_successful=Jenkins执行测试计划成功通知
message.title.jenkins_test_plan_task_execute_failed=Jenkins执行测试计划失败通知
message.title.jenkins_ui_task_execute_successful=Jenkins执行UI用例成功通知
message.title.jenkins_ui_task_execute_failed=Jenkins执行UI用例失败通知
message.title.jenkins_task_execute_successful=Jenkins任务执行成功通知
message.title.jenkins_task_execute_failed=Jenkins任务执行失败通知
resource_pool_not_exist=资源池不存在
#file management

70
backend/framework/sdk/src/main/resources/i18n/project_zh_TW.properties
View File

@ -165,11 +165,9 @@ message.api_definition_task=介面文檔
message.api_scenario_task=介面場景
message.ui_scenario_task=UI自動化
message.load_test_task=測試用例
message.jenkins_ui_task=Jenkins的UI用例任務
message.jenkins_api_scenario_task=Jenkins的介面場景任務
message.jenkins_api_case_task=Jenkins的介面用例任務
message.jenkins_load_case_task=Jenkins的效能用例任務
message.jenkins_test_plan_task=Jenkins的測試計劃任務
message.jenkins_task=執行
message.batch_execution=大量執行
message.manual_execution=手動執行
message.test_plan_management=測試計劃
message.bug_management=缺陷管理
message.case_management=用例管理
@ -177,12 +175,17 @@ message.api_test_management=介面測試
message.ui_test_management=UI測試
message.load_test_management=效能測試
message.jenkins_task_management=Jenkins
message.schedule_task_management=定時任務
message.create=創建
message.update=更新
message.delete=删除
message.execute_completed=執行完成
message.comment=評論
message.execute_review=執行評審
message.at=被@
message.replay=被回覆
message.review_passed=評審通過
message.review_fail=評審不通過
message.review_at=評審被@
message.review_completed=評審完成
message.case_create=創建用例
message.case_update=更新用例
@ -195,17 +198,23 @@ message.scenario_execute_fake_error=场景執行誤報
message.scenario_execute_failed=场景執行失敗
message.execute_successful=執行成功
message.execute_failed=執行失敗
message.execute_passed=執行通過
message.execute_fail=執行不通過
message.execute_at=執行被@
message.open=開啟
message.close=關閉
message.create_user=創建人
message.follow_people=關注人
message.operator=操作人
message.trigger_mode=觸發方式
message.jenkins_name=名稱
message.custom_field=自訂字段
message.case_field=用例字段
message.report_field=報告字段
message.test_plan_task_create=${OPERATOR}創建了測試計劃:${name}
message.test_plan_task_update=${OPERATOR}更新了測試計劃:${name}
message.test_plan_task_delete=${OPERATOR}删除了測試計劃:${name}
message.test_plan_task_execute_completed=${OPERATOR}執行完成了測試計劃:${name}
message.schedule_execute_completed_test_plan=${OPERATOR}透過定時任務執行了測試計劃:${name}
message.test_plan_task_execute=${OPERATOR}執行了測試計劃:${name}
message.test_plan_report_task_delete=${OPERATOR}删除了測試計劃報告:${name}
message.bug_task_create=${OPERATOR}創建了缺陷:${title}
message.bug_task_update=${OPERATOR}更新了缺陷:${title}
@ -214,17 +223,21 @@ message.bug_task_comment=${OPERATOR}評論了你的缺陷:${title}
message.bug_task_at_comment=${OPERATOR}評論了缺陷:${title} 並@了你
message.bug_task_reply_comment=${OPERATOR}在缺陷 ${title} 回覆了你的評論
message.bug_sync_task_execute_completed=${OPERATOR}同步了${total}条缺陷
message.bug_schedule_task_execute_completed=${OPERATOR}透過定時任務同步了${total}条缺陷
message.functional_case_task_create=${OPERATOR}創建了功能用例:${name}
message.functional_case_task_update=${OPERATOR}更新了功能用例:${name}
message.functional_case_task_delete=${OPERATOR}删除了功能用例:${name}
message.functional_case_task_comment=${OPERATOR}評論了你的功能用例:${name}
message.functional_case_task_review=${OPERATOR}評審了${reviewName}${name}
message.functional_case_task_review_at=${OPERATOR}在${reviewName}${name}@了你
message.functional_case_task_plan=${OPERATOR}評審了${testPlanName}${name}
message.functional_case_task_plan_at=${OPERATOR}在${testPlanName}${name}@了你
message.functional_case_task_at_comment=${OPERATOR}評論了功能用例:${name} 並@了你
message.functional_case_task_reply_comment=${OPERATOR}在用例 ${name} 回覆了你的評論
message.case_review_task_create=${OPERATOR}創建了用例評審:${name}
message.case_review_task_update=${OPERATOR}更新了用例評審:${name}
message.case_review_task_delete=${OPERATOR}删除了用例評審:${name}
message.case_review_task_execute_review=${OPERATOR}評審了功能用例:${name}
message.case_review_task_review_completed=${OPERATOR}完成了用例評審:${name}
message.api_definition_task_create=${OPERATOR}創建了介面文檔:${name}
message.api_definition_task_update=${OPERATOR}更新了介面文檔:${name}
@ -237,29 +250,26 @@ message.api_scenario_task_create=${OPERATOR}創建了介面場景:${name}
message.api_scenario_task_update=${OPERATOR}更新了介面場景:${name}
message.api_scenario_task_delete=${OPERATOR}删除了介面場景:${name}
message.api_scenario_task_scenario_execute=${OPERATOR}執行了介面場景:${name}
message.api_schedule_task_execute_completed=${OPERATOR}透過定時任務執行了介面場景:${name}
message.api_report_task_delete=${OPERATOR}删除了接口報告:${name}
message.ui_scenario_task_create=${OPERATOR}創建了UI用例:${name}
message.ui_scenario_task_update=${OPERATOR}更新了UI用例:${name}
message.ui_scenario_task_delete=${OPERATOR}删除了UI用例:${name}
message.ui_scenario_task_execute=${OPERATOR}執行了UI用例:${name}
message.ui_schedule_task_execute_completed=${OPERATOR}透過定時任務執行了UI用例:${name}
message.ui_report_task_delete=${OPERATOR}删除了UI報告:${name}
message.load_test_task_create=${OPERATOR}創建了性能用例:${name}
message.load_test_task_update=${OPERATOR}更新了性能用例:${name}
message.load_test_task_delete=${OPERATOR}删除了性能用例:${name}
message.load_test_task_execute_completed=${OPERATOR}執行了性能用例:${name}
message.load_schedule_task_execute_completed=${OPERATOR}透過定時任務執行了性能用例:${name}
message.load_report_task_delete=${OPERATOR}删除了性能報告:${name}
message.jenkins_api_scenario_task_execute=Jenkins執行了介面場景:${name}
message.jenkins_api_case_task_execute=Jenkins執行了介面用例:${name}
message.jenkins_load_case_task_execute=Jenkins執行了性能用例:${name}
message.jenkins_test_plan_task_execute=Jenkins執行了測試計劃:${name}
message.jenkins_ui_task_execute=Jenkins執行了UI用例:${name}
message.jenkins_task_execute=Jenkins執行了:${name}
message.schedule_task_open=${OPERATOR}開啟了定時任務:${name}
message.schedule_task_close=${OPERATOR}關閉了定時任務:${name}
message.title.test_plan_task_create=測試計劃創建通知
message.title.test_plan_task_update=測試計劃更新通知
message.title.test_plan_task_delete=測試計劃删除通知
message.title.test_plan_task_execute_completed=測試計劃執行完成通知
message.title.test_plan_task_execute_success=測試計劃執行成功通知
message.title.test_plan_task_execute_failed=測試計劃執行失敗通知
message.title.bug_task_create=缺陷創建通知
message.title.bug_task_update=缺陷更新通知
message.title.bug_task_delete=缺陷删除通知
@ -269,10 +279,16 @@ message.title.functional_case_task_create=功能用例創建通知
message.title.functional_case_task_update=功能用例更新通知
message.title.functional_case_task_delete=功能用例删除通知
message.title.functional_case_task_comment=功能用例評論通知
message.title.functional_case_task_review_passed=用例評審透過通知
message.title.functional_case_task_review_fail=用例評審不透過通知
message.title.functional_case_task_review_at=用例評審通知
message.title.functional_case_task_execute_passed=用例執行透過通知
message.title.functional_case_task_execute_fail=用例執行不透過通知
message.title.functional_case_task_execute_at=用例執行通知
message.title.case_review_task_create=用例評審創建通知
message.title.case_review_task_update=用例評審更新通知
message.title.case_review_task_delete=用例評審删除通知
message.title.case_review_task_execute_review=用例評審執行通知
message.title.case_review_task_review_completed=用例評審評審完成通知
message.title.api_definition_task_create=介面文檔創建通知
message.title.api_definition_task_update=介面文檔更新通知
@ -289,30 +305,20 @@ message.title.api_scenario_task_delete=介面場景删除通知
message.title.api_scenario_task_scenario_execute_successful=介面場景執行成功通知
message.title.api_scenario_task_scenario_execute_fake_error=介面場景执誤報通知
message.title.api_scenario_task_scenario_execute_failed=介面場景執行失敗通知
message.title.api_schedule_task_execute_completed=介面場景執行完成通知
message.title.api_report_task_delete=接口報告删除通知
message.title.ui_scenario_task_create=UI用例創建通知
message.title.ui_scenario_task_update=UI用例更新通知
message.title.ui_scenario_task_delete=UI用例删除通知
message.title.ui_scenario_task_execute_successful=UI用例執行成功通知
message.title.ui_scenario_task_execute_failed=UI用例執行失敗通知
message.title.ui_schedule_task_execute_completed=UI執行完成通知
message.title.ui_report_task_delete=UI報告删除通知
message.title.load_test_task_create=性能用例創建通知
message.title.load_test_task_update=性能用例更新通知
message.title.load_test_task_delete=性能用例删除通知
message.title.load_test_task_execute_completed=性能用例執行完成通知
message.title.load_report_task_delete=性能報告删除通知
message.title.jenkins_api_scenario_task_execute_successful=Jenkins執行介面場景成功通知
message.title.jenkins_api_scenario_task_execute_failed=Jenkins執行介面場景失敗通知
message.title.jenkins_api_case_task_execute_successful=Jenkins執行介面用例成功通知
message.title.jenkins_api_case_task_execute_failed=Jenkins執行介面用例失敗通知
message.title.jenkins_load_case_task_execute_successful=Jenkins執行性能用例成功通知
message.title.jenkins_load_case_task_execute_failed=Jenkins執行性能用例失敗通知
message.title.jenkins_test_plan_task_execute_successful=Jenkins執行測試計劃删成功通知
message.title.jenkins_test_plan_task_execute_failed=Jenkins執行測試計劃删失敗通知
message.title.jenkins_ui_task_execute_successful=Jenkins執行UI用例成功通知
message.title.jenkins_ui_task_execute_failed=Jenkins執行UI用例失敗通知
message.title.jenkins_task_execute_successful=Jenkins任務執行成功通知
message.title.jenkins_task_execute_failed=Jenkins任務執行失敗通知
resource_pool_not_exist=資源池不存在
#file management
file_module.not.exist=文件模塊不存在

85
backend/services/project-management/src/main/java/io/metersphere/project/dto/ApiDefinitionCaseDTO.java Normal file
View File

@ -0,0 +1,85 @@
package io.metersphere.project.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class ApiDefinitionCaseDTO {
@Schema(description = "接口名称")
private String name;
@Schema(description = "接口协议")
private String protocol;
@Schema(description = "http协议类型post/get/其它协议则是协议名(mqtt)")
private String method;
@Schema(description = "http协议路径/其它协议则为空")
private String path;
@Schema(description = "接口状态/进行中/已完成")
private String status;
@Schema(description = "描述")
private String description;
@Schema(description = "创建时间")
private Long createTime;
@Schema(description = "创建人")
private String createUser;
@Schema(description = "修改时间")
private Long updateTime;
@Schema(description = "修改人")
private String updateUser;
@Schema(description = "删除人")
private String deleteUser;
@Schema(description = "删除时间")
private Long deleteTime;
@Schema(description = "接口用例名称")
private String caseName;
@Schema(description = "用例等级")
private String priority;
@Schema(description = "用例状态")
private String caseStatus;
@Schema(description = "用例最新执行结果状态")
private String lastReportStatus;
@Schema(description = "用例最后执行结果报告fk")
private String lastReportId;
@Schema(description = "用例责任人")
private String principal;
@Schema(description = "用例创建时间")
private Long caseCreateTime;
@Schema(description = "用例创建人")
private String caseCreateUser;
@Schema(description = "用例更新时间")
private Long caseUpdateTime;
@Schema(description = "用例更新人")
private String caseUpdateUser;
@Schema(description = "用例删除时间")
private Long caseDeleteTime;
@Schema(description = "用例删除人")
private String caseDeleteUser;
}

47
backend/services/project-management/src/main/java/io/metersphere/project/dto/FunctionalCaseMessageDTO.java Normal file
View File

@ -0,0 +1,47 @@
package io.metersphere.project.dto;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class FunctionalCaseMessageDTO {
@Schema(description = "名称", requiredMode = Schema.RequiredMode.REQUIRED)
private String name;
@Schema(description = "测试计划名称", requiredMode = Schema.RequiredMode.REQUIRED)
private String testPlanName;
@Schema(description = "评审名称", requiredMode = Schema.RequiredMode.REQUIRED)
private String reviewName;
@Schema(description = "评审状态：未开始/进行中/已完成/已结束", requiredMode = Schema.RequiredMode.REQUIRED)
private String reviewStatus;
@Schema(description = "编辑模式：步骤模式/文本模式", requiredMode = Schema.RequiredMode.REQUIRED)
private String caseModel;
@Schema(description = "最近的执行结果：未执行/通过/失败/阻塞/跳过", requiredMode = Schema.RequiredMode.REQUIRED)
private String lastExecuteResult;
@Schema(description = "创建人")
private String createUser;
@Schema(description = "更新人")
private String updateUser;
@Schema(description = "删除人")
private String deleteUser;
@Schema(description = "创建时间")
private Long createTime;
@Schema(description = "更新时间")
private Long updateTime;
@Schema(description = "删除时间")
private Long deleteTime;
}

24
backend/services/project-management/src/main/java/io/metersphere/project/service/NoticeMessageTaskService.java
View File

@ -72,16 +72,18 @@ public class NoticeMessageTaskService {
public ResultHolder saveMessageTask(MessageTaskRequest messageTaskRequest, String userId) {
String projectId = messageTaskRequest.getProjectId();
checkProjectExist(projectId);
//如果只选了用户，没有选机器人，默认机器人为站内信
ProjectRobot projectRobot = getDefaultRobot(messageTaskRequest.getProjectId(), messageTaskRequest.getRobotId());
String robotId = projectRobot.getId();
messageTaskRequest.setRobotId(robotId);
//删除用户数据不在当前传送用户内的数据
deleteUserData(messageTaskRequest, projectId);
SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH);
MessageTaskMapper mapper = sqlSession.getMapper(MessageTaskMapper.class);
MessageTaskBlobMapper blobMapper = sqlSession.getMapper(MessageTaskBlobMapper.class);
//检查用户是否存在
Map<String, List<String>> stringListMap = checkUserExistProject(messageTaskRequest.getReceiverIds(), projectId);
List<String> existUserIds = stringListMap.get(USER_IDS);
//如果只选了用户，没有选机器人，默认机器人为站内信
ProjectRobot projectRobot = getDefaultRobot(messageTaskRequest.getProjectId(), messageTaskRequest.getRobotId());
String robotId = projectRobot.getId();
messageTaskRequest.setRobotId(robotId);
//检查设置的通知是否存在，如果存在则更新
List<MessageTask> messageTasks = updateMessageTasks(messageTaskRequest, userId, mapper, blobMapper, existUserIds);
//保存消息任务
@ -96,6 +98,20 @@ public class NoticeMessageTaskService {
return ResultHolder.success("OK");
}
private void deleteUserData(MessageTaskRequest messageTaskRequest, String projectId) {
MessageTaskExample messageTaskExample = new MessageTaskExample();
messageTaskExample.createCriteria().andReceiverNotIn(messageTaskRequest.getReceiverIds())
.andProjectIdEqualTo(projectId).andProjectRobotIdEqualTo(messageTaskRequest.getRobotId()).andTaskTypeEqualTo(messageTaskRequest.getTaskType()).andEventEqualTo(messageTaskRequest.getEvent());
List<MessageTask> delData = messageTaskMapper.selectByExample(messageTaskExample);
List<String> delIds = delData.stream().map(MessageTask::getId).toList();
if (CollectionUtils.isNotEmpty(delIds)) {
MessageTaskBlobExample messageTaskBlobExample = new MessageTaskBlobExample();
messageTaskBlobExample.createCriteria().andIdIn(delIds);
messageTaskBlobMapper.deleteByExample(messageTaskBlobExample);
messageTaskMapper.deleteByExample(messageTaskExample);
}
}
private void checkProjectExist(String projectId) {
Project project = projectMapper.selectByPrimaryKey(projectId);
if (project == null) {

40
backend/services/project-management/src/main/java/io/metersphere/project/service/NoticeTemplateService.java
View File

@ -1,13 +1,12 @@
package io.metersphere.project.service;
import io.metersphere.api.domain.ApiDefinition;
import io.metersphere.api.domain.ApiScenario;
import io.metersphere.api.domain.ApiTestCase;
import io.metersphere.bug.domain.Bug;
import io.metersphere.functional.domain.CaseReview;
import io.metersphere.functional.domain.FunctionalCase;
import io.metersphere.load.domain.LoadTest;
import io.metersphere.plan.domain.TestPlan;
import io.metersphere.project.dto.ApiDefinitionCaseDTO;
import io.metersphere.project.dto.FunctionalCaseMessageDTO;
import io.metersphere.project.dto.MessageTemplateFieldDTO;
import io.metersphere.project.dto.MessageTemplateResultDTO;
import io.metersphere.sdk.constants.TemplateScene;
@ -15,6 +14,7 @@ import io.metersphere.sdk.dto.OptionDTO;
import io.metersphere.sdk.util.Translator;
import io.metersphere.system.domain.CustomField;
import io.metersphere.system.domain.CustomFieldExample;
import io.metersphere.system.domain.Schedule;
import io.metersphere.system.mapper.CustomFieldMapper;
import io.metersphere.system.notice.constants.NoticeConstants;
import io.metersphere.system.notice.utils.MessageTemplateUtils;
@ -42,20 +42,18 @@ public class NoticeTemplateService {
public List<MessageTemplateFieldDTO> getDomainTemplateFields(String projectId, String taskType) {
List<MessageTemplateFieldDTO> messageTemplateFieldDTOList = new ArrayList<>();
switch (taskType) {
case NoticeConstants.TaskType.API_DEFINITION_TASK, NoticeConstants.TaskType.JENKINS_API_CASE_TASK -> {
Field[] allFields = FieldUtils.getAllFields(ApiDefinition.class);
case NoticeConstants.TaskType.API_DEFINITION_TASK -> {
Field[] allFields = FieldUtils.getAllFields(ApiDefinitionCaseDTO.class);
addOptionDto(messageTemplateFieldDTOList, allFields);
Field[] allCaseFields = FieldUtils.getAllFields(ApiTestCase.class);
addOptionDto(messageTemplateFieldDTOList, allCaseFields);
addCustomFiled(messageTemplateFieldDTOList, projectId, TemplateScene.API.toString());
//TODO：获取报告
}
case NoticeConstants.TaskType.API_SCENARIO_TASK, NoticeConstants.TaskType.API_SCHEDULE_TASK, NoticeConstants.TaskType.JENKINS_API_SCENARIO_TASK -> {
case NoticeConstants.TaskType.API_SCENARIO_TASK -> {
Field[] allFields = FieldUtils.getAllFields(ApiScenario.class);
addOptionDto(messageTemplateFieldDTOList, allFields);
//TODO：获取报告
}
case NoticeConstants.TaskType.TEST_PLAN_TASK, NoticeConstants.TaskType.JENKINS_TEST_PLAN_TASK -> {
case NoticeConstants.TaskType.TEST_PLAN_TASK -> {
Field[] allFields = FieldUtils.getAllFields(TestPlan.class);
addOptionDto(messageTemplateFieldDTOList, allFields);
addCustomFiled(messageTemplateFieldDTOList, projectId, TemplateScene.TEST_PLAN.toString());
@ -67,7 +65,7 @@ public class NoticeTemplateService {
//TODO：获取报告
}
case NoticeConstants.TaskType.FUNCTIONAL_CASE_TASK -> {
Field[] allFields = FieldUtils.getAllFields(FunctionalCase.class);
Field[] allFields = FieldUtils.getAllFields(FunctionalCaseMessageDTO.class);
addOptionDto(messageTemplateFieldDTOList, allFields);
addCustomFiled(messageTemplateFieldDTOList, projectId, TemplateScene.FUNCTIONAL.toString());
//TODO：获取报告
@ -78,17 +76,30 @@ public class NoticeTemplateService {
addCustomFiled(messageTemplateFieldDTOList, projectId, TemplateScene.BUG.toString());
//TODO：获取报告
}
case NoticeConstants.TaskType.UI_SCENARIO_TASK, NoticeConstants.TaskType.JENKINS_UI_TASK -> {
case NoticeConstants.TaskType.UI_SCENARIO_TASK -> {
Field[] allFields = FieldUtils.getAllFields(UiScenario.class);
addOptionDto(messageTemplateFieldDTOList, allFields);
addCustomFiled(messageTemplateFieldDTOList, projectId, TemplateScene.UI.toString());
//TODO：获取报告
}
case NoticeConstants.TaskType.LOAD_TEST_TASK, NoticeConstants.TaskType.JENKINS_LOAD_CASE_TASK -> {
case NoticeConstants.TaskType.LOAD_TEST_TASK -> {
Field[] allFields = FieldUtils.getAllFields(LoadTest.class);
addOptionDto(messageTemplateFieldDTOList, allFields);
//TODO：获取报告
}
case NoticeConstants.TaskType.SCHEDULE_TASK -> {
Field[] allFields = FieldUtils.getAllFields(Schedule.class);
addOptionDto(messageTemplateFieldDTOList, allFields);
//TODO：获取报告
}
case NoticeConstants.TaskType.JENKINS_TASK -> {
MessageTemplateFieldDTO messageTemplateFieldOperator = new MessageTemplateFieldDTO();
messageTemplateFieldOperator.setId("JENKINS_NAME");
messageTemplateFieldOperator.setFieldSource(NoticeConstants.FieldSource.CASE_FIELD);
messageTemplateFieldOperator.setName(Translator.get("message.jenkins_name"));
messageTemplateFieldDTOList.add(messageTemplateFieldOperator);
//TODO：获取报告
}
default -> messageTemplateFieldDTOList = new ArrayList<>();
}
@ -151,6 +162,11 @@ public class NoticeTemplateService {
messageTemplateFieldFollow.setFieldSource(NoticeConstants.FieldSource.CASE_FIELD);
messageTemplateFieldFollow.setName(Translator.get("message.follow_people"));
messageTemplateFieldDTOS.add(messageTemplateFieldFollow);
MessageTemplateFieldDTO messageTemplateFieldTriggerMode = new MessageTemplateFieldDTO();
messageTemplateFieldTriggerMode.setId("TRIGGER_MODE");
messageTemplateFieldOperator.setFieldSource(NoticeConstants.FieldSource.CASE_FIELD);
messageTemplateFieldOperator.setName(Translator.get("message.trigger_mode"));
messageTemplateFieldDTOS.add(messageTemplateFieldOperator);
}
public MessageTemplateResultDTO getTemplateFields(String projectId, String taskType) {

393
backend/services/project-management/src/main/resources/message_task.json
View File

@ -79,7 +79,29 @@
]
},
{
"event":"EXECUTE_COMPLETED",
"event":"EXECUTE_SUCCESSFUL",
"eventName":"",
"receivers":[
{
"id": "CREATE_USER",
"name": ""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
},
{
"event":"EXECUTE_FAILED",
"eventName":"",
"receivers":[
{
@ -344,6 +366,94 @@
}
]
},
{
"event":"REVIEW_PASSED",
"eventName":"",
"receivers":[
{
"id": "CREATE_USER",
"name": ""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
},
{
"event":"REVIEW_FAIL",
"eventName":"",
"receivers":[
{
"id": "CREATE_USER",
"name": ""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
},
{
"event":"EXECUTE_PASSED",
"eventName":"",
"receivers":[
{
"id": "CREATE_USER",
"name": ""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
},
{
"event":"EXECUTE_FAIL",
"eventName":"",
"receivers":[
{
"id": "CREATE_USER",
"name": ""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
},
{
"event":"COMMENT",
"eventName":"",
@ -442,28 +552,6 @@
}
]
},
{
"event":"EXECUTE_REVIEW",
"eventName":"",
"receivers":[
{
"id": "CREATE_USER",
"name": ""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
},
{
"event":"REVIEW_COMPLETED",
"eventName":"",
@ -1153,207 +1241,7 @@
"name":"",
"messageTaskTypeDTOList":[
{
"taskType":"JENKINS_UI_TASK",
"taskTypeName":"",
"messageTaskDetailDTOList":[
{
"event":"EXECUTE_SUCCESSFUL",
"eventName":"",
"receivers":[
{
"id":"",
"name":""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
},
{
"event":"EXECUTE_FAILED",
"eventName":"",
"receivers":[
{
"id":"",
"name":""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
}
]
},
{
"taskType":"JENKINS_API_SCENARIO_TASK",
"taskTypeName":"",
"messageTaskDetailDTOList":[
{
"event":"EXECUTE_SUCCESSFUL",
"eventName":"",
"receivers":[
{
"id":"",
"name":""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
},
{
"event":"EXECUTE_FAILED",
"eventName":"",
"receivers":[
{
"id":"",
"name":""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
}
]
},
{
"taskType":"JENKINS_API_CASE_TASK",
"taskTypeName":"",
"messageTaskDetailDTOList":[
{
"event":"EXECUTE_SUCCESSFUL",
"eventName":"",
"receivers":[
{
"id":"",
"name":""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
},
{
"event":"EXECUTE_FAILED",
"eventName":"",
"receivers":[
{
"id":"",
"name":""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
}
]
},
{
"taskType":"JENKINS_LOAD_CASE_TASK",
"taskTypeName":"",
"messageTaskDetailDTOList":[
{
"event":"EXECUTE_SUCCESSFUL",
"eventName":"",
"receivers":[
{
"id":"",
"name":""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
},
{
"event":"EXECUTE_FAILED",
"eventName":"",
"receivers":[
{
"id":"",
"name":""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
}
]
},
{
"taskType":"JENKINS_UI_TASK",
"taskType":"JENKINS_TASK",
"taskTypeName":"",
"messageTaskDetailDTOList":[
{
@ -1403,5 +1291,62 @@
]
}
]
},
{
"projectId":"",
"type":"SCHEDULE_TASK_MANAGEMENT",
"name":"",
"messageTaskTypeDTOList":[
{
"taskType":"SCHEDULE_TASK",
"taskTypeName":"",
"messageTaskDetailDTOList":[
{
"event":"OPEN",
"eventName":"",
"receivers":[
{
"id":"",
"name":""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
},
{
"event":"CLOSE",
"eventName":"",
"receivers":[
{
"id":"",
"name":""
}
],
"projectRobotConfigList":[
{
"robotId":"",
"enable":"",
"template":"",
"defaultTemplate":"",
"useDefaultTemplate":true,
"subject":"",
"defaultSubject":"",
"useDefaultSubject":true
}
]
}
]
}
]
}
]

11
backend/services/project-management/src/test/java/io/metersphere/project/controller/NoticeTemplateControllerTests.java
View File

@ -37,19 +37,13 @@ public class NoticeTemplateControllerTests extends BaseTest {
List<String> typeList = new ArrayList<>();
typeList.add(NoticeConstants.TaskType.API_DEFINITION_TASK);
typeList.add(NoticeConstants.TaskType.API_SCENARIO_TASK);
typeList.add(NoticeConstants.TaskType.API_SCHEDULE_TASK);
typeList.add(NoticeConstants.TaskType.TEST_PLAN_TASK);
typeList.add(NoticeConstants.TaskType.CASE_REVIEW_TASK);
typeList.add(NoticeConstants.TaskType.FUNCTIONAL_CASE_TASK);
typeList.add(NoticeConstants.TaskType.BUG_TASK);
typeList.add(NoticeConstants.TaskType.UI_SCENARIO_TASK);
typeList.add(NoticeConstants.TaskType.LOAD_TEST_TASK);
typeList.add(NoticeConstants.TaskType.JENKINS_UI_TASK);
typeList.add(NoticeConstants.TaskType.JENKINS_API_SCENARIO_TASK);
typeList.add(NoticeConstants.TaskType.JENKINS_API_CASE_TASK);
typeList.add(NoticeConstants.TaskType.JENKINS_LOAD_CASE_TASK);
typeList.add(NoticeConstants.TaskType.JENKINS_TEST_PLAN_TASK);
typeList.add(NoticeConstants.TaskType.BUG_TASK_AT);
for (String s : typeList) {
MvcResult mvcResult = mockMvc.perform(MockMvcRequestBuilders.get("/notice/template/get/fields/project-template-test-1")
.header(SessionConstants.HEADER_TOKEN, sessionId)
@ -61,7 +55,7 @@ public class NoticeTemplateControllerTests extends BaseTest {
ResultHolder resultHolder = JSON.parseObject(contentAsString, ResultHolder.class);
MessageTemplateResultDTO messageTemplateResultDTO = JSON.parseObject(JSON.toJSONString(resultHolder.getData()), MessageTemplateResultDTO.class);
List<MessageTemplateFieldDTO> projectList = messageTemplateResultDTO.getFieldList();
if (s.equals(NoticeConstants.TaskType.BUG_TASK_AT)) {
if (s.equals(NoticeConstants.TaskType.SCHEDULE_TASK)) {
Assertions.assertTrue(CollectionUtils.isEmpty(projectList));
} else {
Assertions.assertTrue(CollectionUtils.isNotEmpty(projectList));
@ -74,7 +68,6 @@ public class NoticeTemplateControllerTests extends BaseTest {
List<String> typeList = new ArrayList<>();
typeList.add(NoticeConstants.TaskType.API_DEFINITION_TASK);
typeList.add(NoticeConstants.TaskType.API_SCENARIO_TASK);
typeList.add(NoticeConstants.TaskType.API_SCHEDULE_TASK);
typeList.add(NoticeConstants.TaskType.TEST_PLAN_TASK);
typeList.add(NoticeConstants.TaskType.CASE_REVIEW_TASK);
typeList.add(NoticeConstants.TaskType.FUNCTIONAL_CASE_TASK);

228
backend/services/system-setting/src/main/java/io/metersphere/system/notice/constants/NoticeConstants.java
View File

@ -8,26 +8,19 @@ public interface NoticeConstants {
//测试计划模块的任务
@Schema(description = "message.test_plan_task")
String TEST_PLAN_TASK = "TEST_PLAN_TASK";
@Schema(description = "message.schedule_task")
String TEST_PLAN_SCHEDULE_TASK = "TEST_PLAN_SCHEDULE_TASK";
@Schema(description = "message.report_task")
String TEST_PLAN_REPORT_TASK = "TEST_PLAN_REPORT_TASK";
//缺陷管理模块的任务
@Schema(description = "message.bug_task")
String BUG_TASK = "BUG_TASK";
@Schema(description = "message.bug_task")
String BUG_TASK_AT = "BUG_TASK_AT";
@Schema(description = "message.bug_sync_task")
String BUG_SYNC_TASK = "BUG_SYNC_TASK";
@Schema(description = "message.schedule_task")
String BUG_SCHEDULE_TASK = "BUG_SCHEDULE_TASK";
//用例管理模块的任务
@Schema(description = "message.functional_case_task")
String FUNCTIONAL_CASE_TASK = "FUNCTIONAL_CASE_TASK";
@Schema(description = "message.functional_case_task")
String FUNCTIONAL_CASE_TASK_AT = "FUNCTIONAL_CASE_TASK_AT";
@Schema(description = "message.case_review_task")
String CASE_REVIEW_TASK = "CASE_REVIEW_TASK";
@ -36,8 +29,6 @@ public interface NoticeConstants {
String API_DEFINITION_TASK = "API_DEFINITION_TASK";
@Schema(description = "message.api_scenario_task")
String API_SCENARIO_TASK = "API_SCENARIO_TASK";
@Schema(description = "message.schedule_task")
String API_SCHEDULE_TASK = "API_SCHEDULE_TASK";
@Schema(description = "message.report_task")
String API_REPORT_TASK = "API_REPORT_TASK";
@ -46,31 +37,42 @@ public interface NoticeConstants {
String UI_SCENARIO_TASK = "UI_SCENARIO_TASK";
@Schema(description = "message.report_task")
String UI_REPORT_TASK = "UI_REPORT_TASK";
@Schema(description = "message.schedule_task")
String UI_SCHEDULE_TASK = "UI_SCHEDULE_TASK";
//性能测试模块的任务
@Schema(description = "message.load_test_task")
String LOAD_TEST_TASK = "LOAD_TEST_TASK";
@Schema(description = "message.report_task")
String LOAD_REPORT_TASK = "LOAD_REPORT_TASK";
@Schema(description = "message.schedule_task")
String LOAD_SCHEDULE_TASK = "LOAD_SCHEDULE_TASK";
//jenkins任务
@Schema(description = "message.jenkins_ui_task")
String JENKINS_UI_TASK = "JENKINS_UI_TASK";
@Schema(description = "message.jenkins_api_scenario_task")
String JENKINS_API_SCENARIO_TASK = "JENKINS_API_SCENARIO_TASK";
@Schema(description = "message.jenkins_api_case_task")
String JENKINS_API_CASE_TASK = "JENKINS_API_CASE_TASK";
@Schema(description = "message.jenkins_load_case_task")
String JENKINS_LOAD_CASE_TASK = "JENKINS_LOAD_CASE_TASK";
@Schema(description = "message.jenkins_test_plan_task")
String JENKINS_TEST_PLAN_TASK = "JENKINS_TEST_PLAN_TASK";
@Schema(description = "message.jenkins_task")
String JENKINS_TASK = "JENKINS_TASK";
//定时任务
@Schema(description = "message.schedule_task")
String SCHEDULE_TASK = "SCHEDULE_TASK";
}
interface TriggerMode {
//定时任务
@Schema(description = "message.schedule_task")
String SCHEDULE_TASK = "SCHEDULE_TASK";
//批量执行
@Schema(description = "message.batch_execution")
String BATCH_EXECUTION = "BATCH_EXECUTION";
//手动执行
@Schema(description = "message.manual_execution")
String MANUAL_EXECUTION = "MANUAL_EXECUTION";
//测试计划
@Schema(description = "message.test_plan_task")
String TEST_PLAN_TASK = "TEST_PLAN_TASK";
//jenkins任务
@Schema(description = "message.jenkins_task")
String JENKINS_TASK = "JENKINS_TASK";
}
interface Mode {
String SCHEDULE = "SCHEDULE";
}
@ -97,6 +99,8 @@ public interface NoticeConstants {
@Schema(description = "message.jenkins_task_management")
String JENKINS_TASK_MANAGEMENT = "JENKINS_TASK_MANAGEMENT";
@Schema(description = "message.schedule_task_management")
String SCHEDULE_TASK_MANAGEMENT = "SCHEDULE_TASK_MANAGEMENT";
}
interface Type {
@ -119,14 +123,41 @@ public interface NoticeConstants {
@Schema(description = "message.delete")
String DELETE = "DELETE";
@Schema(description = "message.execute_successful")
String EXECUTE_SUCCESSFUL = "EXECUTE_SUCCESSFUL";
@Schema(description = "message.execute_failed")
String EXECUTE_FAILED = "EXECUTE_FAILED";
@Schema(description = "message.execute_completed")
String EXECUTE_COMPLETED = "EXECUTE_COMPLETED";
@Schema(description = "message.comment")
String COMMENT = "COMMENT";
@Schema(description = "message.execute_review")
String EXECUTE_REVIEW = "EXECUTE_REVIEW";
@Schema(description = "message.at")
String AT = "AT";
@Schema(description = "message.replay")
String REPLAY = "REPLAY";
@Schema(description = "message.review_passed")
String REVIEW_PASSED = "REVIEW_PASSED";
@Schema(description = "message.review_fail")
String REVIEW_FAIL = "REVIEW_FAIL";
@Schema(description = "message.review_at")
String REVIEW_AT = "REVIEW_AT";
@Schema(description = "message.execute_passed")
String EXECUTE_PASSED = "EXECUTE_PASSED";
@Schema(description = "message.execute_fail")
String EXECUTE_FAIL = "EXECUTE_FAIL";
@Schema(description = "message.execute_at")
String EXECUTE_AT = "EXECUTE_AT";
@Schema(description = "message.review_completed")
String REVIEW_COMPLETED = "REVIEW_COMPLETED";
@ -158,11 +189,11 @@ public interface NoticeConstants {
@Schema(description = "message.scenario_execute_failed")
String SCENARIO_EXECUTE_FAILED = "SCENARIO_EXECUTE_FAILED";
@Schema(description = "message.execute_successful")
String EXECUTE_SUCCESSFUL = "EXECUTE_SUCCESSFUL";
@Schema(description = "message.open")
String OPEN = "OPEN";
@Schema(description = "message.execute_failed")
String EXECUTE_FAILED = "EXECUTE_FAILED";
@Schema(description = "message.close")
String CLOSE = "CLOSE";
}
interface RelatedUser {
@ -184,6 +215,7 @@ public interface NoticeConstants {
String REPORT_FIELD = "REPORT_FIELD"; //报告字段
}
interface TemplateText {
@Schema(description = "message.test_plan_task_create")
String TEST_PLAN_TASK_CREATE = "TEST_PLAN_TASK_CREATE"; // ${OPERATOR}创建了测试计划:${name}
@ -191,10 +223,10 @@ public interface NoticeConstants {
String TEST_PLAN_TASK_UPDATE = "TEST_PLAN_TASK_UPDATE";// ${OPERATOR}更新了测试计划:${name}
@Schema(description = "message.test_plan_task_delete")
String TEST_PLAN_TASK_DELETE = "TEST_PLAN_TASK_DELETE";//${OPERATOR}删除了测试计划:${name}
@Schema(description = "message.test_plan_task_execute_completed")
String TEST_PLAN_TASK_EXECUTE_COMPLETED = "TEST_PLAN_TASK_EXECUTE_COMPLETED";//${OPERATOR}执行完成了测试计划:${name}
@Schema(description = "message.schedule_execute_completed_test_plan")
String TEST_PLAN_SCHEDULE_TASK_EXECUTE_COMPLETED = "TEST_PLAN_SCHEDULE_TASK_EXECUTE_COMPLETED";//${OPERATOR}通过定时任务执行了测试计划:${name}
@Schema(description = "message.test_plan_task_execute")
String TEST_PLAN_TASK_EXECUTE_SUCCESSFUL = "TEST_PLAN_TASK_EXECUTE_SUCCESSFUL";//${OPERATOR}执行了测试计划:${name}
@Schema(description = "message.test_plan_task_execute")
String TEST_PLAN_TASK_EXECUTE_FAILED = "TEST_PLAN_TASK_EXECUTE_FAILED";//${OPERATOR}通过定时任务执行了测试计划:${name}
@Schema(description = "message.test_plan_report_task_delete")
String TEST_PLAN_REPORT_TASK_DELETE = "TEST_PLAN_REPORT_TASK_DELETE";//${OPERATOR}删除了测试计划报告:${name}
@ -207,13 +239,11 @@ public interface NoticeConstants {
@Schema(description = "message.bug_task_comment")
String BUG_TASK_COMMENT = "BUG_TASK_COMMENT";//${OPERATOR}评论了你的缺陷:${title}
@Schema(description = "message.bug_task_at_comment")
String BUG_TASK_AT_COMMENT = "BUG_TASK_AT_COMMENT";//${OPERATOR}评论了缺陷:${title} 并@了你
String BUG_TASK_AT = "BUG_TASK_AT";//${OPERATOR}评论了缺陷:${title} 并@了你
@Schema(description = "message.bug_task_reply_comment")
String BUG_TASK_REPLY_COMMENT = "BUG_TASK_REPLY_COMMENT";//${OPERATOR}在缺陷${title} 回复了你的评论
String BUG_TASK_REPLY = "BUG_TASK_REPLY";//${OPERATOR}在缺陷${title} 回复了你的评论
@Schema(description = "message.bug_sync_task_execute_completed")
String BUG_SYNC_TASK_EXECUTE_COMPLETED = "BUG_SYNC_TASK_EXECUTE_COMPLETED";//${OPERATOR}同步了${total}条缺陷
@Schema(description = "message.bug_schedule_task_execute_completed")
String BUG_SCHEDULE_TASK_EXECUTE_COMPLETED = "BUG_SCHEDULE_TASK_EXECUTE_COMPLETED";//${OPERATOR}通过定时任务同步了${total}条缺陷
@Schema(description = "message.functional_case_task_create")
String FUNCTIONAL_CASE_TASK_CREATE = "FUNCTIONAL_CASE_TASK_CREATE"; // ${OPERATOR}创建了功能用例:${name}
@ -223,10 +253,22 @@ public interface NoticeConstants {
String FUNCTIONAL_CASE_TASK_DELETE = "FUNCTIONAL_CASE_TASK_DELETE";//${OPERATOR}删除了功能用例:${name}
@Schema(description = "message.functional_case_task_comment")
String FUNCTIONAL_CASE_TASK_COMMENT = "FUNCTIONAL_CASE_TASK_COMMENT";//${OPERATOR}评论了你的功能用例:${name}
@Schema(description = "message.functional_case_task_review")
String FUNCTIONAL_CASE_TASK_REVIEW_PASSED = "FUNCTIONAL_CASE_TASK_REVIEW_PASSED";//${OPERATOR}评审了${reviewName}${name}
@Schema(description = "message.functional_case_task_review")
String FUNCTIONAL_CASE_TASK_REVIEW_FAIL = "FUNCTIONAL_CASE_TASK_REVIEW_FAIL";//${OPERATOR}评审了${reviewName}${name}
@Schema(description = "message.functional_case_task_review_at")
String FUNCTIONAL_CASE_TASK_REVIEW_AT = "FUNCTIONAL_CASE_TASK_REVIEW_AT";//${OPERATOR}在${reviewName}${name} @了你
@Schema(description = "message.functional_case_task_plan")
String FUNCTIONAL_CASE_TASK_EXECUTE_PASSED = "FUNCTIONAL_CASE_TASK_EXECUTE_PASSED";//${OPERATOR}评审了${testPlanName}${name}
@Schema(description = "message.functional_case_task_plan")
String FUNCTIONAL_CASE_TASK_EXECUTE_FAIL = "FUNCTIONAL_CASE_TASK_EXECUTE_FAIL";//${OPERATOR}评审了${testPlanName}${name}
@Schema(description = "message.functional_case_task_plan_at")
String FUNCTIONAL_CASE_TASK_EXECUTE_AT = "FUNCTIONAL_CASE_TASK_EXECUTE_AT";//${OPERATOR}在${testPlanName}${name}@了你
@Schema(description = "message.functional_case_task_at_comment")
String FUNCTIONAL_CASE_TASK_AT_COMMENT = "FUNCTIONAL_CASE_TASK_AT_COMMENT";//${OPERATOR}评论了功能用例:${name} 并@了你
String FUNCTIONAL_CASE_TASK_AT = "FUNCTIONAL_CASE_TASK_AT";//${OPERATOR}评论了功能用例:${name} 并@了你
@Schema(description = "message.functional_case_task_reply_comment")
String FUNCTIONAL_CASE_TASK_REPLY_COMMENT = "FUNCTIONAL_CASE_TASK_REPLY_COMMENT";//${OPERATOR}在用例${name} 回复了你的评论
String FUNCTIONAL_CASE_TASK_REPLY = "FUNCTIONAL_CASE_TASK_REPLY";//${OPERATOR}在用例${name} 回复了你的评论
@Schema(description = "message.case_review_task_create")
String CASE_REVIEW_TASK_CREATE = "CASE_REVIEW_TASK_CREATE"; // ${OPERATOR}创建了用例评审:${name}
@ -234,11 +276,10 @@ public interface NoticeConstants {
String CASE_REVIEW_TASK_UPDATE = "CASE_REVIEW_TASK_UPDATE";//${OPERATOR}更新了用例评审:${name}
@Schema(description = "message.case_review_task_delete")
String CASE_REVIEW_TASK_DELETE = "CASE_REVIEW_TASK_DELETE";//${OPERATOR}删除了用例评审:${name}
@Schema(description = "message.case_review_task_execute_review")
String CASE_REVIEW_TASK_EXECUTE_REVIEW = "CASE_REVIEW_TASK_EXECUTE_REVIEW";//${OPERATOR}评审了功能用例:${name}
@Schema(description = "message.case_review_task_review_completed")
String CASE_REVIEW_TASK_REVIEW_COMPLETED = "CASE_REVIEW_TASK_REVIEW_COMPLETED";//${OPERATOR}完成了用例评审:${name}
@Schema(description = "message.api_definition_task_create")
String API_DEFINITION_TASK_CREATE = "API_DEFINITION_TASK_CREATE";//${OPERATOR}创建了接口文档:${name}
@Schema(description = "message.api_definition_task_update")
@ -270,8 +311,6 @@ public interface NoticeConstants {
String API_SCENARIO_TASK_SCENARIO_EXECUTE_FAKE_ERROR = "API_SCENARIO_TASK_SCENARIO_EXECUTE_FAKE_ERROR";//${OPERATOR}执行了接口场景:${name}
@Schema(description = "message.api_scenario_task_scenario_execute")
String API_SCENARIO_TASK_SCENARIO_EXECUTE_FAILED = "API_SCENARIO_TASK_SCENARIO_EXECUTE_FAILED";//${OPERATOR}执行了接口场景:${name}
@Schema(description = "message.api_schedule_task_execute_completed")
String API_SCHEDULE_TASK_EXECUTE_COMPLETED = "API_SCHEDULE_TASK_EXECUTE_COMPLETED";//${OPERATOR}通过定时任务执行了接口场景:${name}
@Schema(description = "message.api_report_task_delete")
String API_REPORT_TASK_DELETE = "API_REPORT_TASK_DELETE";//${OPERATOR}删除了接口报告:${name}
@ -285,8 +324,6 @@ public interface NoticeConstants {
String UI_SCENARIO_TASK_EXECUTE_SUCCESSFUL = "UI_SCENARIO_TASK_EXECUTE_SUCCESSFUL";//${OPERATOR}执行了UI用例:${name}
@Schema(description = "message.ui_scenario_task_execute")
String UI_SCENARIO_TASK_EXECUTE_FAILED = "UI_SCENARIO_TASK_EXECUTE_FAILED";//${OPERATOR}执行了UI用例:${name}
@Schema(description = "message.ui_schedule_task_execute_completed")
String UI_SCHEDULE_TASK_EXECUTE_COMPLETED = "UI_SCHEDULE_TASK_EXECUTE_COMPLETED";//${OPERATOR}通过定时任务执行了UI用例:${name}
@Schema(description = "message.ui_report_task_delete")
String UI_REPORT_TASK_DELETE = "UI_REPORT_TASK_DELETE";//${OPERATOR}删除了UI报告:${name}
@ -298,31 +335,18 @@ public interface NoticeConstants {
String LOAD_TEST_TASK_DELETE = "LOAD_TEST_TASK_DELETE";//${OPERATOR}删除了性能用例:${name}
@Schema(description = "message.load_test_task_execute_completed")
String LOAD_TEST_TASK_EXECUTE_COMPLETED = "LOAD_TEST_TASK_EXECUTE_COMPLETED";//${OPERATOR}执行了性能用例:${name}
@Schema(description = "message.load_schedule_task_execute_completed")
String LOAD_SCHEDULE_TASK_EXECUTE_COMPLETED = "LOAD_SCHEDULE_TASK_EXECUTE_COMPLETED";//${OPERATOR}通过定时任务执行了性能用例:${name}
@Schema(description = "message.load_report_task_delete")
String LOAD_REPORT_TASK_DELETE = "LOAD_REPORT_TASK_DELETE";//${OPERATOR}删除了性能报告:${name}
@Schema(description = "message.jenkins_api_scenario_task_execute")
String JENKINS_API_SCENARIO_TASK_EXECUTE_SUCCESSFUL = "JENKINS_API_SCENARIO_TASK_EXECUTE_SUCCESSFUL";//Jenkins执行了接口场景:${name}
@Schema(description = "message.jenkins_api_scenario_task_execute")
String JENKINS_API_SCENARIO_TASK_EXECUTE_FAILED = "JENKINS_API_SCENARIO_TASK_EXECUTE_FAILED";//Jenkins执行了接口场景:${name}
@Schema(description = "message.jenkins_api_case_task_execute")
String JENKINS_API_CASE_TASK_EXECUTE_SUCCESSFUL = "JENKINS_API_CASE_TASK_EXECUTE_SUCCESSFUL";//Jenkins执行了接口用例:${name}
@Schema(description = "message.jenkins_api_case_task_execute")
String JENKINS_API_CASE_TASK_EXECUTE_FAILED = "JENKINS_API_CASE_TASK_EXECUTE_FAILED";//Jenkins执行了接口用例:${name}
@Schema(description = "message.jenkins_load_case_task_execute")
String JENKINS_LOAD_CASE_TASK_EXECUTE_SUCCESSFUL = "JENKINS_LOAD_CASE_TASK_EXECUTE_SUCCESSFUL";//Jenkins执行了性能用例:${name}
@Schema(description = "message.jenkins_load_case_task_execute")
String JENKINS_LOAD_CASE_TASK_EXECUTE_FAILED = "JENKINS_LOAD_CASE_TASK_EXECUTE_FAILED";//Jenkins执行了性能用例:${name}
@Schema(description = "message.jenkins_test_plan_task_execute")
String JENKINS_TEST_PLAN_TASK_EXECUTE_SUCCESSFUL = "JENKINS_TEST_PLAN_TASK_EXECUTE_SUCCESSFUL";//Jenkins执行了测试计划:${name}
@Schema(description = "message.jenkins_test_plan_task_execute")
String JENKINS_TEST_PLAN_TASK_EXECUTE_FAILED = "JENKINS_TEST_PLAN_TASK_EXECUTE_FAILED";//Jenkins执行了测试计划:${name}
@Schema(description = "message.jenkins_ui_task_execute")
String JENKINS_UI_TASK_EXECUTE_SUCCESSFUL = "JENKINS_UI_TASK_EXECUTE_SUCCESSFUL";//Jenkins执行了UI用例:${name}
@Schema(description = "message.jenkins_ui_task_execute")
String JENKINS_UI_TASK_EXECUTE_FAILED = "JENKINS_UI_TASK_EXECUTE_FAILED";//Jenkins执行了UI用例:${name}
@Schema(description = "message.jenkins_task_execute")
String JENKINS_TASK_EXECUTE_SUCCESSFUL = "JENKINS_TASK_EXECUTE_SUCCESSFUL";//Jenkins执行了接口场景:${name}
@Schema(description = "message.jenkins_task_execute")
String JENKINS_TASK_EXECUTE_FAILED = "JENKINS_TASK_EXECUTE_FAILED";//Jenkins执行了接口场景:${name}
@Schema(description = "message.schedule_task_open")
String SCHEDULE_TASK_OPEN = "SCHEDULE_TASK_OPEN";//Jenkins执行了接口场景:${name}
@Schema(description = "message.schedule_task_close")
String SCHEDULE_TASK_CLOSE = "SCHEDULE_TASK_CLOSE";//Jenkins执行了接口场景:${name}
}
@ -333,10 +357,10 @@ public interface NoticeConstants {
String TEST_PLAN_TASK_UPDATE = "TEST_PLAN_TASK_UPDATE";// 测试计划更新通知
@Schema(description = "message.title.test_plan_task_delete")
String TEST_PLAN_TASK_DELETE = "TEST_PLAN_TASK_DELETE";//测试计划删除通知
@Schema(description = "message.title.test_plan_task_execute_completed")//测试计划执行完成通知
String TEST_PLAN_TASK_EXECUTE_COMPLETED = "TEST_PLAN_TASK_EXECUTE_COMPLETED";
@Schema(description = "message.title.test_plan_task_execute_completed")//测试计划执行完成通知
String TEST_PLAN_SCHEDULE_TASK_EXECUTE_COMPLETED = "TEST_PLAN_SCHEDULE_TASK_EXECUTE_COMPLETED";
@Schema(description = "message.title.test_plan_task_execute_success")//测试计划执行成功通知
String TEST_PLAN_TASK_EXECUTE_SUCCESSFUL = "TEST_PLAN_TASK_EXECUTE_SUCCESSFUL";
@Schema(description = "message.title.test_plan_task_execute_failed")//测试计划执行失败通知
String TEST_PLAN_TASK_EXECUTE_FAILED = "TEST_PLAN_TASK_EXECUTE_FAILED";
@Schema(description = "message.title.test_plan_report_task_delete")//测试计划报告删除通知
String TEST_PLAN_REPORT_TASK_DELETE = "TEST_PLAN_REPORT_TASK_DELETE";
@ -349,11 +373,12 @@ public interface NoticeConstants {
@Schema(description = "message.title.bug_task_comment")//缺陷评论通知
String BUG_TASK_COMMENT = "BUG_TASK_COMMENT";
@Schema(description = "message.title.bug_task_comment")//缺陷评论通知
String BUG_TASK_AT_COMMENT = "BUG_TASK_AT_COMMENT";
String BUG_TASK_AT = "BUG_TASK_AT";
@Schema(description = "message.title.bug_task_comment")//缺陷评论通知
String BUG_TASK_REPLY = "BUG_TASK_REPLY";
@Schema(description = "message.title.bug_sync_task_execute_completed")//同步缺陷执行完成通知
String BUG_SYNC_TASK_EXECUTE_COMPLETED = "BUG_SYNC_TASK_EXECUTE_COMPLETED";
@Schema(description = "message.title.bug_sync_task_execute_completed")//同步缺陷执行完成通知
String BUG_SCHEDULE_TASK_EXECUTE_COMPLETED = "BUG_SCHEDULE_TASK_EXECUTE_COMPLETED";
@Schema(description = "message.title.functional_case_task_create")//功能用例创建通知
String FUNCTIONAL_CASE_TASK_CREATE = "FUNCTIONAL_CASE_TASK_CREATE";
@ -363,8 +388,23 @@ public interface NoticeConstants {
String FUNCTIONAL_CASE_TASK_DELETE = "FUNCTIONAL_CASE_TASK_DELETE";
@Schema(description = "message.title.functional_case_task_comment")//功能用例评论通知
String FUNCTIONAL_CASE_TASK_COMMENT = "FUNCTIONAL_CASE_TASK_COMMENT";
@Schema(description = "message.title.functional_case_task_comment")//功能用例评论通知
String FUNCTIONAL_CASE_TASK_AT_COMMENT = "FUNCTIONAL_CASE_TASK_AT_COMMENT";
@Schema(description = "message.title.functional_case_task_comment")
String FUNCTIONAL_CASE_TASK_AT = "FUNCTIONAL_CASE_TASK_AT";//功能用例评论通知
@Schema(description = "message.title.functional_case_task_comment")
String FUNCTIONAL_CASE_TASK_REPLY = "FUNCTIONAL_CASE_TASK_REPLY";//功能用例评论通知
@Schema(description = "message.title.functional_case_task_review_passed")
String FUNCTIONAL_CASE_TASK_REVIEW_PASSED = "FUNCTIONAL_CASE_TASK_REVIEW_PASSED";//用例评审通过通知
@Schema(description = "message.title.functional_case_task_review_fail")
String FUNCTIONAL_CASE_TASK_REVIEW_FAIL = "FUNCTIONAL_CASE_TASK_REVIEW_FAIL";//用例评审不通过通知
@Schema(description = "message.title.functional_case_task_review_at")
String FUNCTIONAL_CASE_TASK_REVIEW_AT = "FUNCTIONAL_CASE_TASK_REVIEW_AT";//用例评审通知
@Schema(description = "message.title.functional_case_task_execute_passed")
String FUNCTIONAL_CASE_TASK_EXECUTE_PASSED = "FUNCTIONAL_CASE_TASK_EXECUTE_PASSED";//用例执行通过通知
@Schema(description = "message.title.functional_case_task_execute_fail")
String FUNCTIONAL_CASE_TASK_EXECUTE_FAIL = "FUNCTIONAL_CASE_TASK_EXECUTE_FAIL";//用例执行不通过通知
@Schema(description = "message.title.functional_case_task_execute_at")
String FUNCTIONAL_CASE_TASK_EXECUTE_AT = "FUNCTIONAL_CASE_TASK_EXECUTE_AT";//用例执行通知
@Schema(description = "message.title.case_review_task_create")//用例评审创建通知
String CASE_REVIEW_TASK_CREATE = "CASE_REVIEW_TASK_CREATE";
@ -372,11 +412,10 @@ public interface NoticeConstants {
String CASE_REVIEW_TASK_UPDATE = "CASE_REVIEW_TASK_UPDATE";
@Schema(description = "message.title.case_review_task_delete")//用例评审删除通知
String CASE_REVIEW_TASK_DELETE = "CASE_REVIEW_TASK_DELETE";
@Schema(description = "message.title.case_review_task_execute_review")//用例评审执行通知
String CASE_REVIEW_TASK_EXECUTE_REVIEW = "CASE_REVIEW_TASK_EXECUTE_REVIEW";
@Schema(description = "message.title.case_review_task_review_completed")//用例评审评审完成通知
String CASE_REVIEW_TASK_REVIEW_COMPLETED = "CASE_REVIEW_TASK_REVIEW_COMPLETED";
@Schema(description = "message.title.api_definition_task_create")//接口文档创建通知
String API_DEFINITION_TASK_CREATE = "API_DEFINITION_TASK_CREATE";
@Schema(description = "message.title.api_definition_task_update")//接口文档更新通知
@ -408,8 +447,6 @@ public interface NoticeConstants {
String API_SCENARIO_TASK_SCENARIO_EXECUTE_FAKE_ERROR = "API_SCENARIO_TASK_SCENARIO_EXECUTE_FAKE_ERROR";
@Schema(description = "message.title.api_scenario_task_scenario_execute_failed")//接口场景执行失败通知
String API_SCENARIO_TASK_SCENARIO_EXECUTE_FAILED = "API_SCENARIO_TASK_SCENARIO_EXECUTE_FAILED";
@Schema(description = "message.title.api_schedule_task_execute_completed")//接口场景执行完成通知
String API_SCHEDULE_TASK_EXECUTE_COMPLETED = "API_SCHEDULE_TASK_EXECUTE_COMPLETED";
@Schema(description = "message.title.api_report_task_delete")//接口报告删除通知
String API_REPORT_TASK_DELETE = "API_REPORT_TASK_DELETE";
@ -423,8 +460,6 @@ public interface NoticeConstants {
String UI_SCENARIO_TASK_EXECUTE_SUCCESSFUL = "UI_SCENARIO_TASK_EXECUTE_SUCCESSFUL";
@Schema(description = "message.title.ui_scenario_task_execute_failed")//UI用例执行失败通知
String UI_SCENARIO_TASK_EXECUTE_FAILED = "UI_SCENARIO_TASK_EXECUTE_FAILED";
@Schema(description = "message.title.ui_schedule_task_execute_completed")//UI执行完成通知
String UI_SCHEDULE_TASK_EXECUTE_COMPLETED = "UI_SCHEDULE_TASK_EXECUTE_COMPLETED";
@Schema(description = "message.title.ui_report_task_delete")//UI报告删除通知
String UI_REPORT_TASK_DELETE = "UI_REPORT_TASK_DELETE";
@ -436,8 +471,6 @@ public interface NoticeConstants {
String LOAD_TEST_TASK_DELETE = "LOAD_TEST_TASK_DELETE";
@Schema(description = "message.title.load_test_task_execute_completed")//性能用例执行完成通知
String LOAD_TEST_TASK_EXECUTE_COMPLETED = "LOAD_TEST_TASK_EXECUTE_COMPLETED";
@Schema(description = "message.title.load_test_task_execute_completed")//性能用例执行完成通知
String LOAD_SCHEDULE_TASK_EXECUTE_COMPLETED = "LOAD_SCHEDULE_TASK_EXECUTE_COMPLETED";
@Schema(description = "message.title.load_report_task_delete")//性能报告删除通知
String LOAD_REPORT_TASK_DELETE = "LOAD_REPORT_TASK_DELETE";
@ -446,26 +479,11 @@ public interface NoticeConstants {
@Schema(description = "message.title.jenkins_task_execute_failed")//Jenkins任务执行失败通知
String JENKINS_TASK_EXECUTE_FAILED = "JENKINS_TASK_EXECUTE_FAILED";
@Schema(description = "message.title.jenkins_api_scenario_task_execute_successful")
String JENKINS_API_SCENARIO_TASK_EXECUTE_SUCCESSFUL = "JENKINS_API_SCENARIO_TASK_EXECUTE_SUCCESSFUL";//Jenkins执行接口场景成功通知
@Schema(description = "message.title.jenkins_api_scenario_task_execute_failed")
String JENKINS_API_SCENARIO_TASK_EXECUTE_FAILED = "JENKINS_API_SCENARIO_TASK_EXECUTE_FAILED";//Jenkins执行接口场景失败通知
@Schema(description = "message.title.jenkins_api_case_task_execute_successful")
String JENKINS_API_CASE_TASK_EXECUTE_SUCCESSFUL = "JENKINS_API_CASE_TASK_EXECUTE_SUCCESSFUL";//Jenkins执行接口用例成功通知
@Schema(description = "message.title.jenkins_api_case_task_execute_failed")
String JENKINS_API_CASE_TASK_EXECUTE_FAILED = "JENKINS_API_CASE_TASK_EXECUTE_FAILED";//Jenkins执行接口用例失败通知
@Schema(description = "message.title.jenkins_load_case_task_execute_successful")
String JENKINS_LOAD_CASE_TASK_EXECUTE_SUCCESSFUL = "JENKINS_LOAD_CASE_TASK_EXECUTE_SUCCESSFUL";//Jenkins执行性能用例成功通知
@Schema(description = "message.title.jenkins_load_case_task_execute_failed")
String JENKINS_LOAD_CASE_TASK_EXECUTE_FAILED = "JENKINS_LOAD_CASE_TASK_EXECUTE_FAILED";//Jenkins执行性能用例失败通知
@Schema(description = "message.title.jenkins_test_plan_task_execute_successful")
String JENKINS_TEST_PLAN_TASK_EXECUTE_SUCCESSFUL = "JENKINS_TEST_PLAN_TASK_EXECUTE_SUCCESSFUL";//Jenkins执行测试计划成功通知
@Schema(description = "message.title.jenkins_test_plan_task_execute_failed")
String JENKINS_TEST_PLAN_TASK_EXECUTE_FAILED = "JENKINS_TEST_PLAN_TASK_EXECUTE_FAILED";//Jenkins执行测试计划失败通知
@Schema(description = "message.title.jenkins_ui_task_execute_successful")
String JENKINS_UI_TASK_EXECUTE_SUCCESSFUL = "JENKINS_UI_TASK_EXECUTE_SUCCESSFUL";//Jenkins执行UI用例成功通知
@Schema(description = "message.title.jenkins_ui_task_execute_failed")
String JENKINS_UI_TASK_EXECUTE_FAILED = "JENKINS_UI_TASK_EXECUTE_FAILED";//Jenkins执行UI用例失败通知
@Schema(description = "message.title.schedule_task_open")//定时任务开启通知
String SCHEDULE_TASK_OPEN = "SCHEDULE_TASK_OPEN";
@Schema(description = "message.title.schedule_task_close")//定时任务关闭通知
String SCHEDULE_TASK_CLOSE = "SCHEDULE_TASK_CLOSE";
}
interface SensitiveField {

5
backend/services/system-setting/src/main/java/io/metersphere/system/notice/sender/AfterReturningNoticeSendService.java
View File

@ -5,6 +5,7 @@ import io.metersphere.sdk.dto.BaseSystemConfigDTO;
import io.metersphere.sdk.dto.SessionUser;
import io.metersphere.system.notice.annotation.SendNotice;
import io.metersphere.system.notice.NoticeModel;
import io.metersphere.system.notice.constants.NoticeConstants;
import io.metersphere.system.notice.utils.MessageTemplateUtils;
import io.metersphere.system.service.NoticeSendService;
import io.metersphere.system.service.SystemParameterService;
@ -32,9 +33,11 @@ public class AfterReturningNoticeSendService {
for (Map resource : resources) {
Map paramMap = new HashMap<>();
paramMap.put("url", baseSystemConfigDTO.getUrl());
paramMap.put("operator", sessionUser.getName());
paramMap.put(NoticeConstants.RelatedUser.OPERATOR, sessionUser.getName());
paramMap.putAll(resource);
paramMap.putIfAbsent("projectId", currentProjectId);
//TODO: 加来源处理
// 占位符
handleDefaultValues(paramMap);

21
backend/services/system-setting/src/main/java/io/metersphere/system/notice/utils/MessageTemplateUtils.java
View File

@ -8,6 +8,7 @@ import io.metersphere.functional.domain.FunctionalCase;
import io.metersphere.load.domain.LoadTest;
import io.metersphere.plan.domain.TestPlan;
import io.metersphere.sdk.util.Translator;
import io.metersphere.system.domain.Schedule;
import io.metersphere.system.notice.constants.NoticeConstants;
import io.metersphere.ui.domain.UiScenario;
import io.swagger.v3.oas.annotations.media.Schema;
@ -135,15 +136,15 @@ public class MessageTemplateUtils {
public static Field[] getDomainTemplateFields(String taskType) {
Field[] allFields;
switch (taskType) {
case NoticeConstants.TaskType.API_DEFINITION_TASK, NoticeConstants.TaskType.JENKINS_API_CASE_TASK -> {
case NoticeConstants.TaskType.API_DEFINITION_TASK -> {
allFields = FieldUtils.getAllFields(ApiDefinition.class);
}
case NoticeConstants.TaskType.API_SCENARIO_TASK, NoticeConstants.TaskType.API_SCHEDULE_TASK, NoticeConstants.TaskType.JENKINS_API_SCENARIO_TASK -> {
case NoticeConstants.TaskType.API_SCENARIO_TASK -> {
allFields = FieldUtils.getAllFields(ApiScenario.class);
}
case NoticeConstants.TaskType.TEST_PLAN_TASK, NoticeConstants.TaskType.JENKINS_TEST_PLAN_TASK -> {
case NoticeConstants.TaskType.TEST_PLAN_TASK -> {
allFields = FieldUtils.getAllFields(TestPlan.class);
}
@ -156,12 +157,15 @@ public class MessageTemplateUtils {
case NoticeConstants.TaskType.BUG_TASK -> {
allFields = FieldUtils.getAllFields(Bug.class);
}
case NoticeConstants.TaskType.UI_SCENARIO_TASK, NoticeConstants.TaskType.JENKINS_UI_TASK -> {
case NoticeConstants.TaskType.UI_SCENARIO_TASK -> {
allFields = FieldUtils.getAllFields(UiScenario.class);
}
case NoticeConstants.TaskType.LOAD_TEST_TASK, NoticeConstants.TaskType.JENKINS_LOAD_CASE_TASK -> {
case NoticeConstants.TaskType.LOAD_TEST_TASK -> {
allFields = FieldUtils.getAllFields(LoadTest.class);
}
case NoticeConstants.TaskType.SCHEDULE_TASK -> {
allFields = FieldUtils.getAllFields(Schedule.class);
}
default -> allFields = new Field[0];
}
@ -196,6 +200,12 @@ public class MessageTemplateUtils {
}
public static String getTranslateTemplate(String taskType, String template) {
if (StringUtils.equalsIgnoreCase(taskType, NoticeConstants.TaskType.JENKINS_TASK)) {
if (StringUtils.isNotBlank(template) && template.contains("${name}")) {
template = template.replace("${name}", "<"+Translator.get("message.jenkins_name")+">");
}
return template;
} else {
Field[] domainTemplateFields = getDomainTemplateFields(taskType);
Map<String, Object> map = new HashMap<>();
if (StringUtils.isNotBlank(template) && template.contains("${OPERATOR}")) {
@ -217,3 +227,4 @@ public class MessageTemplateUtils {
return getContent(template, map);
}
}
}