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

2023-10-17 09:29:45 +08:00 · 2023-10-17 09:29:45 +08:00 · e69b0bb25a
parent bc9cada46e
commit e69b0bb25a
14 changed files with 746 additions and 604 deletions
--- a/backend/framework/domain/src/main/resources/migration/3.0.0/dml/V3.0.0_11_1__data.sql
+++ b/backend/framework/domain/src/main/resources/migration/3.0.0/dml/V3.0.0_11_1__data.sql
@ -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;
--- a/backend/framework/sdk/src/main/resources/i18n/project.properties
+++ b/backend/framework/sdk/src/main/resources/i18n/project.properties
@ -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
--- a/backend/framework/sdk/src/main/resources/i18n/project_en_US.properties
+++ b/backend/framework/sdk/src/main/resources/i18n/project_en_US.properties
@ -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,71 +197,77 @@ 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_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}
-message.bug_task_delete=${OPERATOR}deleted a bug: ${title}
-message.bug_task_comment=${OPERATOR}commented on your bug: ${title}
-message.bug_task_at_comment=${OPERATOR}commented on the bug: ${title} and @you
+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=${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}
+message.bug_task_delete=${OPERATOR} deleted a bug: ${title}
+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_at_comment=${OPERATOR}commented on functional case: ${name} and @you
+message.bug_sync_task_execute_completed=${OPERATOR} synchronized ${total} bugs
+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}
-message.api_definition_task_delete=${OPERATOR}deleted the API documentation: ${name}
-message.api_definition_task_case_create=${OPERATOR}created the API case: ${name}
-message.api_definition_task_case_update=${OPERATOR}updated the API case: ${name}
-message.api_definition_task_case_delete=${OPERATOR}deleted the API case: ${name}
-message.api_definition_task_case_execute=${OPERATOR}executed the API case: ${name}
-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.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_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}
+message.api_definition_task_delete=${OPERATOR} deleted the API documentation: ${name}
+message.api_definition_task_case_create=${OPERATOR} created the API case: ${name}
+message.api_definition_task_case_update=${OPERATOR} updated the API case: ${name}
+message.api_definition_task_case_delete=${OPERATOR} deleted the API case: ${name}
+message.api_definition_task_case_execute=${OPERATOR} executed the API case: ${name}
+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_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_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_report_task_delete=${OPERATOR} deleted load report: ${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

--- a/backend/framework/sdk/src/main/resources/i18n/project_zh_CN.properties
+++ b/backend/framework/sdk/src/main/resources/i18n/project_zh_CN.properties
@ -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
--- a/backend/framework/sdk/src/main/resources/i18n/project_zh_TW.properties
+++ b/backend/framework/sdk/src/main/resources/i18n/project_zh_TW.properties
@ -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=文件模塊不存在
--- a/backend/services/project-management/src/main/java/io/metersphere/project/dto/ApiDefinitionCaseDTO.java
+++ b/backend/services/project-management/src/main/java/io/metersphere/project/dto/ApiDefinitionCaseDTO.java
@ -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;
+
+
+
+}
--- a/backend/services/project-management/src/main/java/io/metersphere/project/dto/FunctionalCaseMessageDTO.java
+++ b/backend/services/project-management/src/main/java/io/metersphere/project/dto/FunctionalCaseMessageDTO.java
@ -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;
+
+}
--- a/backend/services/project-management/src/main/java/io/metersphere/project/service/NoticeMessageTaskService.java
+++ b/backend/services/project-management/src/main/java/io/metersphere/project/service/NoticeMessageTaskService.java
@ -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) {
--- a/backend/services/project-management/src/main/java/io/metersphere/project/service/NoticeTemplateService.java
+++ b/backend/services/project-management/src/main/java/io/metersphere/project/service/NoticeTemplateService.java
@ -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) {
--- a/backend/services/project-management/src/main/resources/message_task.json
+++ b/backend/services/project-management/src/main/resources/message_task.json
@ -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
+              }
+            ]
+          }
+        ]
+      }
+    ]
  }
 ]
--- a/backend/services/project-management/src/test/java/io/metersphere/project/controller/NoticeTemplateControllerTests.java
+++ b/backend/services/project-management/src/test/java/io/metersphere/project/controller/NoticeTemplateControllerTests.java
@ -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);
--- a/backend/services/system-setting/src/main/java/io/metersphere/system/notice/constants/NoticeConstants.java
+++ b/backend/services/system-setting/src/main/java/io/metersphere/system/notice/constants/NoticeConstants.java
@ -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 {
--- a/backend/services/system-setting/src/main/java/io/metersphere/system/notice/sender/AfterReturningNoticeSendService.java
+++ b/backend/services/system-setting/src/main/java/io/metersphere/system/notice/sender/AfterReturningNoticeSendService.java
@ -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);

--- a/backend/services/system-setting/src/main/java/io/metersphere/system/notice/utils/MessageTemplateUtils.java
+++ b/backend/services/system-setting/src/main/java/io/metersphere/system/notice/utils/MessageTemplateUtils.java
@ -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,24 +200,31 @@ public class MessageTemplateUtils {
    }

    public static String getTranslateTemplate(String taskType, String template) {
-        Field[] domainTemplateFields = getDomainTemplateFields(taskType);
-        Map<String, Object> map = new HashMap<>();
-        if (StringUtils.isNotBlank(template) && template.contains("${OPERATOR}")) {
-            template = template.replace("${OPERATOR}", "<"+Translator.get("message.operator")+">");
-        }
-        if (StringUtils.isNotBlank(template) && template.contains("${total}")) {
-            template = template.replace("${total}", "<n>");
-        }
-        for (Field allField : domainTemplateFields) {
-            Schema annotation = allField.getAnnotation(Schema.class);
-            if (annotation != null) {
-                String description = annotation.description();
-                if (StringUtils.equals(allField.getName(), "name") || StringUtils.equals(allField.getName(), "title")) {
-                    description = "{{" + description + "}}";
-                }
-                map.put(allField.getName(), description);
+        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}")) {
+                template = template.replace("${OPERATOR}", "<"+Translator.get("message.operator")+">");
+            }
+            if (StringUtils.isNotBlank(template) && template.contains("${total}")) {
+                template = template.replace("${total}", "<n>");
+            }
+            for (Field allField : domainTemplateFields) {
+                Schema annotation = allField.getAnnotation(Schema.class);
+                if (annotation != null) {
+                    String description = annotation.description();
+                    if (StringUtils.equals(allField.getName(), "name") || StringUtils.equals(allField.getName(), "title")) {
+                        description = "{{" + description + "}}";
+                    }
+                    map.put(allField.getName(), description);
+                }
+            }
+            return getContent(template, map);
        }
-        return getContent(template, map);
    }
 }