【feat】【v3】

1.修改表结构及其对应实体类

doc/sql/update-v3.sql

@@ -1,6 +1,6 @@
-CREATE TABLE `new_user_stats` (
+CREATE TABLE `stat_new_user` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
-  `stats_time` char(10) NOT NULL COMMENT '统计时间（格式：yyyy-MM-dd）',
+  `stat_time` char(10) NOT NULL COMMENT '统计时间（格式：yyyy-MM-dd）',
   `new_user_count` int NOT NULL COMMENT '新用户数量',
   `created_by` bigint NOT NULL COMMENT '创建人',
   `creation_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
@@ -9,13 +9,13 @@ CREATE TABLE `new_user_stats` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_NewUserStats_StatsTime` (`stats_time`)
+  KEY `idx_NewUserStat_StatTime` (`stat_time`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='新用户数据统计';
 
-CREATE TABLE `points_stats` (
+CREATE TABLE `stat_points` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
   `user_id` bigint NOT NULL COMMENT '用户id',
-  `stats_time` char(10) NOT NULL COMMENT '统计时间（格式：yyyy-MM-dd）',
+  `stat_time` char(10) NOT NULL COMMENT '统计时间（格式：yyyy-MM-dd）',
   `settle_points` int NOT NULL COMMENT '每日积分的结算数',
   `consume_points` int NOT NULL COMMENT '每日积分的消耗数量',
   `total_points` int NOT NULL COMMENT '每日剩余总积分',
@@ -26,8 +26,8 @@ CREATE TABLE `points_stats` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_PointsStats_StatsTime` (`stats_time`),
-  KEY `idx_PointsStats_UserId` (`user_id`)
+  KEY `idx_PointsStat_StatsTime` (`stat_time`),
+  KEY `idx_PointsStat_UserId` (`user_id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='积分数据统计';
 
 CREATE TABLE `reward` (
@@ -87,11 +87,11 @@ CREATE TABLE `reward_history` (
   KEY `idx_RewardHis_CreationTime` (`creation_time`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='奖励兑换记录';
 
-CREATE TABLE `punch_in_stats_week` (
+CREATE TABLE `stat_pi_task_week` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
   `user_id` bigint NOT NULL COMMENT '用户id',
   `task_unique_id` bigint NOT NULL COMMENT '任务唯一ID',
-  `stats_time` char(7) NOT NULL COMMENT '统计时间（格式：yyyy-周数）',
+  `stat_time` char(7) NOT NULL COMMENT '统计时间（格式：yyyy-周数）',
   `punch_in_total_count` int NOT NULL COMMENT '本周需打卡数',
   `punch_in_count` int NOT NULL COMMENT '本周已打卡数',
   `punch_in_done_count` int NOT NULL COMMENT '本周完成打卡数',
@@ -105,16 +105,16 @@ CREATE TABLE `punch_in_stats_week` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_PIStatsMonth_UserId` (`user_id`),
-  KEY `idx_PIStatsMonth_TaskUniqueId` (`task_unique_id`),
-  KEY `idx_PIStatsMonth_StatsTime` (`stats_time`)
+  KEY `idx_StatPiTaskWeek_UserId` (`user_id`),
+  KEY `idx_StatPiTaskWeek_TUniqueId` (`task_unique_id`),
+  KEY `idx_StatPiTaskWeek_StatTime` (`stat_time`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='打卡任务周数据统计';
 
-CREATE TABLE `punch_in_stats_month` (
+CREATE TABLE `stat_pi_task_month` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
   `user_id` bigint NOT NULL COMMENT '用户id',
   `task_unique_id` bigint NOT NULL COMMENT '任务唯一ID',
-  `stats_time` char(7) NOT NULL COMMENT '统计时间（格式：yyyy-MM）',
+  `stat_time` char(7) NOT NULL COMMENT '统计时间（格式：yyyy-MM）',
   `punch_in_total_count` int NOT NULL COMMENT '本月需打卡数',
   `punch_in_count` int NOT NULL COMMENT '本月已打卡数',
   `punch_in_done_count` int NOT NULL COMMENT '本月完成打卡数',
@@ -128,16 +128,16 @@ CREATE TABLE `punch_in_stats_month` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_PIStatsMonth_UserId` (`user_id`),
-  KEY `idx_PIStatsMonth_TaskUniqueId` (`task_unique_id`),
-  KEY `idx_PIStatsMonth_StatsTime` (`stats_time`)
+  KEY `idx_StatPiTaskMonth_UserId` (`user_id`),
+  KEY `idx_StatPiTaskMonth_TUniqueId` (`task_unique_id`),
+  KEY `idx_StatPiTaskMonth_StatTime` (`stat_time`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='打卡任务月数据统计';
 
-CREATE TABLE `punch_in_stats_year` (
+CREATE TABLE `stat_pi_task_year` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
   `user_id` bigint NOT NULL COMMENT '用户id',
   `task_unique_id` bigint NOT NULL COMMENT '任务唯一ID',
-  `stats_time` char(4) NOT NULL COMMENT '统计时间（格式：yyyy）',
+  `stat_time` char(4) NOT NULL COMMENT '统计时间（格式：yyyy）',
   `punch_in_total_count` int NOT NULL COMMENT '本年需打卡数',
   `punch_in_count` int NOT NULL COMMENT '本年已打卡数',
   `punch_in_done_count` int NOT NULL COMMENT '本年完成打卡数',
@@ -151,9 +151,9 @@ CREATE TABLE `punch_in_stats_year` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_PIStatsYear_UserId` (`user_id`),
-  KEY `idx_PIStatsYear_TaskUniqueId` (`task_unique_id`),
-  KEY `idx_PIStatsYear_StatsTime` (`stats_time`)
+  KEY `idx_StatPiTaskYear_UserId` (`user_id`),
+  KEY `idx_StatPiTaskYear_TUniqueId` (`task_unique_id`),
+  KEY `idx_StatPiTaskYear_StatTime` (`stat_time`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='打卡任务年数据统计';
 
 CREATE TABLE `account` (
@@ -211,11 +211,11 @@ CREATE TABLE `item_consume_win_history` (
   KEY `idx_ICWHis_CreationTime` (`creation_time`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='物品消费与中奖记录';
 
-CREATE TABLE `punch_in_task_ext` (
+CREATE TABLE `pi_task_ext` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
   `user_id` bigint NOT NULL COMMENT '用户ID',
-  `punch_in_task_id` bigint NOT NULL COMMENT '打卡任务ID',
-  `dimension` varchar(10) NOT NULL COMMENT '使用维度（一天-ONE_DAY，多天-MULTI_DAY）',
+  `task_id` bigint NOT NULL COMMENT '打卡任务ID',
+  `dimension` varchar(10) NOT NULL COMMENT '使用维度（一天-ONE_DAY，连续-CONTINUE）',
   `initial_value` int NOT NULL COMMENT '起始值（单位：次）',
   `extra_points` int NOT NULL COMMENT '奖励的积分（额外）',
   `created_by` bigint NOT NULL COMMENT '创建人',
@@ -225,22 +225,22 @@ CREATE TABLE `punch_in_task_ext` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_PITaskExt_UserId` (`user_id`),
-  KEY `idx_PITaskExt_PunchInTaskId` (`punch_in_task_id`)
+  KEY `idx_PiTaskExt_UserId` (`user_id`),
+  KEY `idx_PiTaskExt_TaskId` (`task_id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='打卡任务拓展表';
 
-CREATE TABLE `punch_in_multi_task` (
+CREATE TABLE `pi_multi_task` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
   `user_id` bigint NOT NULL COMMENT '用户ID',
-  `multi_task_unique_id` bigint NOT NULL COMMENT '打卡多任务唯一ID',
-  `multi_task_status` varchar(10) NOT NULL COMMENT '任务状态(活跃-ACTIVE，归档-ARCHIVE)',
-  `multi_task_version` int NOT NULL COMMENT '任务修改版本',
+  `unique_id` bigint NOT NULL COMMENT '打卡多任务唯一ID',
+  `task_status` varchar(10) NOT NULL COMMENT '任务状态(活跃-ACTIVE，归档-ARCHIVE)',
+  `task_version` int NOT NULL COMMENT '任务修改版本',
   `task_points_status` varchar(10) NOT NULL COMMENT '是否启用多任务积分计算(ENABLED-启用，DISABLED-关闭)',
   `punch_in_done_count` int DEFAULT NULL COMMENT '打卡完成次数',
   `points` int NOT NULL COMMENT '奖励的积分(基本)',
-  `grace_status` varchar(10) NOT NULL COMMENT '是否启用宽限期(ENABLED-启用，DISABLED-关闭)',
+  `continue_status` varchar(10) NOT NULL COMMENT '是否启用连续规则(ENABLED-启用，DISABLED-关闭)',
   `grace_day` int DEFAULT NULL COMMENT '宽限期（单位：天）',
-  `interrupted_day` int DEFAULT NULL COMMENT '打卡中断天数（单位：天）',
+  `continue_interrupted_count` int DEFAULT NULL COMMENT '连续中断次数',
   `penalty_day` int DEFAULT NULL COMMENT '惩罚天数（单位：天）',
   `extra_method` varchar(10) NOT NULL COMMENT '额外奖励方式（无-NONE，固定-FIXED，区间-INTERVAL）',
   `extra_points` int DEFAULT NULL COMMENT '奖励的积分（额外）',
@@ -251,11 +251,11 @@ CREATE TABLE `punch_in_multi_task` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_PIMTask_UserId` (`user_id`),
-  KEY `idx_PIMTask_MultiTaskUniqueId` (`multi_task_unique_id`)
+  KEY `idx_PiMTask_UserId` (`user_id`),
+  KEY `idx_PiMTask_UniqueId` (`unique_id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='打卡多任务表';
 
-CREATE TABLE `punch_in_multi_task_ext` (
+CREATE TABLE `pi_multi_task_ext` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
   `user_id` bigint NOT NULL COMMENT '用户ID',
   `multi_task_id` bigint NOT NULL COMMENT '多任务ID',
@@ -269,15 +269,15 @@ CREATE TABLE `punch_in_multi_task_ext` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_PIMTaskExt_UserId` (`user_id`),
-  KEY `idx_PIMTaskExt_MTaskUniqueId` (`multi_task_unique_id`)
+  KEY `idx_PiMTaskExt_UserId` (`user_id`),
+  KEY `idx_PiMTaskExt_MultiUniqueId` (`multi_task_id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='打卡多任务拓展表';
 
-CREATE TABLE `punch_in_multi_task_rela` (
+CREATE TABLE `pi_multi_task_rela` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
   `user_id` bigint NOT NULL COMMENT '用户ID',
-  `punch_in_multi_task_id` bigint NOT NULL COMMENT '打卡多任务ID',
-  `punch_in_task_id` bigint NOT NULL COMMENT '打卡任务ID',
+  `multi_task_id` bigint NOT NULL COMMENT '打卡多任务ID',
+  `task_id` bigint NOT NULL COMMENT '打卡任务ID',
   `created_by` bigint NOT NULL COMMENT '创建人',
   `creation_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
   `last_updated_by` bigint NOT NULL COMMENT '最后更新人',
@@ -285,24 +285,28 @@ CREATE TABLE `punch_in_multi_task_rela` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_PIMTaskRela_UserId` (`user_id`),
-  KEY `idx_PIMTaskRela_PIMTaskId` (`punch_in_multi_task_id`),
-  KEY `idx_PIMTaskRela_PITaskId` (`punch_in_task_id`)
+  KEY `idx_PiMTaskRela_UserId` (`user_id`),
+  KEY `idx_PiMTaskRela_MTaskId` (`multi_task_id`),
+  KEY `idx_PiMTaskRela_TaskId` (`task_id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='打卡多任务关联表';
 
-CREATE TABLE `punch_in_task_history` (
+CREATE TABLE `pi_task_history` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
   `user_id` bigint NOT NULL COMMENT '用户ID',
-  `punch_in_task_unique_id` bigint NOT NULL COMMENT '打卡任务唯一ID',
+  `task_unique_id` bigint NOT NULL COMMENT '打卡任务唯一ID',
   `punch_in_date` varchar(10) NOT NULL COMMENT '打卡日期',
-  `punch_in_status` varchar(10) NOT NULL COMMENT '打卡状态(DONE-完成，UNDONE-未完成)',
   `count_track` int DEFAULT NULL COMMENT '次数记录',
   `time_track` time DEFAULT NULL COMMENT '时间记录',
-  `consecutive_status` varchar(20) DEFAULT NULL COMMENT '连续打卡状态(正常打卡-NORMAL、中断--INTERRUPTED)',
-  `consecutive_day` int DEFAULT NULL COMMENT '连续天数，第一天开始就等于1',
-  `settle_task_history_id` bigint DEFAULT NULL COMMENT '结算任务执行ID',
-  `settle_status` varchar(20) NOT NULL COMMENT '结算状态(未结算-UNSETTLED，宽限期跳过J-GRACE_SKIP，惩罚跳过-PENALTY_SKIP，已结算-SETTLED)',
-  `settle_punch_in_task_id` bigint DEFAULT NULL COMMENT '结算时的打卡任务ID',
+  `task_continue_status` varchar(20) DEFAULT NULL COMMENT '任务连续打卡状态(连续打卡-CONTINUE、中断-INTERRUPTED)',
+  `task_continue_day` int DEFAULT NULL COMMENT '任务连续天数，第一天开始就等于1',
+  `continue_stage` varchar(10) DEFAULT NULL COMMENT '连续阶段（宽限期-GRACE_STAGE，正常打卡期-NORMAL_STAGE，惩罚期-PENALTY_STAGE）',
+  `stage_start_date` date DEFAULT NULL COMMENT '阶段开始日期',
+  `stage_end_date` date DEFAULT NULL COMMENT '阶段结束日期',
+  `continue_interrupted_count` int DEFAULT NULL COMMENT '连续中断次数',
+  `punch_in_result` varchar(10) NOT NULL COMMENT '打卡状态(DONE-完成，UNDONE-未完成)',
+  `settle_result` varchar(20) NOT NULL COMMENT '结算结果（未结算-UNSETTLED，已结算-SETTLED）',
+  `settle_pi_task_id` bigint DEFAULT NULL COMMENT '结算时的打卡任务ID',
+  `settle_task_history_id` bigint DEFAULT NULL COMMENT '结算任务执行记录ID',
   `settle_points` int DEFAULT NULL COMMENT '结算奖励积分',
   `created_by` bigint NOT NULL COMMENT '创建人',
   `creation_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
@@ -311,25 +315,29 @@ CREATE TABLE `punch_in_task_history` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_PITaskHis_UserId` (`user_id`),
-  KEY `idx_PITaskHis_PITaskUniqueId` (`punch_in_task_unique_id`),
-  KEY `idx_PITaskHis_PunchInDate` (`punch_in_date`),
-  KEY `idx_PITaskHis_CreationTime` (`creation_time`)
+  KEY `idx_PiTaskHis_UserId` (`user_id`),
+  KEY `idx_PiTaskHis_TaskUniqueId` (`task_unique_id`),
+  KEY `idx_PiTaskHis_PunchInDate` (`punch_in_date`),
+  KEY `idx_PiTaskHis_CreationTime` (`creation_time`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='打卡任务记录表';
 
-CREATE TABLE `punch_in_multi_task_history` (
+CREATE TABLE `pi_multi_task_history` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
   `user_id` bigint NOT NULL COMMENT '用户ID',
-  `punch_in_multi_task_unique_id` bigint NOT NULL COMMENT '打卡多任务唯一ID',
+  `multi_task_unique_id` bigint NOT NULL COMMENT '打卡多任务唯一ID',
   `punch_in_date` varchar(10) NOT NULL COMMENT '打卡日期',
-  `punch_in_status` varchar(10) NOT NULL COMMENT '打卡状态(DONE-完成，UNDONE-未完成)',
   `total_task_count` int NOT NULL COMMENT '总任务数',
   `punch_in_done_count` int NOT NULL COMMENT '打卡完成数',
-  `consecutive_status` varchar(20) NOT NULL COMMENT '连续打卡状态(正常打卡-NORMAL、中断--INTERRUPTED)',
-  `consecutive_day` int NOT NULL COMMENT '连续天数，第一天开始就等于1',
-  `settle_task_history_id` bigint DEFAULT NULL COMMENT '结算任务执行ID',
-  `settle_status` varchar(20) NOT NULL COMMENT '结算状态(未结算-UNSETTLED，宽限期跳过J-GRACE_SKIP，惩罚跳过-PENALTY_SKIP，已结算-SETTLED)',
-  `settle_punch_in_multi_task_id` bigint DEFAULT NULL COMMENT '结算时的打卡多任务ID',
+  `task_continue_status` varchar(20) DEFAULT NULL COMMENT '任务连续打卡状态(连续打卡-CONTINUE、中断-INTERRUPTED)',
+  `task_continue_day` int DEFAULT NULL COMMENT '任务连续天数，第一天开始就等于1',
+  `continue_stage` varchar(10) DEFAULT NULL COMMENT '连续阶段（宽限期-GRACE_STAGE，正常打卡期-NORMAL_STAGE，惩罚期-PENALTY_STAGE）',
+  `stage_start_date` date DEFAULT NULL COMMENT '阶段开始日期',
+  `stage_end_date` date DEFAULT NULL COMMENT '阶段结束日期',
+  `continue_interrupted_count` int DEFAULT NULL COMMENT '连续中断次数',
+  `punch_in_result` varchar(10) NOT NULL COMMENT '打卡状态(DONE-完成，UNDONE-未完成)',
+  `settle_result` varchar(20) NOT NULL COMMENT '结算结果（未结算-UNSETTLED，已结算-SETTLED）',
+  `settle_pi_multi_task_id` bigint DEFAULT NULL COMMENT '结算时的打卡多任务ID',
+  `settle_task_history_id` bigint DEFAULT NULL COMMENT '结算任务执行记录ID',
   `settle_points` int DEFAULT NULL COMMENT '结算奖励积分',
   `created_by` bigint NOT NULL COMMENT '创建人',
   `creation_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
@@ -338,20 +346,23 @@ CREATE TABLE `punch_in_multi_task_history` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_PIMTaskHis_UserId` (`user_id`),
-  KEY `idx_PIMTaskHis_PIMTUniqueId` (`punch_in_multi_task_unique_id`),
-  KEY `idx_PIMTaskHis_PunchInDate` (`punch_in_date`)
+  KEY `idx_PiMTaskHis_UserId` (`user_id`),
+  KEY `idx_PiMTaskHis_MTUniqueId` (`multi_task_unique_id`),
+  KEY `idx_PiMTaskHis_PunchInDate` (`punch_in_date`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='打卡多任务记录表';
 
-CREATE TABLE `punch_in_status` (
+CREATE TABLE `pi_status` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
   `user_id` bigint NOT NULL COMMENT '用户ID',
-  `punch_in_multi_task_unique_id` bigint DEFAULT NULL COMMENT '打卡多任务唯一ID',
-  `punch_in_task_unique_id` bigint DEFAULT NULL COMMENT '打卡任务唯一ID',
-  `consecutive_status` varchar(20) NOT NULL COMMENT '连续打卡状态(连续打卡-CONSECUTIVE、中断--INTERRUPTED)',
-  `consecutive_day` int NOT NULL COMMENT '连续天数，第一天开始就等于1',
-  `start_date` date NOT NULL COMMENT '开始日期',
-  `end_date` date DEFAULT NULL COMMENT '结束日期',
+  `multi_task_unique_id` bigint DEFAULT NULL COMMENT '打卡多任务唯一ID',
+  `task_unique_id` bigint DEFAULT NULL COMMENT '打卡任务唯一ID',
+  `status_date` date NOT NULL COMMENT '记录状态的时间',
+  `task_continue_status` varchar(20) DEFAULT NULL COMMENT '任务连续打卡状态(连续打卡-CONTINUE、中断-INTERRUPTED)',
+  `task_continue_day` int DEFAULT NULL COMMENT '任务连续天数，第一天开始就等于1',
+  `continue_stage` varchar(10) DEFAULT NULL COMMENT '连续阶段（宽限期-GRACE_STAGE，正常打卡期-NORMAL_STAGE，惩罚期-PENALTY_STAGE）',
+  `stage_start_date` date DEFAULT NULL COMMENT '阶段开始日期',
+  `stage_end_date` date DEFAULT NULL COMMENT '阶段结束日期',
+  `continue_interrupted_count` int DEFAULT NULL COMMENT '连续中断次数',
   `created_by` bigint NOT NULL COMMENT '创建人',
   `creation_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
   `last_updated_by` bigint NOT NULL COMMENT '最后更新人',
@@ -359,20 +370,23 @@ CREATE TABLE `punch_in_status` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_PIStatus_UserId` (`user_id`),
-  KEY `idx_PIStatus_PIMTaskUniqueId` (`punch_in_multi_task_unique_id`),
-  KEY `idx_PIStatus_PITaskUniqueId` (`punch_in_task_unique_id`)
+  KEY `idx_PiStatus_UserId` (`user_id`),
+  KEY `idx_PiStatus_MTaskUniqueId` (`multi_task_unique_id`),
+  KEY `idx_PiStatus_TaskUniqueId` (`task_unique_id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='打卡任务状态表';
 
-CREATE TABLE `punch_in_status_history` (
+CREATE TABLE `pi_status_history` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
   `user_id` bigint NOT NULL COMMENT '用户ID',
-  `punch_in_multi_task_unique_id` bigint DEFAULT NULL COMMENT '打卡多任务唯一ID',
-  `punch_in_task_unique_id` bigint DEFAULT NULL COMMENT '打卡任务唯一ID',
-  `consecutive_status` varchar(20) NOT NULL COMMENT '连续打卡状态(正常打卡-NORMAL、中断--INTERRUPTED)',
-  `consecutive_day` int NOT NULL COMMENT '连续天数，第一天开始就等于1',
-  `start_date` date NOT NULL COMMENT '开始日期',
-  `end_date` date DEFAULT NULL COMMENT '结束日期',
+  `multi_task_unique_id` bigint DEFAULT NULL COMMENT '打卡多任务唯一ID',
+  `task_unique_id` bigint DEFAULT NULL COMMENT '打卡任务唯一ID',
+  `status_date` date NOT NULL COMMENT '记录状态的时间',
+  `task_continue_status` varchar(20) DEFAULT NULL COMMENT '任务连续打卡状态(连续打卡-CONTINUE、中断-INTERRUPTED)',
+  `task_continue_day` int DEFAULT NULL COMMENT '任务连续天数，第一天开始就等于1',
+  `continue_stage` varchar(10) DEFAULT NULL COMMENT '连续阶段（宽限期-GRACE_STAGE，正常打卡期-NORMAL_STAGE，惩罚期-PENALTY_STAGE）',
+  `stage_start_date` date DEFAULT NULL COMMENT '阶段开始日期',
+  `stage_end_date` date DEFAULT NULL COMMENT '阶段结束日期',
+  `continue_interrupted_count` int DEFAULT NULL COMMENT '连续中断次数',
   `created_by` bigint NOT NULL COMMENT '创建人',
   `creation_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
   `last_updated_by` bigint NOT NULL COMMENT '最后更新人',
@@ -380,10 +394,10 @@ CREATE TABLE `punch_in_status_history` (
   `version` bigint NOT NULL DEFAULT '1' COMMENT '版本号',
   `delete_flag` tinyint NOT NULL DEFAULT '0' COMMENT '逻辑删除标志（0-未删除，1-已删除）',
   PRIMARY KEY (`id`),
-  KEY `idx_PIStatusHis_UserId` (`user_id`),
-  KEY `idx_PIStatusHis_PIMTUniqueId` (`punch_in_multi_task_unique_id`),
-  KEY `idx_PIStatusHis_PITUniqueId` (`punch_in_task_unique_id`),
-  KEY `idx_PIStatusHis_CreationTime` (`creation_time`)
+  KEY `idx_PiStatusHis_UserId` (`user_id`),
+  KEY `idx_PiStatusHis_MTUniqueId` (`multi_task_unique_id`),
+  KEY `idx_PiStatusHis_TUniqueId` (`task_unique_id`),
+  KEY `idx_PIStatusHis_StatusDate` (`status_date`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='打卡任务状态记录表';
 
 CREATE TABLE `settle_points_history` (
@@ -471,13 +485,13 @@ ALTER TABLE `user` MODIFY COLUMN total_consume_amount decimal(10,2) DEFAULT 0.00
 ALTER TABLE `user` CHANGE lottery_win_amount total_win_amount decimal(10,2) DEFAULT 0.00 NOT NULL COMMENT '总中奖金额(元)';
 ALTER TABLE `user` MODIFY COLUMN total_win_amount decimal(10,2) DEFAULT 0.00 NOT NULL COMMENT '总中奖金额(元)';
 
-RENAME TABLE punch_settle.punch_in TO punch_settle.punch_in_task;
+RENAME TABLE punch_settle.punch_in TO punch_settle.pi_task;
 
-ALTER TABLE punch_settle.punch_in_task CHANGE reward_num points int DEFAULT 1 NOT NULL COMMENT '奖励的积分（基本）';
-ALTER TABLE punch_settle.punch_in_task MODIFY COLUMN points int DEFAULT 1 NOT NULL COMMENT '奖励的积分（基本）';
+ALTER TABLE punch_settle.pi_task CHANGE reward_num points int DEFAULT 1 NOT NULL COMMENT '奖励的积分（基本）';
+ALTER TABLE punch_settle.pi_task MODIFY COLUMN points int DEFAULT 1 NOT NULL COMMENT '奖励的积分（基本）';
 
-ALTER TABLE `punch_in_task`
-ADD COLUMN `task_unique_id` bigint NULL COMMENT '任务唯一ID',
+ALTER TABLE `pi_task`
+ADD COLUMN `unique_id` bigint NULL COMMENT '任务唯一ID',
 ADD COLUMN `task_status` varchar(10) NULL COMMENT '任务状态(活跃-ACTIVE，归档-ARCHIVE)',
 ADD COLUMN `task_version` int NULL COMMENT '任务修改版本',
 ADD COLUMN `end_date` date DEFAULT NULL  COMMENT '结束日期',
@@ -497,74 +511,73 @@ ADD COLUMN `repeat_custom_day` varchar(13) DEFAULT NULL COMMENT '自定义重复
 ADD COLUMN `extra_method` varchar(10) DEFAULT NULL COMMENT '额外奖励方式（无-NONE，固定-FIXED，区间-INTERVAL）',
 ADD COLUMN `extra_time_step` int DEFAULT NULL COMMENT '额外的时间间隔（单位：分钟）',
 ADD COLUMN `extra_points` int DEFAULT NULL COMMENT '奖励的积分（额外）',
-ADD COLUMN `grace_status` varchar(10) DEFAULT NULL COMMENT '是否启用宽限期(ENABLED-启用，DISABLED-关闭)',
+ADD COLUMN `continue_status` varchar(10) DEFAULT NULL COMMENT '是否启用连续规则(ENABLED-启用，DISABLED-关闭)',
 ADD COLUMN `grace_day` int DEFAULT NULL COMMENT '宽限期（单位：天）',
-ADD COLUMN `interrupted_day` int DEFAULT NULL COMMENT '打卡中断天数（单位：天）',
+ADD COLUMN `continue_interrupted_count` int DEFAULT NULL COMMENT '连续中断次数',
 ADD COLUMN `penalty_day` int DEFAULT NULL COMMENT '惩罚天数（单位：天）',
 ADD COLUMN `auto_status` varchar(10) DEFAULT NULL COMMENT '是否启用自动打卡(ENABLED-启用，DISABLED-关闭)',
 ADD COLUMN `task_points_status` varchar(10) DEFAULT NULL COMMENT '是否启用任务积分计算(ENABLED-启用，DISABLED-关闭)';
 
-ALTER TABLE punch_settle.punch_in_task CHANGE created_by created_by bigint NOT NULL COMMENT '创建人' AFTER auto_status;
-ALTER TABLE punch_settle.punch_in_task CHANGE creation_time creation_time timestamp DEFAULT CURRENT_TIMESTAMP  NOT NULL COMMENT '创建时间' AFTER created_by;
-ALTER TABLE punch_settle.punch_in_task CHANGE last_updated_by last_updated_by bigint NOT NULL COMMENT '最后更新人' AFTER creation_time;
-ALTER TABLE punch_settle.punch_in_task CHANGE last_update_time last_update_time timestamp DEFAULT CURRENT_TIMESTAMP  on update CURRENT_TIMESTAMP NOT NULL COMMENT '最后更新时间' AFTER last_updated_by;
-ALTER TABLE punch_settle.punch_in_task CHANGE version version bigint DEFAULT 1 NOT NULL COMMENT '版本号' AFTER last_update_time;
-ALTER TABLE punch_settle.punch_in_task CHANGE delete_flag delete_flag tinyint DEFAULT 0 NOT NULL COMMENT '逻辑删除标志（0-未删除，1-已删除）' AFTER version;
-ALTER TABLE punch_settle.punch_in_task CHANGE task_unique_id task_unique_id bigint NULL COMMENT '任务唯一ID' AFTER id;
-ALTER TABLE punch_settle.punch_in_task CHANGE task_status task_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '任务状态(活跃-ACTIVE，归档-ARCHIVE)' AFTER task_unique_id;
-ALTER TABLE punch_settle.punch_in_task CHANGE task_version task_version int NULL COMMENT '任务修改版本' AFTER task_status;
-ALTER TABLE punch_settle.punch_in_task CHANGE description description varchar(300) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '任务描述' AFTER task_name;
-ALTER TABLE punch_settle.punch_in_task CHANGE points points int DEFAULT 1 NOT NULL COMMENT '奖励的积分（基本）' AFTER description;
-ALTER TABLE punch_settle.punch_in_task CHANGE end_date end_date date NULL COMMENT '结束日期' AFTER points;
-ALTER TABLE punch_settle.punch_in_task CHANGE archive_status archive_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '是否归档(活跃-ACTIVE，归档-ARCHIVE)' AFTER end_date;
-ALTER TABLE punch_settle.punch_in_task CHANGE display_order display_order int NULL COMMENT '显示顺序' AFTER archive_status;
-ALTER TABLE punch_settle.punch_in_task CHANGE display_time display_time time NULL COMMENT '显示时间' AFTER display_order;
-ALTER TABLE punch_settle.punch_in_task CHANGE punch_in_method punch_in_method varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '打卡方式(单次打卡-SINGLE，计数-COUNT、计时-TIMING)' AFTER rule;
-ALTER TABLE punch_settle.punch_in_task CHANGE compare_rule compare_rule varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '比较规则(大于等于-GTE，小于等于-LTE)' AFTER punch_in_method;
-update punch_settle.punch_in_task
-set task_unique_id = id,
+ALTER TABLE punch_settle.pi_task CHANGE created_by created_by bigint NOT NULL COMMENT '创建人' AFTER auto_status;
+ALTER TABLE punch_settle.pi_task CHANGE creation_time creation_time timestamp DEFAULT CURRENT_TIMESTAMP  NOT NULL COMMENT '创建时间' AFTER created_by;
+ALTER TABLE punch_settle.pi_task CHANGE last_updated_by last_updated_by bigint NOT NULL COMMENT '最后更新人' AFTER creation_time;
+ALTER TABLE punch_settle.pi_task CHANGE last_update_time last_update_time timestamp DEFAULT CURRENT_TIMESTAMP  on update CURRENT_TIMESTAMP NOT NULL COMMENT '最后更新时间' AFTER last_updated_by;
+ALTER TABLE punch_settle.pi_task CHANGE version version bigint DEFAULT 1 NOT NULL COMMENT '版本号' AFTER last_update_time;
+ALTER TABLE punch_settle.pi_task CHANGE delete_flag delete_flag tinyint DEFAULT 0 NOT NULL COMMENT '逻辑删除标志（0-未删除，1-已删除）' AFTER version;
+ALTER TABLE punch_settle.pi_task CHANGE unique_id unique_id bigint NULL COMMENT '任务唯一ID' AFTER id;
+ALTER TABLE punch_settle.pi_task CHANGE task_status task_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '任务状态(活跃-ACTIVE，归档-ARCHIVE)' AFTER unique_id;
+ALTER TABLE punch_settle.pi_task CHANGE task_version task_version int NULL COMMENT '任务修改版本' AFTER task_status;
+ALTER TABLE punch_settle.pi_task CHANGE description description varchar(300) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '任务描述' AFTER task_name;
+ALTER TABLE punch_settle.pi_task CHANGE points points int DEFAULT 1 NOT NULL COMMENT '奖励的积分（基本）' AFTER description;
+ALTER TABLE punch_settle.pi_task CHANGE end_date end_date date NULL COMMENT '结束日期' AFTER points;
+ALTER TABLE punch_settle.pi_task CHANGE archive_status archive_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '是否归档(活跃-ACTIVE，归档-ARCHIVE)' AFTER end_date;
+ALTER TABLE punch_settle.pi_task CHANGE display_order display_order int NULL COMMENT '显示顺序' AFTER archive_status;
+ALTER TABLE punch_settle.pi_task CHANGE display_time display_time time NULL COMMENT '显示时间' AFTER display_order;
+ALTER TABLE punch_settle.pi_task CHANGE punch_in_method punch_in_method varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '打卡方式(单次打卡-SINGLE，计数-COUNT、计时-TIMING)' AFTER rule;
+ALTER TABLE punch_settle.pi_task CHANGE compare_rule compare_rule varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '比较规则(大于等于-GTE，小于等于-LTE)' AFTER punch_in_method;
+update punch_settle.pi_task
+set unique_id = id,
 task_status = 'ACTIVE',
 task_version = 1;
 
-UPDATE punch_settle.punch_in_task SET archive_status = 'ACTIVE' WHERE archive_flag = 0;
-UPDATE punch_settle.punch_in_task SET archive_status = 'ARCHIVE' WHERE archive_flag = 1;
-UPDATE punch_settle.punch_in_task SET punch_in_method = 'SINGLE' WHERE category = 0;
-UPDATE punch_settle.punch_in_task SET punch_in_method = 'COUNT' WHERE category = 1;
-UPDATE punch_settle.punch_in_task SET punch_in_method = 'TIMING' WHERE category = 2;
-update punch_settle.punch_in_task set compare_rule = 'GTE' WHERE rule = 0 and category != 0;
-update punch_settle.punch_in_task set compare_rule = 'LTE' WHERE rule = 1 and category != 0;
-ALTER TABLE punch_settle.punch_in_task DROP COLUMN archive_flag;
-ALTER TABLE punch_settle.punch_in_task DROP COLUMN category;
-ALTER TABLE punch_settle.punch_in_task DROP COLUMN rule;
+UPDATE punch_settle.pi_task SET archive_status = 'ACTIVE' WHERE archive_flag = 0;
+UPDATE punch_settle.pi_task SET archive_status = 'ARCHIVE' WHERE archive_flag = 1;
+UPDATE punch_settle.pi_task SET punch_in_method = 'SINGLE' WHERE category = 0;
+UPDATE punch_settle.pi_task SET punch_in_method = 'COUNT' WHERE category = 1;
+UPDATE punch_settle.pi_task SET punch_in_method = 'TIMING' WHERE category = 2;
+update punch_settle.pi_task set compare_rule = 'GTE' WHERE rule = 0 and category != 0;
+update punch_settle.pi_task set compare_rule = 'LTE' WHERE rule = 1 and category != 0;
+ALTER TABLE punch_settle.pi_task DROP COLUMN archive_flag;
+ALTER TABLE punch_settle.pi_task DROP COLUMN category;
+ALTER TABLE punch_settle.pi_task DROP COLUMN rule;
 -- 节假日没有节假日的判断目标数据无法初始化，因此初始化为关闭
-UPDATE punch_settle.punch_in_task SET holiday_status = 'DISABLED';
-UPDATE punch_settle.punch_in_task SET full_attendance_status = 'DISABLED' WHERE full_attendance_flag = 0;
-UPDATE punch_settle.punch_in_task
+UPDATE punch_settle.pi_task SET holiday_status = 'DISABLED';
+UPDATE punch_settle.pi_task SET full_attendance_status = 'DISABLED' WHERE full_attendance_flag = 0;
+UPDATE punch_settle.pi_task
 SET full_attendance_status = 'ENABLED',
 full_attendance_fault_tolerance_cnt = 1,
 full_attendance_period = 'WEEK'
 WHERE full_attendance_flag = 1;
-ALTER TABLE punch_settle.punch_in_task DROP COLUMN full_attendance_flag;
-ALTER TABLE punch_settle.punch_in_task DROP COLUMN weekend_double_flag;
-UPDATE punch_settle.punch_in_task SET repeat_category = 'EVERYDAY';
-UPDATE punch_settle.punch_in_task SET extra_method = 'NONE';
-UPDATE punch_settle.punch_in_task SET grace_status = 'DISABLED';
-UPDATE punch_settle.punch_in_task SET auto_status = 'DISABLED';
-ALTER TABLE punch_settle.punch_in_task MODIFY COLUMN archive_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '是否归档(活跃-ACTIVE，归档-ARCHIVE)';
-ALTER TABLE punch_settle.punch_in_task MODIFY COLUMN task_unique_id bigint NOT NULL COMMENT '任务唯一ID';
-ALTER TABLE punch_settle.punch_in_task MODIFY COLUMN task_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '任务状态(活跃-ACTIVE，归档-ARCHIVE)';
-ALTER TABLE punch_settle.punch_in_task MODIFY COLUMN task_version int NOT NULL COMMENT '任务修改版本';
-ALTER TABLE punch_settle.punch_in_task MODIFY COLUMN punch_in_method varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '打卡方式(单次打卡-SINGLE，计数-COUNT、计时-TIMING)';
-ALTER TABLE punch_settle.punch_in_task MODIFY COLUMN holiday_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '是否启用节假日奖励(ENABLED-启用，DISABLED-关闭)';
-ALTER TABLE punch_settle.punch_in_task MODIFY COLUMN full_attendance_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '是否启用全勤奖励(ENABLED-启用，DISABLED-关闭)';
-ALTER TABLE punch_settle.punch_in_task MODIFY COLUMN repeat_category varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '重复周期类型（每日-EVERYDAY、法定工作日-WORKDAY、法定节假日（含周末）-HOLIADY、自定义（周一至周日）-CUSTOM）';
-ALTER TABLE punch_settle.punch_in_task MODIFY COLUMN extra_method varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '额外奖励方式（无-NONE，固定-FIXED，区间-INTERVAL）';
-ALTER TABLE punch_settle.punch_in_task MODIFY COLUMN grace_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '是否启用宽限期(ENABLED-启用，DISABLED-关闭)';
-ALTER TABLE punch_settle.punch_in_task MODIFY COLUMN auto_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '是否启用自动打卡(ENABLED-启用，DISABLED-关闭)';
-
-ALTER TABLE punch_settle.punch_in_multi_task MODIFY COLUMN punch_in_method varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '打卡方式（次数-COUNT，比率-RATE）';
-ALTER TABLE punch_settle.punch_in_multi_task MODIFY COLUMN grace_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '是否启用宽限期(ENABLED-启用，DISABLED-关闭)';
-ALTER TABLE punch_settle.punch_in_multi_task MODIFY COLUMN extra_method varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '额外奖励方式（无-NONE，固定-FIXED，区间-INTERVAL）';
+ALTER TABLE punch_settle.pi_task DROP COLUMN full_attendance_flag;
+ALTER TABLE punch_settle.pi_task DROP COLUMN weekend_double_flag;
+UPDATE punch_settle.pi_task SET repeat_category = 'EVERYDAY';
+UPDATE punch_settle.pi_task SET extra_method = 'NONE';
+UPDATE punch_settle.pi_task SET continue_status = 'DISABLED';
+UPDATE punch_settle.pi_task SET auto_status = 'DISABLED';
+ALTER TABLE punch_settle.pi_task MODIFY COLUMN archive_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '是否归档(活跃-ACTIVE，归档-ARCHIVE)';
+ALTER TABLE punch_settle.pi_task MODIFY COLUMN unique_id bigint NOT NULL COMMENT '任务唯一ID';
+ALTER TABLE punch_settle.pi_task MODIFY COLUMN task_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '任务状态(活跃-ACTIVE，归档-ARCHIVE)';
+ALTER TABLE punch_settle.pi_task MODIFY COLUMN task_version int NOT NULL COMMENT '任务修改版本';
+ALTER TABLE punch_settle.pi_task MODIFY COLUMN punch_in_method varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '打卡方式(单次打卡-SINGLE，计数-COUNT、计时-TIMING)';
+ALTER TABLE punch_settle.pi_task MODIFY COLUMN holiday_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '是否启用节假日奖励(ENABLED-启用，DISABLED-关闭)';
+ALTER TABLE punch_settle.pi_task MODIFY COLUMN full_attendance_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '是否启用全勤奖励(ENABLED-启用，DISABLED-关闭)';
+ALTER TABLE punch_settle.pi_task MODIFY COLUMN repeat_category varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '重复周期类型（每日-EVERYDAY、法定工作日-WORKDAY、法定节假日（含周末）-HOLIADY、自定义（周一至周日）-CUSTOM）';
+ALTER TABLE punch_settle.pi_task MODIFY COLUMN extra_method varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '额外奖励方式（无-NONE，固定-FIXED，区间-INTERVAL）';
+ALTER TABLE punch_settle.pi_task MODIFY COLUMN continue_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '是否启用连续规则(ENABLED-启用，DISABLED-关闭)';
+ALTER TABLE punch_settle.pi_task MODIFY COLUMN auto_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '是否启用自动打卡(ENABLED-启用，DISABLED-关闭)';
+
+ALTER TABLE punch_settle.pi_multi_task MODIFY COLUMN continue_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '是否启用连续规则(ENABLED-启用，DISABLED-关闭)';
+ALTER TABLE punch_settle.pi_multi_task MODIFY COLUMN extra_method varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '额外奖励方式（无-NONE，固定-FIXED，区间-INTERVAL）';
 
 ALTER TABLE punch_settle.sys_dict MODIFY COLUMN status varchar(10) DEFAULT 'DISABLED' NOT NULL COMMENT '状态(ENABLED-启用，DISABLED-失效)';
 UPDATE punch_settle.sys_dict SET status = 'ENABLED' WHERE status = '1';
@@ -605,7 +618,7 @@ left join settle_task_history sth on pis.settlement_task_id = sth.id;
 DROP TABLE IF EXISTS punch_in_settlement;
 
 -- 删除无效的用户数据
-delete from user where id not in (select created_by from punch_in_task group by created_by);
+delete from user where id not in (select created_by from pi_task group by created_by);
 -- 初始化账户数据，account数从user导入
 insert into account(user_id, account_name, account_type, points, created_by, creation_time, last_updated_by, last_update_time, version, delete_flag)
 select id, '基本户', 'BASIC', unused_points, id, CURRENT_TIMESTAMP(), id, CURRENT_TIMESTAMP(), 1, 0
@@ -633,9 +646,9 @@ created_by, creation_time, last_updated_by, last_update_time, version, delete_fl
 from user_claim_reward_record rr;
 DROP TABLE IF EXISTS user_claim_reward_record;
 
-insert into punch_in_task_history(id, user_id, punch_in_task_unique_id,
-punch_in_date, punch_in_status, count_track, time_track, settle_task_history_id,
-settle_status, settle_punch_in_task_id, created_by, creation_time,
+insert into pi_task_history(id, user_id, task_unique_id,
+punch_in_date, punch_in_result, count_track, time_track, settle_task_history_id,
+settle_result, settle_pi_task_id, created_by, creation_time,
 last_updated_by, last_update_time, version, delete_flag)
 select pir.id, pir.created_by, punch_in_id, punch_in_date, punch_in_status,
 count_track, time_track, pirsr.settlement_id , 'SETTLED', pir.punch_in_id , pir.created_by,
@@ -643,9 +656,9 @@ pir.creation_time, pir.last_updated_by, pir.last_update_time, pir.version, pir.d
 from punch_in_record pir
 left join punch_in_record_settlement_rela pirsr on pir.id = pirsr.record_id;
 
-update punch_in_task_history set punch_in_status = 'DONE' where punch_in_status = '1';
-update punch_in_task_history set punch_in_status = 'UNDONE' where punch_in_status = '2';
-update punch_in_task_history set punch_in_status = 'UNDONE' where punch_in_status = '0';
+update pi_task_history set punch_in_result = 'DONE' where punch_in_result = '1';
+update pi_task_history set punch_in_result = 'UNDONE' where punch_in_result = '2';
+update pi_task_history set punch_in_result = 'UNDONE' where punch_in_result = '0';
 DROP TABLE IF EXISTS punch_in_record;
 DROP TABLE IF EXISTS punch_in_record_settlement_rela;
 
@@ -667,4 +680,4 @@ update punch_settle.sys_dict_item set item_code = 'TIMING' where id = 11;
 update punch_settle.sys_dict_item set item_code = 'GTE' where id = 12;
 update punch_settle.sys_dict_item set item_code = 'LET' where id = 13;
 
-ALTER TABLE punch_settle.punch_in_task CHANGE task_points_status task_points_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '是否启用任务积分计算(ENABLED-启用，DISABLED-关闭)' AFTER auto_status;
+ALTER TABLE punch_settle.pi_task CHANGE task_points_status task_points_status varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL COMMENT '是否启用任务积分计算(ENABLED-启用，DISABLED-关闭)' AFTER auto_status;

doc/技术文档.md

@@ -96,17 +96,27 @@ ui设计工具：即时设计
 
 
 
-##### 前置判断
+##### 连续规则
 
-1. 开始前有连续N天，不结算积分，不计算连续打卡天数
+作用：用于那些连续性比较强的任务，希望一直连续完成，不是三天晒网两天打鱼
 
-2. 中途没有完成打卡则重新开始
+计量单位：连续天数
 
-   如果没有完成的天数小于等于N天，则有连续Y天不结算积分（等同于一个小的开始，Y自己设置），连续打卡天数天数重置
+目标对象：单任务、多任务
 
-   如果大于N天，则等同于任务重新开始
+规则：设宽限期N天，中断X次，惩罚Y天
 
-注：可以应用在单个任务，也可以应用在多个任务
+* 宽限期阶段：
+  1. 有连续N天宽限期，期间完成打卡也不结算积分、不计算连续打卡天数
+  2. 如果N天宽限期后第一次**完成打卡**，则进入正常打卡期
+  3. 如果N天宽限期后一直没有完成打卡，则一直处于宽限期
+* 正常打卡期：
+  1. 如果完成打卡，允许结算积分和计算连续打卡天数
+  2. 如果没有完成打卡（连续打卡中断），则进入惩罚期
+* 惩罚期：
+  1. 如果没有完成打卡，则接下来**Y天是惩罚时间且连续打卡天数重置（归零）**，期间完成打卡也不结算积分、不计算连续打卡天数
+  2. Y天的惩罚时间结束后，自动返回正常打卡期
+  3. 如果**连续进入惩罚期的次数**等于中断X次，则重新进入宽限期
 
 
 
@@ -158,7 +168,7 @@ ui设计工具：即时设计
 
 2. 显示今日待办的打卡任务列表
 
-   显示元素：任务名称、任务描述、奖励的基本积分数、节假日奖励标识、全勤奖励标识、自动打卡标识、本周的打卡情况、打卡按钮
+   显示元素：任务名称、任务描述、奖励的基本积分数、节假日奖励标识、全勤奖励标识、自动打卡标识、本周的打卡情况、打卡按钮、宽限期/惩罚期/正常打卡期标识
 
    注意点：
 
@@ -519,12 +529,12 @@ ui设计工具：即时设计
 
 ### 打卡任务表
 
-表名：punch_in_task
+表名：pi_task
 
 | 字段                                | 类型         | 描述                                                         | 索引     |
 | ----------------------------------- | ------------ | ------------------------------------------------------------ | -------- |
 | id                                  | bigint       | 主键                                                         | 主键索引 |
-| task_unique_id                      | bigint       | 任务唯一ID                                                   | 普通索引 |
+| unique_id                           | bigint       | 任务唯一ID                                                   | 普通索引 |
 | task_status                         | varchar(10)  | 任务状态(活跃-ACTIVE，归档-ARCHIVE)                          |          |
 | task_version                        | int          | 任务修改版本                                                 |          |
 | task_name                           | varchar(128) | 任务名称                                                     |          |
@@ -549,9 +559,9 @@ ui设计工具：即时设计
 | extra_method                        | varchar(10)  | 额外奖励方式（无-NONE，固定-FIXED，区间-INTERVAL）           |          |
 | extra_time_step                     | int          | 额外的时间间隔（单位：分钟）                                 |          |
 | extra_points                        | int          | 奖励的积分（额外）                                           |          |
-| grace_status                        | varchar(10)  | 是否启用宽限期(ENABLED-启用，DISABLED-关闭)                  |          |
+| continue_status                     | varchar(10)  | 是否启用连续规则(ENABLED-启用，DISABLED-关闭)                |          |
 | grace_day                           | int          | 宽限期（单位：天）                                           |          |
-| interrupted_day                     | int          | 打卡中断天数（单位：天）                                     |          |
+| continue_interrupted_count          | int          | 连续中断次数                                                 |          |
 | penalty_day                         | int          | 惩罚天数（单位：天）                                         |          |
 | auto_status                         | varchar(10)  | 是否启用自动打卡(ENABLED-启用，DISABLED-关闭)                |          |
 | task_points_status                  | varchar(10)  | 是否启用任务积分计算(ENABLED-启用，DISABLED-关闭)            |          |
@@ -566,13 +576,13 @@ ui设计工具：即时设计
 
 ### 打卡任务拓展表
 
-表名：punch_in_task_ext
+表名：pi_task_ext
 
 | 字段             | 类型        | 描述                                     | 索引     |
 | ---------------- | ----------- | ---------------------------------------- | -------- |
 | id               | bigint      | 主键                                     | 主键索引 |
 | user_id          | bigint      | 用户ID                                   | 普通索引 |
-| punch_in_task_id | bigint      | 打卡任务ID                               | 普通索引 |
+| task_id          | bigint      | 打卡任务ID                               | 普通索引 |
 | dimension        | varchar(10) | 使用维度（一天-ONE_DAY，多天-MULTI_DAY） |          |
 | initial_value    | int         | 起始值（单位：次）                       |          |
 | extra_points     | int         | 奖励的积分（额外）                       |          |
@@ -589,36 +599,36 @@ ui设计工具：即时设计
 
 ### 打卡多任务表
 
-表名：punch_in_multi_task
-
-| 字段                 | 类型        | 描述                                                | 索引     |
-| -------------------- | ----------- | --------------------------------------------------- | -------- |
-| id                   | bigint      | 主键                                                | 主键索引 |
-| user_id              | bigint      | 用户ID                                              | 普通索引 |
-| multi_task_unique_id | bigint      | 打卡多任务唯一ID                                    | 普通索引 |
-| multi_task_status    | varchar(10) | 任务状态(活跃-ACTIVE，归档-ARCHIVE)                 |          |
-| multi_task_version   | int         | 任务修改版本                                        |          |
-| task_points_status   | varchar(10) | 是否启用多任务积分计算(ENABLED-启用，DISABLED-关闭) |          |
-| punch_in_done_count  | int         | 打卡完成次数                                        |          |
-| points               | int         | 奖励的积分(基本)                                    |          |
-| grace_status         | varchar(10) | 是否启用宽限期(ENABLED-启用，DISABLED-关闭)         |          |
-| grace_day            | int         | 宽限期（单位：天）                                  |          |
-| interrupted_day      | int         | 打卡中断天数（单位：天）                            |          |
-| penalty_day          | int         | 惩罚天数（单位：天）                                |          |
-| extra_method         | varchar(10) | 额外奖励方式（无-NONE，固定-FIXED，区间-INTERVAL）  |          |
-| extra_points         | int         | 奖励的积分（额外）                                  |          |
-| created_by           | bigint      | 创建人                                              |          |
-| creation_time        | timestamp   | 创建时间                                            |          |
-| last_updated_by      | bigint      | 最后更新人                                          |          |
-| last_update_time     | timestamp   | 最后更新时间                                        |          |
-| version              | bigint      | 版本号                                              |          |
-| delete_flag          | tinyint     | 逻辑删除标志（0-未删除，1-已删除）                  |          |
+表名：pi_multi_task
+
+| 字段                       | 类型        | 描述                                                | 索引     |
+| -------------------------- | ----------- | --------------------------------------------------- | -------- |
+| id                         | bigint      | 主键                                                | 主键索引 |
+| unique_id                  | bigint      | 打卡多任务唯一ID                                    | 普通索引 |
+| user_id                    | bigint      | 用户ID                                              | 普通索引 |
+| task_status                | varchar(10) | 任务状态(活跃-ACTIVE，归档-ARCHIVE)                 |          |
+| task_version               | int         | 任务修改版本                                        |          |
+| task_points_status         | varchar(10) | 是否启用多任务积分计算(ENABLED-启用，DISABLED-关闭) |          |
+| punch_in_done_count        | int         | 打卡完成次数                                        |          |
+| points                     | int         | 奖励的积分(基本)                                    |          |
+| continue_status            | varchar(10) | 是否启用连续规则(ENABLED-启用，DISABLED-关闭)       |          |
+| grace_day                  | int         | 宽限期（单位：天）                                  |          |
+| continue_interrupted_count | int         | 连续中断次数                                        |          |
+| penalty_day                | int         | 惩罚天数（单位：天）                                |          |
+| extra_method               | varchar(10) | 额外奖励方式（无-NONE，固定-FIXED，区间-INTERVAL）  |          |
+| extra_points               | int         | 奖励的积分（额外）                                  |          |
+| created_by                 | bigint      | 创建人                                              |          |
+| creation_time              | timestamp   | 创建时间                                            |          |
+| last_updated_by            | bigint      | 最后更新人                                          |          |
+| last_update_time           | timestamp   | 最后更新时间                                        |          |
+| version                    | bigint      | 版本号                                              |          |
+| delete_flag                | tinyint     | 逻辑删除标志（0-未删除，1-已删除）                  |          |
 
 
 
 ### 打卡多任务拓展表
 
-表名：punch_in_multi_task_ext
+表名：pi_multi_task_ext
 
 | 字段             | 类型        | 描述                                     | 索引     |
 | ---------------- | ----------- | ---------------------------------------- | -------- |
@@ -639,131 +649,144 @@ ui设计工具：即时设计
 
 ### 打卡多任务关联表
 
-表名：punch_in_multi_task_rela
+表名：pi_multi_task_rela
 
 说明：这里的打卡多任务ID和打卡任务ID均不用唯一ID，用于记录对应的快照关系
 
-| 字段                   | 类型      | 描述                               | 索引     |
-| ---------------------- | --------- | ---------------------------------- | -------- |
-| id                     | bigint    | 主键                               | 主键索引 |
-| user_id                | bigint    | 用户ID                             | 普通索引 |
-| punch_in_multi_task_id | bigint    | 打卡多任务ID                       | 普通索引 |
-| punch_in_task_id       | bigint    | 打卡任务ID                         | 普通索引 |
-| created_by             | bigint    | 创建人                             |          |
-| creation_time          | timestamp | 创建时间                           |          |
-| last_updated_by        | bigint    | 最后更新人                         |          |
-| last_update_time       | timestamp | 最后更新时间                       |          |
-| version                | bigint    | 版本号                             |          |
-| delete_flag            | tinyint   | 逻辑删除标志（0-未删除，1-已删除） |          |
-
-
-
-### 打卡任务记录表
-
-表名：punch_in_task_history
-
-| 字段                          | 类型        | 描述                                                         | 索引     |
-| ----------------------------- | ----------- | ------------------------------------------------------------ | -------- |
-| id                            | bigint      | 主键                                                         | 主键索引 |
-| user_id                       | bigint      | 用户ID                                                       | 普通索引 |
-| punch_in_task_unique_id       | bigint      | 打卡任务唯一ID                                               | 普通索引 |
-| punch_in_date                 | varchar(10) | 打卡日期                                                     | 普通索引 |
-| punch_in_status               | varchar(10) | 打卡状态(DONE-完成，UNDONE-未完成)                           |          |
-| count_track                   | int         | 次数记录                                                     |          |
-| time_track                    | time        | 时间记录                                                     |          |
-| consecutive_status            | varchar(20) | 连续打卡状态(正常打卡-NORMAL、中断--INTERRUPTED)             |          |
-| consecutive_day               | int         | 连续天数，第一天开始就等于1                                  |          |
-| settle_task_history_id        | bigint      | 结算任务执行记录ID                                           | 普通索引 |
-| settle_status                 | varchar(20) | 结算状态(未结算-UNSETTLED，宽限期跳过J-GRACE_SKIP，惩罚跳过-PENALTY_SKIP，已结算-SETTLED) |          |
-| settle_punch_in_task_id       | bigint      | 结算时的打卡任务ID                                           |          |
-| settle_points                 | int         | 结算奖励积分                                                 |          |
-| settle_basic_points           | int         |                                                              |          |
-| settle_extra_points           |             |                                                              |          |
-| settle_full_attendance_points |             |                                                              |          |
-| settle_holiday_points         |             |                                                              |          |
-| settle_task_points            |             |                                                              |          |
-| created_by                    | bigint      | 创建人                                                       |          |
-| creation_time                 | timestamp   | 创建时间                                                     | 普通索引 |
-| last_updated_by               | bigint      | 最后更新人                                                   |          |
-| last_update_time              | timestamp   | 最后更新时间                                                 |          |
-| version                       | bigint      | 版本号                                                       |          |
-| delete_flag                   | tinyint     | 逻辑删除标志（0-未删除，1-已删除）                           |          |
-
-
-
-### 打卡多任务记录表
-
-表名：punch_in_multi_task_history
-
-| 字段                          | 类型        | 描述                                                         | 索引     |
-| ----------------------------- | ----------- | ------------------------------------------------------------ | -------- |
-| id                            | bigint      | 主键                                                         | 主键索引 |
-| user_id                       | bigint      | 用户ID                                                       | 普通索引 |
-| punch_in_multi_task_unique_id | bigint      | 打卡多任务唯一ID                                             | 普通索引 |
-| punch_in_date                 | varchar(10) | 打卡日期                                                     | 普通索引 |
-| punch_in_status               | varchar(10) | 打卡状态(DONE-完成，UNDONE-未完成)                           |          |
-| total_task_count              | int         | 总任务数                                                     |          |
-| punch_in_done_count           | int         | 打卡完成数                                                   |          |
-| consecutive_status            | varchar(20) | 连续打卡状态(正常打卡-NORMAL、中断--INTERRUPTED)             |          |
-| consecutive_day               | int         | 连续天数，第一天开始就等于1                                  |          |
-| settle_task_history_id        | bigint      | 结算任务执行记录ID                                           | 普通索引 |
-| settle_status                 | varchar(20) | 结算状态(未结算-UNSETTLED，宽限期跳过J-GRACE_SKIP，惩罚跳过-PENALTY_SKIP，已结算-SETTLED) |          |
-| settle_punch_in_multi_task_id | bigint      | 结算时的打卡多任务ID                                         |          |
-| settle_points                 | int         | 结算奖励积分                                                 |          |
-| created_by                    | bigint      | 创建人                                                       |          |
-| creation_time                 | timestamp   | 创建时间                                                     |          |
-| last_updated_by               | bigint      | 最后更新人                                                   |          |
-| last_update_time              | timestamp   | 最后更新时间                                                 |          |
-| version                       | bigint      | 版本号                                                       |          |
-| delete_flag                   | tinyint     | 逻辑删除标志（0-未删除，1-已删除）                           |          |
+| 字段             | 类型      | 描述                               | 索引     |
+| ---------------- | --------- | ---------------------------------- | -------- |
+| id               | bigint    | 主键                               | 主键索引 |
+| user_id          | bigint    | 用户ID                             | 普通索引 |
+| multi_task_id    | bigint    | 打卡多任务ID                       | 普通索引 |
+| task_id          | bigint    | 打卡任务ID                         | 普通索引 |
+| created_by       | bigint    | 创建人                             |          |
+| creation_time    | timestamp | 创建时间                           |          |
+| last_updated_by  | bigint    | 最后更新人                         |          |
+| last_update_time | timestamp | 最后更新时间                       |          |
+| version          | bigint    | 版本号                             |          |
+| delete_flag      | tinyint   | 逻辑删除标志（0-未删除，1-已删除） |          |
+
+
+
+### 打卡任务打卡记录表
+
+表名：pi_task_history
+
+| 字段                       | 类型        | 描述                                                         | 索引     |
+| -------------------------- | ----------- | ------------------------------------------------------------ | -------- |
+| id                         | bigint      | 主键                                                         | 主键索引 |
+| user_id                    | bigint      | 用户ID                                                       | 普通索引 |
+| task_unique_id             | bigint      | 打卡任务唯一ID                                               | 普通索引 |
+| punch_in_date              | varchar(10) | 打卡日期                                                     | 普通索引 |
+| count_track                | int         | 次数记录                                                     |          |
+| time_track                 | time        | 时间记录                                                     |          |
+| task_continue_status       | varchar(20) | 任务连续打卡状态(连续打卡-CONTINUE、中断-INTERRUPTED)        |          |
+| task_continue_day          | int         | 任务连续天数，第一天开始就等于1                              |          |
+| continue_stage             | varchar(10) | 连续阶段（宽限期-GRACE_STAGE，正常打卡期-NORMAL_STAGE，惩罚期-PENALTY_STAGE） |          |
+| stage_start_date           | date        | 阶段开始日期                                                 |          |
+| stage_end_date             | date        | 阶段结束日期                                                 |          |
+| continue_interrupted_count | int         | 连续中断次数                                                 |          |
+| punch_in_result            | varchar(10) | 打卡结果(DONE-完成，UNDONE-未完成)                           |          |
+| settle_result              | varchar(10) | 结算结果（未结算-UNSETTLED，已结算-SETTLED）                 |          |
+| settle_pi_task_id          | bigint      | 结算时的打卡任务ID                                           |          |
+| settle_task_history_id     | bigint      | 结算任务执行记录ID                                           | 普通索引 |
+| settle_points              | int         | 结算奖励积分                                                 |          |
+| created_by                 | bigint      | 创建人                                                       |          |
+| creation_time              | timestamp   | 创建时间                                                     | 普通索引 |
+| last_updated_by            | bigint      | 最后更新人                                                   |          |
+| last_update_time           | timestamp   | 最后更新时间                                                 |          |
+| version                    | bigint      | 版本号                                                       |          |
+| delete_flag                | tinyint     | 逻辑删除标志（0-未删除，1-已删除）                           |          |
+
+
+
+### 打卡多任务打卡记录表
+
+表名：pi_multi_task_history
+
+| 字段                       | 类型        | 描述                                                         | 索引     |
+| -------------------------- | ----------- | ------------------------------------------------------------ | -------- |
+| id                         | bigint      | 主键                                                         | 主键索引 |
+| user_id                    | bigint      | 用户ID                                                       | 普通索引 |
+| multi_task_unique_id       | bigint      | 打卡多任务唯一ID                                             | 普通索引 |
+| punch_in_date              | varchar(10) | 打卡日期                                                     | 普通索引 |
+| total_task_count           | int         | 总任务数                                                     |          |
+| punch_in_done_count        | int         | 打卡完成数                                                   |          |
+| task_continue_status       | varchar(20) | 任务连续打卡状态(连续打卡-CONTINUE、中断-INTERRUPTED)        |          |
+| task_continue_day          | int         | 任务连续天数，第一天开始就等于1                              |          |
+| continue_stage             | varchar(10) | 连续阶段（宽限期-GRACE_STAGE，正常打卡期-NORMAL_STAGE，惩罚期-PENALTY_STAGE） |          |
+| stage_start_date           | date        | 阶段开始日期                                                 |          |
+| stage_end_date             | date        | 阶段结束日期                                                 |          |
+| continue_interrupted_count | int         | 连续中断次数                                                 |          |
+| punch_in_result            | varchar(10) | 打卡结果(DONE-完成，UNDONE-未完成)                           |          |
+| settle_result              | varchar(10) | 结算结果（未结算-UNSETTLED，已结算-SETTLED）                 |          |
+| settle_pi_multi_task_id    | bigint      | 结算时的打卡多任务ID                                         |          |
+| settle_task_history_id     | bigint      | 结算任务执行记录ID                                           | 普通索引 |
+| settle_points              | int         | 结算奖励积分                                                 |          |
+| created_by                 | bigint      | 创建人                                                       |          |
+| creation_time              | timestamp   | 创建时间                                                     |          |
+| last_updated_by            | bigint      | 最后更新人                                                   |          |
+| last_update_time           | timestamp   | 最后更新时间                                                 |          |
+| version                    | bigint      | 版本号                                                       |          |
+| delete_flag                | tinyint     | 逻辑删除标志（0-未删除，1-已删除）                           |          |
 
 
 
 ### 打卡任务状态表
 
-表名：punch_in_status
+表名：pi_status
 
-作用：punch_in_multi_task_unique_id和punch_in_task_unique_id字段不能同时出现，是一张公用表，punch_in_multi_task_unique_id出现时是多任务的打卡状态，punch_in_task_unique_id出现时是单任务的打卡状态
+作用：multi_task_unique_id和task_unique_id字段不能同时出现，是一张公用表，multi_task_unique_id出现时是多任务的打卡状态，task_unique_id出现时是单任务的打卡状态
 
-| 字段                          | 类型        | 描述                                                  | 索引     |
-| ----------------------------- | ----------- | ----------------------------------------------------- | -------- |
-| id                            | bigint      | 主键                                                  | 主键索引 |
-| user_id                       | bigint      | 用户ID                                                | 普通索引 |
-| punch_in_multi_task_unique_id | bigint      | 打卡多任务唯一ID                                      | 普通索引 |
-| punch_in_task_unique_id       | bigint      | 打卡任务唯一ID                                        | 普通索引 |
-| consecutive_status            | varchar(20) | 连续打卡状态(连续打卡-CONSECUTIVE、中断--INTERRUPTED) |          |
-| consecutive_day               | int         | 连续天数，第一天开始就等于1                           |          |
-| start_date                    | date        | 开始日期                                              |          |
-| end_date                      | date        | 结束日期                                              |          |
-| created_by                    | bigint      | 创建人                                                |          |
-| creation_time                 | timestamp   | 创建时间                                              |          |
-| last_updated_by               | bigint      | 最后更新人                                            |          |
-| last_update_time              | timestamp   | 最后更新时间                                          |          |
-| version                       | bigint      | 版本号                                                |          |
-| delete_flag                   | tinyint     | 逻辑删除标志（0-未删除，1-已删除）                    |          |
+| 字段                       | 类型        | 描述                                                         | 索引     |
+| -------------------------- | ----------- | ------------------------------------------------------------ | -------- |
+| id                         | bigint      | 主键                                                         | 主键索引 |
+| user_id                    | bigint      | 用户ID                                                       | 普通索引 |
+| multi_task_unique_id       | bigint      | 打卡多任务唯一ID                                             | 普通索引 |
+| task_unique_id             | bigint      | 打卡任务唯一ID                                               | 普通索引 |
+| status_date                | date        | 记录状态的时间                                               |          |
+| task_continue_status       | varchar(20) | 任务连续打卡状态(连续打卡-CONTINUE、中断-INTERRUPTED)        |          |
+| task_continue_day          | int         | 任务连续天数，第一天开始就等于1                              |          |
+| continue_stage             | varchar(10) | 连续阶段（宽限期-GRACE_STAGE，正常打卡期-NORMAL_STAGE，惩罚期-PENALTY_STAGE） |          |
+| stage_start_date           | date        | 阶段开始日期                                                 |          |
+| stage_end_date             | date        | 阶段结束日期                                                 |          |
+| continue_interrupted_count | int         | 连续中断次数                                                 |          |
+| created_by                 | bigint      | 创建人                                                       |          |
+| creation_time              | timestamp   | 创建时间                                                     |          |
+| last_updated_by            | bigint      | 最后更新人                                                   |          |
+| last_update_time           | timestamp   | 最后更新时间                                                 |          |
+| version                    | bigint      | 版本号                                                       |          |
+| delete_flag                | tinyint     | 逻辑删除标志（0-未删除，1-已删除）                           |          |
 
 
 
 ### 打卡任务状态记录表
 
-表名：punch_in_status_history
+表名：pi_status_history
+
+作用：multi_task_unique_id和task_unique_id字段不能同时出现，是一张公用表，multi_task_unique_id出现时是多任务的打卡状态，task_unique_id出现时是单任务的打卡状态
+
+| 字段                       | 类型        | 描述                                                         | 索引     |
+| -------------------------- | ----------- | ------------------------------------------------------------ | -------- |
+| id                         | bigint      | 主键                                                         | 主键索引 |
+| user_id                    | bigint      | 用户ID                                                       | 普通索引 |
+| multi_task_unique_id       | bigint      | 打卡多任务唯一ID                                             | 普通索引 |
+| task_unique_id             | bigint      | 打卡任务唯一ID                                               | 普通索引 |
+| status_date                | date        | 记录状态的时间                                               | 普通索引 |
+| task_continue_status       | varchar(20) | 任务连续打卡状态(连续打卡-CONTINUE、中断--INTERRUPTED)       |          |
+| task_continue_day          | int         | 任务连续天数，第一天开始就等于1                              |          |
+| continue_stage             | varchar(10) | 连续阶段（宽限期-GRACE_STAGE，正常打卡期-NORMAL_STAGE，惩罚期-PENALTY_STAGE） |          |
+| stage_start_date           | date        | 阶段开始日期                                                 |          |
+| stage_end_date             | date        | 阶段结束日期                                                 |          |
+| continue_interrupted_count | int         | 连续中断次数                                                 |          |
+| created_by                 | bigint      | 创建人                                                       |          |
+| creation_time              | timestamp   | 创建时间                                                     |          |
+| last_updated_by            | bigint      | 最后更新人                                                   |          |
+| last_update_time           | timestamp   | 最后更新时间                                                 |          |
+| version                    | bigint      | 版本号                                                       |          |
+| delete_flag                | tinyint     | 逻辑删除标志（0-未删除，1-已删除）                           |          |
+
 
-| 字段                          | 类型        | 描述                                             | 索引     |
-| ----------------------------- | ----------- | ------------------------------------------------ | -------- |
-| id                            | bigint      | 主键                                             | 主键索引 |
-| user_id                       | bigint      | 用户ID                                           | 普通索引 |
-| punch_in_multi_task_unique_id | bigint      | 打卡多任务唯一ID                                 | 普通索引 |
-| punch_in_task_unique_id       | bigint      | 打卡任务唯一ID                                   | 普通索引 |
-| consecutive_status            | varchar(20) | 连续打卡状态(正常打卡-NORMAL、中断--INTERRUPTED) |          |
-| consecutive_day               | int         | 连续天数，第一天开始就等于1                      |          |
-| start_date                    | date        | 开始日期                                         |          |
-| end_date                      | date        | 结束日期                                         |          |
-| created_by                    | bigint      | 创建人                                           |          |
-| creation_time                 | timestamp   | 创建时间                                         | 普通索引 |
-| last_updated_by               | bigint      | 最后更新人                                       |          |
-| last_update_time              | timestamp   | 最后更新时间                                     |          |
-| version                       | bigint      | 版本号                                           |          |
-| delete_flag                   | tinyint     | 逻辑删除标志（0-未删除，1-已删除）               |          |
 
 
 
@@ -874,6 +897,76 @@ ui设计工具：即时设计
 
 
 
+### 系统日历表
+
+表名：sys_calendar
+
+| 字段             | 类型         | 描述                                                         | 索引     |
+| ---------------- | ------------ | ------------------------------------------------------------ | -------- |
+| id               | bigint       | 主键                                                         | 主键索引 |
+| gregorian_date   | char(10)     | 公历日期，格式：yyyy-MM-dd                                   | 普通索引 |
+| lunar_date       | char(10)     | 农历日期，格式：yyyy-MM-dd                                   |          |
+| week_day         | int          | 周内天数（1-7），周一为1，周日为7                            |          |
+| status           | char(7)      | 状态：WORKDAY-上班， HOLIDAY-放假；上班：含正常工作日及补班；放假：含周末及节假日。 |          |
+| festival         | varhcar(30)  | 国家法定节日：元旦节, 春节, 清明节, 劳动节, 端午节, 中秋节, 国庆节。 |          |
+| bad_day          | char(1)      | 是否补班：Y-是，N-否。需要补班，真是难受的一天！仅当需要补班时有该字段。 |          |
+| description      | varhcar(300) | 描述，表示什么时候补班，例如劳动节前补班、国庆节后补班等。仅需要补班时有该字段。 |          |
+| statutory        | char(1)      | 是否法定节假日：Y-是，N-否。如果是法定节假日则返回1，仅当是法定节假日时有该字段。 |          |
+| created_by       | bigint       | 创建人                                                       |          |
+| creation_time    | timestamp    | 创建时间                                                     |          |
+| last_updated_by  | bigint       | 最后更新人                                                   |          |
+| last_update_time | timestamp    | 最后更新时间                                                 |          |
+| version          | bigint       | 版本号                                                       |          |
+| delete_flag      | tinyint      | 逻辑删除标志（0-未删除，1-已删除）                           |          |
+
+
+
+### 系统定时任务执行配置表
+
+表名：sys_schedule_task
+
+| 字段             | 类型         | 描述                                          |
+| ---------------- | ------------ | --------------------------------------------- |
+| id               | bigint       | 主键                                          |
+| task_code        | varchar(100) | 定时任务编码                                  |
+| task_name        | varchar(100) | 定时任务名称                                  |
+| execute_status   | varchar(10)  | 是否启用定时任务(ENABLED-启用、DISABLED-关闭) |
+| created_by       | bigint       | 创建人                                        |
+| creation_time    | timestamp    | 创建时间                                      |
+| last_updated_by  | bigint       | 最后更新人                                    |
+| last_update_time | timestamp    | 最后更新时间                                  |
+| version          | bigint       | 版本号                                        |
+| delete_flag      | tinyint      | 逻辑删除标志（0-未删除，1-已删除）            |
+
+
+
+### 系统定时任务执行记录表
+
+表名：sys_schedule_task_history
+
+| 字段             | 类型          | 描述                                                | 索引     |
+| ---------------- | ------------- | --------------------------------------------------- | -------- |
+| id               | bigint        | 主键                                                | 主键索引 |
+| task_code        | varchar(100)  | 定时任务编码                                        |          |
+| task_name        | varchar(100)  | 定时任务名称                                        |          |
+| launch_method    | varchar(10)   | 启动方式（AUTO-自动，MANUAL-手动）                  |          |
+| start_time       | timestamp     | 任务开始时间                                        |          |
+| end_time         | timestamp     | 任务结束时间                                        |          |
+| process_status   | varchar(10)   | 执行状态（RUNNING-执行中，SUCCESS-成功，FAIL-失败） |          |
+| error_message    | varchar(5000) | 错误信息                                            |          |
+| created_by       | bigint        | 创建人                                              |          |
+| creation_time    | timestamp     | 创建时间                                            |          |
+| last_updated_by  | bigint        | 最后更新人                                          |          |
+| last_update_time | timestamp     | 最后更新时间                                        |          |
+| version          | bigint        | 版本号                                              |          |
+| delete_flag      | tinyint       | 逻辑删除标志（0-未删除，1-已删除）                  |          |
+
+
+
+
+
+
+
 ### 账户
 
 表名：account
@@ -987,14 +1080,14 @@ ui设计工具：即时设计
 
 ### 打卡任务周数据统计
 
-表名：punch_in_stats_week
+表名：stat_pi_task_week
 
 | 字段                 | 类型         | 描述                               | 索引     |
 | -------------------- | ------------ | ---------------------------------- | -------- |
 | id                   | bigint       | 主键                               | 主键索引 |
 | user_id              | bigint       | 用户id                             | 普通索引 |
 | task_unique_id       | bigint       | 任务唯一ID                         | 普通索引 |
-| stats_time           | char(7)      | 统计时间（格式：yyyy-W周数）       | 普通索引 |
+| stat_time            | char(7)      | 统计时间（格式：yyyy-W周数）       | 普通索引 |
 | punch_in_total_count | int          | 本周需打卡数                       |          |
 | punch_in_count       | int          | 本周已打卡数                       |          |
 | punch_in_done_count  | int          | 本周完成打卡数                     |          |
@@ -1012,14 +1105,14 @@ ui设计工具：即时设计
 
 ### 打卡任务月数据统计
 
-表名：punch_in_stats_month
+表名：stat_pi_task_month
 
 | 字段                 | 类型         | 描述                               | 索引     |
 | -------------------- | ------------ | ---------------------------------- | -------- |
 | id                   | bigint       | 主键                               | 主键索引 |
 | user_id              | bigint       | 用户id                             | 普通索引 |
 | task_unique_id       | bigint       | 任务唯一ID                         | 普通索引 |
-| stats_time           | char(7)      | 统计时间（格式：yyyy-MM）          | 普通索引 |
+| stat_time            | char(7)      | 统计时间（格式：yyyy-MM）          | 普通索引 |
 | punch_in_total_count | int          | 本月需打卡数                       |          |
 | punch_in_count       | int          | 本月已打卡数                       |          |
 | punch_in_done_count  | int          | 本月完成打卡数                     |          |
@@ -1037,14 +1130,14 @@ ui设计工具：即时设计
 
 ### 打卡任务年数据统计
 
-表名：punch_in_stats_year
+表名：stat_pi_task_year
 
 | 字段                 | 类型         | 描述                               | 索引     |
 | -------------------- | ------------ | ---------------------------------- | -------- |
 | id                   | bigint       | 主键                               | 主键索引 |
 | user_id              | bigint       | 用户id                             | 普通索引 |
 | task_unique_id       | bigint       | 任务唯一ID                         | 普通索引 |
-| stats_time           | char(4)      | 统计时间（格式：yyyy）             | 普通索引 |
+| stat_time            | char(4)      | 统计时间（格式：yyyy）             | 普通索引 |
 | punch_in_total_count | int          | 本年需打卡数                       |          |
 | punch_in_count       | int          | 本年已打卡数                       |          |
 | punch_in_done_count  | int          | 本年完成打卡数                     |          |
@@ -1062,13 +1155,13 @@ ui设计工具：即时设计
 
 ### 积分数据统计
 
-表名：points_stats
+表名：stat_points
 
 | 字段             | 类型      | 描述                               | 索引     |
 | ---------------- | --------- | ---------------------------------- | -------- |
 | id               | bigint    | 主键                               | 主键索引 |
 | user_id          | bigint    | 用户id                             | 普通索引 |
-| stats_time       | char(10)  | 统计时间（格式：yyyy-MM-dd）       | 普通索引 |
+| stat_time        | char(10)  | 统计时间（格式：yyyy-MM-dd）       | 普通索引 |
 | settle_points    | int       | 每日积分的结算数                   |          |
 | consume_points   | int       | 每日积分的消耗数量                 |          |
 | total_points     | int       | 每日剩余总积分                     |          |
@@ -1083,12 +1176,12 @@ ui设计工具：即时设计
 
 ### 新用户数据统计
 
-表名：new_user_stats
+表名：stat_new_user
 
 | 字段             | 类型      | 描述                               | 索引     |
 | ---------------- | --------- | ---------------------------------- | -------- |
 | id               | bigint    | 主键                               | 主键索引 |
-| stats_time       | char(10)  | 统计时间（格式：yyyy-MM-dd）       | 普通索引 |
+| stat_time        | char(10)  | 统计时间（格式：yyyy-MM-dd）       | 普通索引 |
 | new_user_count   | int       | 新用户数量                         |          |
 | created_by       | bigint    | 创建人                             |          |
 | creation_time    | timestamp | 创建时间                           |          |
@@ -1099,70 +1192,6 @@ ui设计工具：即时设计
 
 
 
-### 定时任务执行配置表
-
-表名：sys_schedule_task
-
-| 字段             | 类型         | 描述                                          |
-| ---------------- | ------------ | --------------------------------------------- |
-| id               | bigint       | 主键                                          |
-| task_code        | varchar(100) | 定时任务编码                                  |
-| task_name        | varchar(100) | 定时任务名称                                  |
-| execute_status   | varchar(10)  | 是否启用定时任务(ENABLED-启用、DISABLED-关闭) |
-| created_by       | bigint       | 创建人                                        |
-| creation_time    | timestamp    | 创建时间                                      |
-| last_updated_by  | bigint       | 最后更新人                                    |
-| last_update_time | timestamp    | 最后更新时间                                  |
-| version          | bigint       | 版本号                                        |
-| delete_flag      | tinyint      | 逻辑删除标志（0-未删除，1-已删除）            |
-
-
-
-### 定时任务执行记录表
-
-表名：sys_schedule_task_history
-
-| 字段             | 类型          | 描述                                                | 索引     |
-| ---------------- | ------------- | --------------------------------------------------- | -------- |
-| id               | bigint        | 主键                                                | 主键索引 |
-| task_code        | varchar(100)  | 定时任务编码                                        |          |
-| task_name        | varchar(100)  | 定时任务名称                                        |          |
-| launch_method    | varchar(10)   | 启动方式（AUTO-自动，MANUAL-手动）                  |          |
-| start_time       | timestamp     | 任务开始时间                                        |          |
-| end_time         | timestamp     | 任务结束时间                                        |          |
-| process_status   | varchar(10)   | 执行状态（RUNNING-执行中，SUCCESS-成功，FAIL-失败） |          |
-| error_message    | varchar(5000) | 错误信息                                            |          |
-| created_by       | bigint        | 创建人                                              |          |
-| creation_time    | timestamp     | 创建时间                                            |          |
-| last_updated_by  | bigint        | 最后更新人                                          |          |
-| last_update_time | timestamp     | 最后更新时间                                        |          |
-| version          | bigint        | 版本号                                              |          |
-| delete_flag      | tinyint       | 逻辑删除标志（0-未删除，1-已删除）                  |          |
-
-
-
-### 系统日历表
-
-表名：sys_calendar
-
-| 字段             | 类型         | 描述                                                         | 索引     |
-| ---------------- | ------------ | ------------------------------------------------------------ | -------- |
-| id               | bigint       | 主键                                                         | 主键索引 |
-| gregorian_date   | char(10)     | 公历日期，格式：yyyy-MM-dd                                   | 普通索引 |
-| lunar_date       | char(10)     | 农历日期，格式：yyyy-MM-dd                                   |          |
-| week_day         | int          | 周内天数（1-7），周一为1，周日为7                            |          |
-| status           | char(7)      | 状态：WORKDAY-上班， HOLIDAY-放假；上班：含正常工作日及补班；放假：含周末及节假日。 |          |
-| festival         | varhcar(30)  | 国家法定节日：元旦节, 春节, 清明节, 劳动节, 端午节, 中秋节, 国庆节。 |          |
-| bad_day          | char(1)      | 是否补班：Y-是，N-否。需要补班，真是难受的一天！仅当需要补班时有该字段。 |          |
-| description      | varhcar(300) | 描述，表示什么时候补班，例如劳动节前补班、国庆节后补班等。仅需要补班时有该字段。 |          |
-| statutory        | char(1)      | 是否法定节假日：Y-是，N-否。如果是法定节假日则返回1，仅当是法定节假日时有该字段。 |          |
-| created_by       | bigint       | 创建人                                                       |          |
-| creation_time    | timestamp    | 创建时间                                                     |          |
-| last_updated_by  | bigint       | 最后更新人                                                   |          |
-| last_update_time | timestamp    | 最后更新时间                                                 |          |
-| version          | bigint       | 版本号                                                       |          |
-| delete_flag      | tinyint      | 逻辑删除标志（0-未删除，1-已删除）                           |          |
-
 
 
 ## 开发参考

src/main/java/com/punchsettle/server/atomic/entity/PunchInMultiTask.java → src/main/java/com/punchsettle/server/atomic/entity/PiMultiTask.java

@@ -2,19 +2,16 @@ package com.punchsettle.server.atomic.entity;
 
 import java.io.Serial;
 import java.io.Serializable;
-import java.math.BigDecimal;
 
 import com.punchsettle.server.common.pojo.BaseEntity;
 
 import com.punchsettle.server.constant.ArchiveStatusEnum;
 import com.punchsettle.server.common.constant.CommonEnableStatusEnum;
 import com.punchsettle.server.constant.PunchInExtraMethodEnum;
-import com.punchsettle.server.constant.PunchInMethodMultiEnum;
 import jakarta.persistence.Column;
 import jakarta.persistence.Table;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
-import org.checkerframework.checker.units.qual.N;
 
 /**
  * @author tyuio
@@ -24,8 +21,8 @@ import org.checkerframework.checker.units.qual.N;
  */
 @Data
 @EqualsAndHashCode(callSuper = true)
-@Table(name = "punch_in_multi_task")
-public class PunchInMultiTask extends BaseEntity implements Serializable {
+@Table(name = "pi_multi_task")
+public class PiMultiTask extends BaseEntity implements Serializable {
 
     @Serial
     private static final long serialVersionUID = -8616950431388861152L;
@@ -33,21 +30,21 @@ public class PunchInMultiTask extends BaseEntity implements Serializable {
     /**
      * 打卡多任务唯一ID
      */
-    @Column(name = "multi_task_unique_id")
-    private Long multiTaskUniqueId;
+    @Column(name = "unique_id")
+    private Long uniqueId;
 
     /**
      * 任务状态(活跃-ACTIVE，归档-ARCHIVE)
      * @see ArchiveStatusEnum
      */
-    @Column(name = "multi_task_status")
-    private ArchiveStatusEnum multiTaskStatus;
+    @Column(name = "task_status")
+    private ArchiveStatusEnum taskStatus;
 
     /**
      * 任务修改版本
      */
-    @Column(name = "multi_task_version")
-    private Integer multiTaskVersion;
+    @Column(name = "task_version")
+    private Integer taskVersion;
 
     /**
      * 用户ID
@@ -75,11 +72,11 @@ public class PunchInMultiTask extends BaseEntity implements Serializable {
     private Integer points;
 
     /**
-     * 是否启用宽限期(ENABLED-启用，DISABLED-关闭)
+     * 是否启用连续规则(ENABLED-启用，DISABLED-关闭)
      * @see CommonEnableStatusEnum
      */
-    @Column(name = "grace_status")
-    private CommonEnableStatusEnum graceStatus;
+    @Column(name = "continue_status")
+    private CommonEnableStatusEnum continueStatus;
 
     /**
      * 宽限期（单位：天）
@@ -88,10 +85,10 @@ public class PunchInMultiTask extends BaseEntity implements Serializable {
     private Integer graceDay;
 
     /**
-     * 打卡中断天数（单位：天）
+     * 连续中断次数
      */
-    @Column(name = "interrupted_day")
-    private Integer interruptedDay;
+    @Column(name = "continue_interrupted_day")
+    private Integer continueInterruptedDay;
 
     /**
      * 惩罚天数（单位：天）

src/main/java/com/punchsettle/server/atomic/entity/PunchInMultiTaskExt.java → src/main/java/com/punchsettle/server/atomic/entity/PiMultiTaskExt.java

@@ -18,8 +18,8 @@ import lombok.EqualsAndHashCode;
  */
 @Data
 @EqualsAndHashCode(callSuper = true)
-@Table(name = "punchJ_in_multi_task_ext")
-public class PunchInMultiTaskExt extends BaseEntity implements Serializable {
+@Table(name = "pi_multi_task_ext")
+public class PiMultiTaskExt extends BaseEntity implements Serializable {
 
     @Serial
     private static final long serialVersionUID = -1842326979030637250L;

src/main/java/com/punchsettle/server/atomic/entity/PiMultiTaskHistory.java

@@ -0,0 +1,128 @@
+package com.punchsettle.server.atomic.entity;
+
+import java.io.Serial;
+import java.io.Serializable;
+import java.time.LocalDate;
+
+import com.punchsettle.server.common.pojo.BaseEntity;
+
+import com.punchsettle.server.constant.PunchInStatusEnum;
+import jakarta.persistence.Column;
+import jakarta.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springframework.beans.factory.annotation.Autowired;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @description 打卡多任务记录表
+ * @date 2025/04/08 09:49
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@Table(name = "pi_multi_task_history")
+public class PiMultiTaskHistory extends BaseEntity implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = -8993538007673896334L;
+
+    /**
+     * 用户ID
+     */
+    @Column(name = "user_id")
+    private Long userId;
+
+    /**
+     * 打卡多任务唯一ID
+     */
+    @Column(name = "multi_task_unique_id")
+    private Long multiTaskUniqueId;
+
+    /**
+     * 打卡日期
+     */
+    @Column(name = "punch_in_date")
+    private String punchInDate;
+
+
+    /**
+     * 总任务数
+     */
+    @Column(name = "total_task_count")
+    private Integer totalTaskCount;
+
+    /**
+     * 打卡完成数
+     */
+    @Column(name = "punch_in_done_count")
+    private Integer punchInDoneCount;
+
+    /**
+     * 任务连续打卡状态(连续打卡-CONTINUE、中断-INTERRUPTED)
+     */
+    @Column(name = "task_continue_status")
+    private String taskContinueStatus;
+
+    /**
+     * 任务连续天数，第一天开始就等于1
+     */
+    @Column(name = "task_continue_day")
+    private Integer taskContinueDay;
+
+    /**
+     * 连续阶段（宽限期-GRACE_STAGE，正常打卡期-NORMAL_STAGE，惩罚期-PENALTY_STAGE）
+     */
+    @Column(name = "continue_stage")
+    private String continueStage;
+
+    /**
+     * 阶段开始日期
+     */
+    @Column(name = "stage_start_date")
+    private LocalDate stageStartDate;
+
+    /**
+     * 阶段结束日期
+     */
+    @Column(name = "stage_end_date")
+    private LocalDate stageEndDate;
+
+    /**
+     * 连续中断次数
+     */
+    @Column(name = "continue_interrupted_count")
+    private Integer continueInterruptedCount;
+
+    /**
+     * 打卡结果(DONE-完成，UNDONE-未完成)
+     * @see PunchInStatusEnum
+     */
+    @Column(name = "punch_in_result")
+    private PunchInStatusEnum punchInResult;
+
+    /**
+     * 结算结果（未结算-UNSETTLED，已结算-SETTLED）
+     */
+    @Column(name = "settle_result")
+    private String settleResult;
+
+    /**
+     * 结算任务执行ID
+     */
+    @Column(name = "settle_task_history_id")
+    private Long settleTaskHistoryId;
+
+    /**
+     * 结算时的打卡多任务ID
+     */
+    @Column(name = "settle_pi_multi_task_id")
+    private Long settlePiMultiTaskId;
+
+    /**
+     * 结算奖励积分
+     */
+    @Column(name = "settle_points")
+    private Integer settlePoints;
+
+}

src/main/java/com/punchsettle/server/atomic/entity/PunchInMultiTaskRela.java → src/main/java/com/punchsettle/server/atomic/entity/PiMultiTaskRela.java

@@ -18,8 +18,8 @@ import lombok.EqualsAndHashCode;
  */
 @Data
 @EqualsAndHashCode(callSuper = true)
-@Table(name = "punch_in_multi_task_rela")
-public class PunchInMultiTaskRela extends BaseEntity implements Serializable {
+@Table(name = "pi_multi_task_rela")
+public class PiMultiTaskRela extends BaseEntity implements Serializable {
 
     @Serial
     private static final long serialVersionUID = 3897475522655680161L;
@@ -33,12 +33,12 @@ public class PunchInMultiTaskRela extends BaseEntity implements Serializable {
     /**
      * 打卡多任务ID
      */
-    @Column(name = "punch_in_multi_task_id")
-    private Long punchInMultiTaskId;
+    @Column(name = "multi_task_id")
+    private Long multiTaskId;
 
     /**
      * 打卡任务ID
      */
-    @Column(name = "punch_in_task_id")
-    private Long punchInTaskId;
+    @Column(name = "task_id")
+    private Long taskId;
 }

src/main/java/com/punchsettle/server/atomic/entity/PiStatus.java

@@ -0,0 +1,88 @@
+package com.punchsettle.server.atomic.entity;
+
+import java.io.Serial;
+import java.io.Serializable;
+import java.time.LocalDate;
+
+import com.punchsettle.server.common.pojo.BaseEntity;
+import com.punchsettle.server.constant.ConsecutiveStatusEnum;
+import jakarta.persistence.Column;
+import jakarta.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @description 打卡任务状态表
+ * @date 2025/04/08 09:49
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@Table(name = "pi_status")
+public class PiStatus extends BaseEntity implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 3336593993245280066L;
+
+    /**
+     * 用户ID
+     */
+    @Column(name = "user_id")
+    private Long userId;
+
+    /**
+     * 打卡多任务唯一ID
+     */
+    @Column(name = "multi_task_unique_id")
+    private Long multiTaskUniqueId;
+
+    /**
+     * 打卡任务唯一ID
+     */
+    @Column(name = "task_unique_id")
+    private Long taskUniqueId;
+
+    /**
+     * 记录状态的时间
+     */
+    @Column(name = "status_date")
+    private String statusDate;
+
+    /**
+     * 任务连续打卡状态(连续打卡-CONTINUE、中断-INTERRUPTED)
+     * @see ConsecutiveStatusEnum
+     */
+    @Column(name = "task_continue_status")
+    private ConsecutiveStatusEnum taskContinueStatus;
+
+    /**
+     * 任务连续天数，第一天开始就等于1
+     */
+    @Column(name = "task_continue_day")
+    private Integer taskContinueDay;
+
+    /**
+     * 连续阶段（宽限期-GRACE_STAGE，正常打卡期-NORMAL_STAGE，惩罚期-PENALTY_STAGE）
+     */
+    @Column(name = "continue_stage")
+    private String continueStage;
+
+    /**
+     * 阶段开始日期
+     */
+    @Column(name = "stage_start_date")
+    private LocalDate stageStartDate;
+
+    /**
+     * 结束日期
+     */
+    @Column(name = "stage_end_date")
+    private LocalDate stageEndDate;
+
+    /**
+     * 连续中断次数
+     */
+    @Column(name = "连续中断次数")
+    private Integer continueInterruptedCount;
+}

src/main/java/com/punchsettle/server/atomic/entity/PiStatusHistory.java

@@ -0,0 +1,89 @@
+package com.punchsettle.server.atomic.entity;
+
+import java.io.Serial;
+import java.io.Serializable;
+import java.time.LocalDate;
+import java.util.Date;
+
+import com.punchsettle.server.common.pojo.BaseEntity;
+import com.punchsettle.server.constant.ConsecutiveStatusEnum;
+import jakarta.persistence.Column;
+import jakarta.persistence.Table;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @description 打卡任务状态记录表
+ * @date 2025/04/08 09:49
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@Table(name = "pi_status_history")
+public class PiStatusHistory extends BaseEntity implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 4985644914965499020L;
+
+    /**
+     * 用户ID
+     */
+    @Column(name = "user_id")
+    private Long userId;
+
+    /**
+     * 打卡多任务唯一ID
+     */
+    @Column(name = "multi_task_unique_id")
+    private Long multiTaskUniqueId;
+
+    /**
+     * 打卡任务唯一ID
+     */
+    @Column(name = "task_unique_id")
+    private Long taskUniqueId;
+
+    /**
+     * 记录状态的时间
+     */
+    @Column(name = "status_date")
+    private String statusDate;
+
+    /**
+     * 任务连续打卡状态(连续打卡-CONTINUE、中断-INTERRUPTED)
+     * @see ConsecutiveStatusEnum
+     */
+    @Column(name = "task_continue_status")
+    private ConsecutiveStatusEnum taskContinueStatus;
+
+    /**
+     * 任务连续天数，第一天开始就等于1
+     */
+    @Column(name = "task_continue_day")
+    private Integer taskContinueDay;
+
+    /**
+     * 连续阶段（宽限期-GRACE_STAGE，正常打卡期-NORMAL_STAGE，惩罚期-PENALTY_STAGE）
+     */
+    @Column(name = "continue_stage")
+    private String continueStage;
+
+    /**
+     * 阶段开始日期
+     */
+    @Column(name = "stage_start_date")
+    private LocalDate stageStartDate;
+
+    /**
+     * 结束日期
+     */
+    @Column(name = "stage_end_date")
+    private LocalDate stageEndDate;
+
+    /**
+     * 连续中断次数
+     */
+    @Column(name = "连续中断次数")
+    private Integer continueInterruptedCount;
+}

src/main/java/com/punchsettle/server/atomic/entity/PunchInTask.java → src/main/java/com/punchsettle/server/atomic/entity/PiTask.java

@@ -26,8 +26,8 @@ import lombok.EqualsAndHashCode;
  */
 @Data
 @EqualsAndHashCode(callSuper = true)
-@Table(name = "punch_in_task")
-public class PunchInTask extends BaseEntity implements Serializable {
+@Table(name = "pi_task")
+public class PiTask extends BaseEntity implements Serializable {
 
     @Serial
     private static final long serialVersionUID = -8123216246400989207L;
@@ -35,8 +35,8 @@ public class PunchInTask extends BaseEntity implements Serializable {
     /**
      * 任务唯一ID
      */
-    @Column(name = "task_unique_id")
-    private Long taskUniqueId;
+    @Column(name = "unique_id")
+    private Long uniqueId;
 
     /**
      * 任务状态(活跃-ACTIVE，归档-ARCHIVE)
@@ -192,11 +192,11 @@ public class PunchInTask extends BaseEntity implements Serializable {
     private Integer extraPoints;
 
     /**
-     * 是否启用宽限期(ENABLED-启用，DISABLED-关闭)
+     * 是否启用连续规则(ENABLED-启用，DISABLED-关闭)
      * @see CommonEnableStatusEnum
      */
-    @Column(name = "grace_status")
-    private CommonEnableStatusEnum graceStatus;
+    @Column(name = "continue_status")
+    private CommonEnableStatusEnum continueStatus;
 
     /**
      * 宽限期（单位：天）
@@ -205,10 +205,10 @@ public class PunchInTask extends BaseEntity implements Serializable {
     private Integer graceDay;
 
     /**
-     * 打卡中断天数（单位：天）
+     * 连续中断次数
      */
-    @Column(name = "interrupted_day")
-    private Integer interruptedDay;
+    @Column(name = "continue_interrupted_count")
+    private Integer continueInterruptedDay;
 
     /**
      * 惩罚天数（单位：天）

src/main/java/com/punchsettle/server/atomic/entity/PunchInTaskExt.java → src/main/java/com/punchsettle/server/atomic/entity/PiTaskExt.java

@@ -19,8 +19,8 @@ import lombok.EqualsAndHashCode;
  */
 @Data
 @EqualsAndHashCode(callSuper = true)
-@Table(name = "punch_in_task_ext")
-public class PunchInTaskExt extends BaseEntity implements Serializable {
+@Table(name = "pi_task_ext")
+public class PiTaskExt extends BaseEntity implements Serializable {
 
     @Serial
     private static final long serialVersionUID = -400469506734374326L;
@@ -34,8 +34,8 @@ public class PunchInTaskExt extends BaseEntity implements Serializable {
     /**
      * 打卡任务ID
      */
-    @Column(name = "punch_in_task_id")
-    private Long punchInTaskId;
+    @Column(name = "task_id")
+    private Long taskId;
 
     /**
      * 使用维度（一天-ONE_DAY，多天-MULTI_DAY）

src/main/java/com/punchsettle/server/atomic/entity/PunchInTaskHistory.java → src/main/java/com/punchsettle/server/atomic/entity/PiTaskHistory.java

@@ -2,6 +2,7 @@ package com.punchsettle.server.atomic.entity;
 
 import java.io.Serial;
 import java.io.Serializable;
+import java.time.LocalDate;
 import java.time.LocalTime;
 
 import com.punchsettle.server.common.pojo.BaseEntity;
@@ -22,8 +23,8 @@ import lombok.EqualsAndHashCode;
  */
 @Data
 @EqualsAndHashCode(callSuper = true)
-@Table(name = "punch_in_task_history")
-public class PunchInTaskHistory extends BaseEntity implements Serializable {
+@Table(name = "pi_task_history")
+public class PiTaskHistory extends BaseEntity implements Serializable {
 
     @Serial
     private static final long serialVersionUID = -6614493342545702250L;
@@ -37,7 +38,7 @@ public class PunchInTaskHistory extends BaseEntity implements Serializable {
     /**
      * 打卡任务唯一ID
      */
-    @Column(name = "punch_in_task_unique_id")
+    @Column(name = "task_unique_id")
     private Long punchInTaskUniqueId;
 
     /**
@@ -46,13 +47,6 @@ public class PunchInTaskHistory extends BaseEntity implements Serializable {
     @Column(name = "punch_in_date")
     private String punchInDate;
 
-    /**
-     * 打卡状态(DONE-完成，UNDONE-未完成)
-     * @ssee PunchInStatusEnum
-     */
-    @Column(name = "punch_in_status")
-    private PunchInStatusEnum punchInStatus;
-
     /**
      * 次数记录
      */
@@ -65,37 +59,67 @@ public class PunchInTaskHistory extends BaseEntity implements Serializable {
     @Column(name = "time_track")
     private LocalTime timeTrack;
 
+
     /**
-     * 连续打卡状态(正常打卡-NORMAL、中断--INTERRUPTED)
-     * @see ConsecutiveStatusEnum
+     * 任务连续打卡状态(连续打卡-CONTINUE、中断-INTERRUPTED)
      */
-    @Column(name = "consecutive_status")
-    private ConsecutiveStatusEnum consecutiveStatus;
+    @Column(name = "task_continue_status")
+    private String taskContinueStatus;
 
     /**
-     * 连续天数，第一天开始就等于1
+     * 任务连续天数，第一天开始就等于1
      */
-    @Column(name = "consecutive_day")
-    private Integer consecutiveDay;
+    @Column(name = "task_continue_day")
+    private Integer taskContinueDay;
 
     /**
-     * 结算任务执行ID
+     * 连续阶段（宽限期-GRACE_STAGE，正常打卡期-NORMAL_STAGE，惩罚期-PENALTY_STAGE）
      */
-    @Column(name = "settle_task_history_id")
-    private Long settleTaskHistoryId;
+    @Column(name = "continue_stage")
+    private String continueStage;
+
+    /**
+     * 阶段开始日期
+     */
+    @Column(name = "stage_start_date")
+    private LocalDate stageStartDate;
+
+    /**
+     * 阶段结束日期
+     */
+    @Column(name = "stage_end_date")
+    private LocalDate stageEndDate;
 
     /**
-     * 结算状态(未结算-UNSETTLED，宽限期跳过J-GRACE_SKIP，惩罚跳过-PENALTY_SKIP，已结算-SETTLED)
-     * @see SettleStatusEnum
+     * 连续中断次数
      */
-    @Column(name = "settle_status")
-    private SettleStatusEnum settleStatus;
+    @Column(name = "continue_interrupted_count")
+    private Integer continueInterruptedCount;
+
+    /**
+     * 打卡结果(DONE-完成，UNDONE-未完成)
+     * @see PunchInStatusEnum
+     */
+    @Column(name = "punch_in_result")
+    private PunchInStatusEnum punchInResult;
+
+    /**
+     * 结算结果（未结算-UNSETTLED，已结算-SETTLED）
+     */
+    @Column(name = "settle_result")
+    private String settleResult;
+
+    /**
+     * 结算任务执行ID
+     */
+    @Column(name = "settle_task_history_id")
+    private Long settleTaskHistoryId;
 
     /**
-     * 结算时的打卡任务ID
+     * 结算时的打卡多任务ID
      */
-    @Column(name = "settle_punch_in_task_id")
-    private Long settlePunchInTaskId;
+    @Column(name = "settle_pi_multi_task_id")
+    private Long settlePiMultiTaskId;
 
     /**
      * 结算奖励积分

src/main/java/com/punchsettle/server/atomic/entity/PunchInMultiTaskHistory.java

@@ -1,96 +0,0 @@
-package com.punchsettle.server.atomic.entity;
-
-import java.io.Serial;
-import java.io.Serializable;
-import java.math.BigDecimal;
-
-import com.punchsettle.server.common.pojo.BaseEntity;
-
-import com.punchsettle.server.constant.PunchInStatusEnum;
-import jakarta.persistence.Column;
-import jakarta.persistence.Table;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @description 打卡多任务记录表
- * @date 2025/04/08 09:49
- */
-@Data
-@EqualsAndHashCode(callSuper = true)
-@Table(name = "punch_in_multi_task_history")
-public class PunchInMultiTaskHistory extends BaseEntity implements Serializable {
-
-    @Serial
-    private static final long serialVersionUID = -8993538007673896334L;
-
-    /**
-     * 打卡多任务唯一ID
-     */
-    @Column(name = "punch_in_multi_task_unique_id")
-    private Long punchInMultiTaskUniqueId;
-
-    /**
-     * 打卡日期
-     */
-    @Column(name = "punch_in_date")
-    private String punchInDate;
-
-    /**
-     * 打卡状态(DONE-完成，UNDONE-未完成)
-     * @see PunchInStatusEnum
-     */
-    @Column(name = "punch_in_status")
-    private PunchInStatusEnum punchInStatus;
-
-    /**
-     * 总任务数
-     */
-    @Column(name = "total_task_count")
-    private Integer totalTaskCount;
-
-    /**
-     * 打卡完成数
-     */
-    @Column(name = "punch_in_done_count")
-    private Integer punchInDoneCount;
-
-    /**
-     * 连续打卡状态(正常打卡-NORMAL、中断--INTERRUPTED)
-     */
-    @Column(name = "consecutive_status")
-    private String consecutiveStatus;
-
-    /**
-     * 连续天数，第一天开始就等于1
-     */
-    @Column(name = "consecutive_day")
-    private Integer consecutiveDay;
-
-    /**
-     * 结算任务执行ID
-     */
-    @Column(name = "settle_task_history_id")
-    private Long settleTaskHistoryId;
-
-    /**
-     * 结算状态(未结算-UNSETTLED，宽限期跳过J-GRACE_SKIP，惩罚跳过-PENALTY_SKIP，已结算-SETTLED)
-     */
-    @Column(name = "settle_status")
-    private String settleStatus;
-
-    /**
-     * 结算时的打卡多任务ID
-     */
-    @Column(name = "settle_punch_in_multi_task_id")
-    private Long settlePunchInMultiTaskId;
-
-    /**
-     * 结算奖励积分
-     */
-    @Column(name = "settle_points")
-    private Integer settlePoints;
-
-}

src/main/java/com/punchsettle/server/atomic/entity/PunchInStatus.java

@@ -1,72 +0,0 @@
-package com.punchsettle.server.atomic.entity;
-
-import java.io.Serial;
-import java.io.Serializable;
-import java.time.LocalDate;
-import java.util.Date;
-
-import com.punchsettle.server.common.pojo.BaseEntity;
-import com.punchsettle.server.constant.ConsecutiveStatusEnum;
-import jakarta.persistence.Column;
-import jakarta.persistence.Table;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @description 打卡任务状态表
- * @date 2025/04/08 09:49
- */
-@Data
-@EqualsAndHashCode(callSuper = true)
-@Table(name = "punch_in_status")
-public class PunchInStatus extends BaseEntity implements Serializable {
-
-    @Serial
-    private static final long serialVersionUID = 3336593993245280066L;
-
-    /**
-     * 用户ID
-     */
-    @Column(name = "user_id")
-    private Long userId;
-
-    /**
-     * 打卡多任务唯一ID
-     */
-    @Column(name = "punch_in_multi_task_unique_id")
-    private Long punchInMultiTaskUniqueId;
-
-    /**
-     * 打卡任务唯一ID
-     */
-    @Column(name = "punch_in_task_unique_id")
-    private Long punchInTaskUniqueId;
-
-    /**
-     * 连续打卡状态(连续打卡-CONSECUTIVE、中断--INTERRUPTED)
-     * @see ConsecutiveStatusEnum
-     */
-    @Column(name = "consecutive_status")
-    private ConsecutiveStatusEnum consecutiveStatus;
-
-    /**
-     * 连续天数，第一天开始就等于1
-     */
-    @Column(name = "consecutive_day")
-    private Integer consecutiveDay;
-
-    /**
-     * 开始日期
-     */
-    @Column(name = "start_date")
-    private LocalDate startDate;
-
-    /**
-     * 结束日期
-     */
-    @Column(name = "end_date")
-    private LocalDate endDate;
-
-}

src/main/java/com/punchsettle/server/atomic/entity/PunchInStatusHistory.java

@@ -1,69 +0,0 @@
-package com.punchsettle.server.atomic.entity;
-
-import java.io.Serial;
-import java.io.Serializable;
-import java.util.Date;
-
-import com.punchsettle.server.common.pojo.BaseEntity;
-import jakarta.persistence.Column;
-import jakarta.persistence.Table;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @description 打卡任务状态记录表
- * @date 2025/04/08 09:49
- */
-@Data
-@EqualsAndHashCode(callSuper = true)
-@Table(name = "punch_in_status_history")
-public class PunchInStatusHistory extends BaseEntity implements Serializable {
-
-    @Serial
-    private static final long serialVersionUID = 4985644914965499020L;
-
-    /**
-     * 用户ID
-     */
-    @Column(name = "user_id")
-    private Long userId;
-
-    /**
-     * 打卡多任务唯一ID
-     */
-    @Column(name = "punch_in_multi_task_unique_id")
-    private Long punchInMultiTaskUniqueId;
-
-    /**
-     * 打卡任务唯一ID
-     */
-    @Column(name = "punch_in_task_unique_id")
-    private Long punchInTaskUniqueId;
-
-    /**
-     * 连续打卡状态(正常打卡-NORMAL、中断--INTERRUPTED)
-     */
-    @Column(name = "consecutive_status")
-    private String consecutiveStatus;
-
-    /**
-     * 连续天数，第一天开始就等于1
-     */
-    @Column(name = "consecutive_day")
-    private Integer consecutiveDay;
-
-    /**
-     * 开始日期
-     */
-    @Column(name = "start_date")
-    private Date startDate;
-
-    /**
-     * 结束日期
-     */
-    @Column(name = "end_date")
-    private Date endDate;
-
-}

src/main/java/com/punchsettle/server/atomic/entity/NewUserStats.java → src/main/java/com/punchsettle/server/atomic/entity/StatNewUser.java

@@ -18,8 +18,8 @@ import lombok.EqualsAndHashCode;
  */
 @Data
 @EqualsAndHashCode(callSuper = true)
-@Table(name = "new_user_stats")
-public class NewUserStats extends BaseEntity implements Serializable {
+@Table(name = "stat_new_user")
+public class StatNewUser extends BaseEntity implements Serializable {
 
     @Serial
     private static final long serialVersionUID = 6328306652525151160L;
@@ -27,8 +27,8 @@ public class NewUserStats extends BaseEntity implements Serializable {
     /**
      * 统计时间（格式：yyyy-MM-dd）
      */
-    @Column(name = "stats_time")
-    private String statsTime;
+    @Column(name = "stat_time")
+    private String statTime;
 
     /**
      * 新用户数量

src/main/java/com/punchsettle/server/atomic/entity/PunchInStatsMonth.java → src/main/java/com/punchsettle/server/atomic/entity/StatPiTaskMonth.java

@@ -19,8 +19,8 @@ import lombok.EqualsAndHashCode;
  */
 @Data
 @EqualsAndHashCode(callSuper = true)
-@Table(name = "punch_in_stats_month")
-public class PunchInStatsMonth extends BaseEntity implements Serializable {
+@Table(name = "stat_pi_task_month")
+public class StatPiTaskMonth extends BaseEntity implements Serializable {
 
     @Serial
     private static final long serialVersionUID = -590856736982272243L;
@@ -41,7 +41,7 @@ public class PunchInStatsMonth extends BaseEntity implements Serializable {
      * 统计时间（格式：yyyy-MM）
      */
     @Column(name = "stats_time")
-    private String statsTime;
+    private String statTime;
 
     /**
      * 本月需打卡数

src/main/java/com/punchsettle/server/atomic/entity/PunchInStatsWeek.java → src/main/java/com/punchsettle/server/atomic/entity/StatPiTaskWeek.java

@@ -19,8 +19,8 @@ import lombok.EqualsAndHashCode;
  */
 @Data
 @EqualsAndHashCode(callSuper = true)
-@Table(name = "punch_in_stats_week")
-public class PunchInStatsWeek extends BaseEntity implements Serializable {
+@Table(name = "stat_pi_task_week")
+public class StatPiTaskWeek extends BaseEntity implements Serializable {
 
     @Serial
     private static final long serialVersionUID = -590856736982272243L;
@@ -41,7 +41,7 @@ public class PunchInStatsWeek extends BaseEntity implements Serializable {
      * 统计时间（格式：yyyy-周数）
      */
     @Column(name = "stats_time")
-    private String statsTime;
+    private String statTime;
 
     /**
      * 本周需打卡数

src/main/java/com/punchsettle/server/atomic/entity/PunchInStatsYear.java → src/main/java/com/punchsettle/server/atomic/entity/StatPiTaskYear.java

@@ -19,8 +19,8 @@ import lombok.EqualsAndHashCode;
  */
 @Data
 @EqualsAndHashCode(callSuper = true)
-@Table(name = "punch_in_stats_year")
-public class PunchInStatsYear extends BaseEntity implements Serializable {
+@Table(name = "stat_pi_task_year")
+public class StatPiTaskYear extends BaseEntity implements Serializable {
 
     @Serial
     private static final long serialVersionUID = 4320138404959615628L;
@@ -40,8 +40,8 @@ public class PunchInStatsYear extends BaseEntity implements Serializable {
     /**
      * 统计时间（格式：yyyy）
      */
-    @Column(name = "stats_time")
-    private String statsTime;
+    @Column(name = "stat_time")
+    private String statTime;
 
     /**
      * 本年需打卡数

src/main/java/com/punchsettle/server/atomic/entity/PointsStats.java → src/main/java/com/punchsettle/server/atomic/entity/StatPoints.java

@@ -18,8 +18,8 @@ import lombok.EqualsAndHashCode;
  */
 @Data
 @EqualsAndHashCode(callSuper = true)
-@Table(name = "points_stats")
-public class PointsStats extends BaseEntity implements Serializable {
+@Table(name = "stat_points")
+public class StatPoints extends BaseEntity implements Serializable {
 
     @Serial
     private static final long serialVersionUID = -3999261546475470489L;
@@ -33,8 +33,8 @@ public class PointsStats extends BaseEntity implements Serializable {
     /**
      * 统计时间（格式：yyyy-MM-dd）
      */
-    @Column(name = "stats_time")
-    private String statsTime;
+    @Column(name = "stat_time")
+    private String statTime;
 
     /**
      * 每日积分的结算数

src/main/java/com/punchsettle/server/atomic/mapper/PunchInMultiTaskExtMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/PiMultiTaskExtMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskExt;
+import com.punchsettle.server.atomic.entity.PiMultiTaskExt;
 import tk.mybatis.mapper.common.Mapper;
 
 /**
@@ -9,6 +9,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 打卡多任务拓展表 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PunchInMultiTaskExtMapper extends Mapper<PunchInMultiTaskExt> {
+public interface PiMultiTaskExtMapper extends Mapper<PiMultiTaskExt> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/PunchInMultiTaskHistoryMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/PiMultiTaskHistoryMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskHistory;
+import com.punchsettle.server.atomic.entity.PiMultiTaskHistory;
 import tk.mybatis.mapper.additional.update.batch.BatchUpdateSelectiveMapper;
 import tk.mybatis.mapper.common.Mapper;
 
@@ -10,6 +10,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 打卡多任务记录表 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PunchInMultiTaskHistoryMapper extends Mapper<PunchInMultiTaskHistory>, BatchUpdateSelectiveMapper<PunchInMultiTaskHistory> {
+public interface PiMultiTaskHistoryMapper extends Mapper<PiMultiTaskHistory>, BatchUpdateSelectiveMapper<PiMultiTaskHistory> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/PunchInMultiTaskMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/PiMultiTaskMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTask;
+import com.punchsettle.server.atomic.entity.PiMultiTask;
 import tk.mybatis.mapper.common.Mapper;
 
 /**
@@ -9,6 +9,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 打卡多任务表 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PunchInMultiTaskMapper extends Mapper<PunchInMultiTask> {
+public interface PiMultiTaskMapper extends Mapper<PiMultiTask> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/PunchInMultiTaskRelaMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/PiMultiTaskRelaMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskRela;
+import com.punchsettle.server.atomic.entity.PiMultiTaskRela;
 import tk.mybatis.mapper.common.Mapper;
 
 /**
@@ -9,6 +9,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 打卡多任务关联表 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PunchInMultiTaskRelaMapper extends Mapper<PunchInMultiTaskRela> {
+public interface PiMultiTaskRelaMapper extends Mapper<PiMultiTaskRela> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/PunchInStatusHistoryMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/PiStatusHistoryMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PunchInStatusHistory;
+import com.punchsettle.server.atomic.entity.PiStatusHistory;
 import tk.mybatis.mapper.common.Mapper;
 
 /**
@@ -9,6 +9,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 打卡任务状态记录表 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PunchInStatusHistoryMapper extends Mapper<PunchInStatusHistory> {
+public interface PiStatusHistoryMapper extends Mapper<PiStatusHistory> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/PunchInStatusMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/PiStatusMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PunchInStatus;
+import com.punchsettle.server.atomic.entity.PiStatus;
 import tk.mybatis.mapper.common.Mapper;
 
 /**
@@ -9,6 +9,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 打卡任务状态表 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PunchInStatusMapper extends Mapper<PunchInStatus> {
+public interface PiStatusMapper extends Mapper<PiStatus> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/PunchInTaskExtMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/PiTaskExtMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PunchInTaskExt;
+import com.punchsettle.server.atomic.entity.PiTaskExt;
 import tk.mybatis.mapper.common.Mapper;
 
 /**
@@ -9,6 +9,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 打卡任务拓展表 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PunchInTaskExtMapper extends Mapper<PunchInTaskExt> {
+public interface PiTaskExtMapper extends Mapper<PiTaskExt> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/PunchInTaskHistoryMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/PiTaskHistoryMapper.java

@@ -1,7 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PunchInRecord;
-import com.punchsettle.server.atomic.entity.PunchInTaskHistory;
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
 import tk.mybatis.mapper.additional.update.batch.BatchUpdateSelectiveMapper;
 import tk.mybatis.mapper.common.Mapper;
 
@@ -11,6 +10,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 打卡任务记录表 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PunchInTaskHistoryMapper extends Mapper<PunchInTaskHistory>, BatchUpdateSelectiveMapper<PunchInTaskHistory> {
+public interface PiTaskHistoryMapper extends Mapper<PiTaskHistory>, BatchUpdateSelectiveMapper<PiTaskHistory> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/PunchInTaskMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/PiTaskMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PunchInTask;
+import com.punchsettle.server.atomic.entity.PiTask;
 import tk.mybatis.mapper.common.Mapper;
 
 /**
@@ -9,6 +9,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 打卡任务表 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PunchInTaskMapper extends Mapper<PunchInTask> {
+public interface PiTaskMapper extends Mapper<PiTask> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/NewUserStatsMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/StatNewUserMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.NewUserStats;
+import com.punchsettle.server.atomic.entity.StatNewUser;
 import tk.mybatis.mapper.common.Mapper;
 
 /**
@@ -9,6 +9,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 新用户数据统计 Mapper
  * @date 2025/04/08 10:30
  */
-public interface NewUserStatsMapper extends Mapper<NewUserStats> {
+public interface StatNewUserMapper extends Mapper<StatNewUser> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/PunchInStatsMonthMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/StatPiTaskMonthMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PunchInStatsMonth;
+import com.punchsettle.server.atomic.entity.StatPiTaskMonth;
 import tk.mybatis.mapper.common.Mapper;
 
 /**
@@ -9,6 +9,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 打卡任务月数据统计 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PunchInStatsMonthMapper extends Mapper<PunchInStatsMonth> {
+public interface StatPiTaskMonthMapper extends Mapper<StatPiTaskMonth> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/PunchInStatsWeekMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/StatPiTaskWeekMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PunchInStatsWeek;
+import com.punchsettle.server.atomic.entity.StatPiTaskWeek;
 
 import tk.mybatis.mapper.common.Mapper;
 
@@ -10,6 +10,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 打卡任务周数据统计 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PunchInStatsWeekMapper extends Mapper<PunchInStatsWeek> {
+public interface StatPiTaskWeekMapper extends Mapper<StatPiTaskWeek> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/PunchInStatsYearMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/StatPiTaskYearMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PunchInStatsYear;
+import com.punchsettle.server.atomic.entity.StatPiTaskYear;
 import tk.mybatis.mapper.common.Mapper;
 
 /**
@@ -9,6 +9,6 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 打卡任务年数据统计 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PunchInStatsYearMapper extends Mapper<PunchInStatsYear> {
+public interface StatPiTaskYearMapper extends Mapper<StatPiTaskYear> {
 
 }

src/main/java/com/punchsettle/server/atomic/mapper/PointsStatsMapper.java → src/main/java/com/punchsettle/server/atomic/mapper/StatPointsMapper.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.mapper;
 
-import com.punchsettle.server.atomic.entity.PointsStats;
+import com.punchsettle.server.atomic.entity.StatPoints;
 import tk.mybatis.mapper.common.Mapper;
 
 /**
@@ -9,5 +9,5 @@ import tk.mybatis.mapper.common.Mapper;
  * @description 积分数据统计 Mapper
  * @date 2025/04/08 10:30
  */
-public interface PointsStatsMapper extends Mapper< PointsStats> {
+public interface StatPointsMapper extends Mapper<StatPoints> {
 }

src/main/java/com/punchsettle/server/atomic/service/IPiMultiTaskExtService.java

@@ -0,0 +1,22 @@
+package com.punchsettle.server.atomic.service;
+
+import com.punchsettle.server.atomic.entity.PiMultiTaskExt;
+import com.punchsettle.server.pojo.punchIn.PiMultiTaskExtQuery;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:36
+ * @description 打卡多任务拓展表 service
+ */
+public interface IPiMultiTaskExtService {
+
+    /**
+     * 根据条件查询打卡多任务拓展表
+     * @param piMultiTaskExtQuery
+     * @return
+     */
+    List<PiMultiTaskExt> queryByCondition(PiMultiTaskExtQuery piMultiTaskExtQuery);
+}

src/main/java/com/punchsettle/server/atomic/service/IPiMultiTaskHistoryService.java

@@ -0,0 +1,28 @@
+package com.punchsettle.server.atomic.service;
+
+import com.punchsettle.server.atomic.entity.PiMultiTaskHistory;
+import com.punchsettle.server.pojo.punchIn.PiMultiTaskHistoryQuery;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:36
+ * @description 打卡多任务记录表 service
+ */
+public interface IPiMultiTaskHistoryService {
+
+    /**
+     * 根据条件查询打卡多任务记录表
+     * @param piMultiTaskHistoryQuery 查询条件
+     * @return 打卡多任务记录表列表
+     */
+    List<PiMultiTaskHistory> queryByCondition(PiMultiTaskHistoryQuery piMultiTaskHistoryQuery);
+
+    /**
+     * 批量更新打卡多任务记录表
+     * @param piMultiTaskHistoryList
+     */
+    void batchUpdate(List<PiMultiTaskHistory> piMultiTaskHistoryList);
+}

src/main/java/com/punchsettle/server/atomic/service/IPunchInMultiTaskRelaService.java → src/main/java/com/punchsettle/server/atomic/service/IPiMultiTaskRelaService.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.service;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskRela;
+import com.punchsettle.server.atomic.entity.PiMultiTaskRela;
 
 import java.util.Collection;
 import java.util.List;
@@ -11,12 +11,12 @@ import java.util.List;
  * @date 2025/4/8 10:37
  * @description 打卡多任务关联表 service
  */
-public interface IPunchInMultiTaskRelaService {
+public interface IPiMultiTaskRelaService {
 
     /**
      * 根据多任务id查询多任务关联表
      * @param multiTaskIds
      * @return
      */
-    List<PunchInMultiTaskRela> queryByMultiTaskId(Collection<Long> multiTaskIds);
+    List<PiMultiTaskRela> queryByMultiTaskId(Collection<Long> multiTaskIds);
 }

src/main/java/com/punchsettle/server/atomic/service/IPiMultiTaskService.java

@@ -0,0 +1,22 @@
+package com.punchsettle.server.atomic.service;
+
+import com.punchsettle.server.atomic.entity.PiMultiTask;
+import com.punchsettle.server.pojo.punchIn.PiMultiTaskQuery;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:36
+ * @description 打卡多任务表 service
+ */
+public interface IPiMultiTaskService {
+
+    /**
+     * 根据条件查询打卡多任务表
+     * @param piMultiTaskQuery
+     * @return
+     */
+    List<PiMultiTask> queryByCondition(PiMultiTaskQuery piMultiTaskQuery);
+}

src/main/java/com/punchsettle/server/atomic/service/IPunchInStatusHistoryService.java → src/main/java/com/punchsettle/server/atomic/service/IPiStatusHistoryService.java

@@ -6,5 +6,5 @@ package com.punchsettle.server.atomic.service;
  * @date 2025/4/8 10:37
  * @description 打卡任务状态记录表 service
  */
-public interface IPunchInStatusHistoryService {
+public interface IPiStatusHistoryService {
 }

src/main/java/com/punchsettle/server/atomic/service/IPiStatusService.java

@@ -0,0 +1,22 @@
+package com.punchsettle.server.atomic.service;
+
+import com.punchsettle.server.atomic.entity.PiStatus;
+import com.punchsettle.server.pojo.punchIn.PiStatusQuery;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:37
+ * @description 打卡任务状态表 service
+ */
+public interface IPiStatusService {
+
+    /**
+     * 根据条件查询打卡任务状态
+     * @param piStatusQuery
+     * @return
+     */
+    List<PiStatus> queryByCondition(PiStatusQuery piStatusQuery);
+}

src/main/java/com/punchsettle/server/atomic/service/IPiTaskExtService.java

@@ -0,0 +1,22 @@
+package com.punchsettle.server.atomic.service;
+
+import com.punchsettle.server.atomic.entity.PiTaskExt;
+import com.punchsettle.server.pojo.punchIn.PiTaskExtQuery;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:38
+ * @description 打卡任务拓展表 service
+ */
+public interface IPiTaskExtService {
+
+    /**
+     * 根据条件查询打卡任务拓展表
+     * @param piTaskExtQuery
+     * @return
+     */
+    List<PiTaskExt> queryByCondition(PiTaskExtQuery piTaskExtQuery);
+}

src/main/java/com/punchsettle/server/atomic/service/IPiTaskHistoryService.java

@@ -0,0 +1,28 @@
+package com.punchsettle.server.atomic.service;
+
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
+import com.punchsettle.server.pojo.punchIn.PiTaskHistoryQuery;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:38
+ * @description 打卡任务记录表 service
+ */
+public interface IPiTaskHistoryService {
+
+    /**
+     * 根据条件查询打卡任务记录
+     * @param piTaskHistoryQuery 查询条件
+     * @return
+     */
+    List<PiTaskHistory> queryByCondition(PiTaskHistoryQuery piTaskHistoryQuery);
+
+    /**
+     * 批量更新打卡任务记录
+     * @param punchInTaskHistories
+     */
+    void batchUpdate(List<PiTaskHistory> punchInTaskHistories);
+}

src/main/java/com/punchsettle/server/atomic/service/IPiTaskService.java

@@ -0,0 +1,22 @@
+package com.punchsettle.server.atomic.service;
+
+import com.punchsettle.server.atomic.entity.PiTask;
+import com.punchsettle.server.pojo.punchIn.PiTaskQuery;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:38
+ * @description 打卡任务表 service
+ */
+public interface IPiTaskService {
+
+    /**
+     * 根据条件查询打卡任务
+     * @param piTaskQuery
+     * @return
+     */
+    List<PiTask> queryByCondition(PiTaskQuery piTaskQuery);
+}

src/main/java/com/punchsettle/server/atomic/service/IPunchInMultiTaskExtService.java

@@ -1,22 +0,0 @@
-package com.punchsettle.server.atomic.service;
-
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskExt;
-import com.punchsettle.server.pojo.punchIn.PunchInMultiTaskExtQuery;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:36
- * @description 打卡多任务拓展表 service
- */
-public interface IPunchInMultiTaskExtService {
-
-    /**
-     * 根据条件查询打卡多任务拓展表
-     * @param punchInMultiTaskExtQuery
-     * @return
-     */
-    List<PunchInMultiTaskExt> queryByCondition(PunchInMultiTaskExtQuery punchInMultiTaskExtQuery);
-}

src/main/java/com/punchsettle/server/atomic/service/IPunchInMultiTaskHistoryService.java

@@ -1,28 +0,0 @@
-package com.punchsettle.server.atomic.service;
-
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskHistory;
-import com.punchsettle.server.pojo.punchIn.PunchInMultiTaskHistoryQuery;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:36
- * @description 打卡多任务记录表 service
- */
-public interface IPunchInMultiTaskHistoryService {
-
-    /**
-     * 根据条件查询打卡多任务记录表
-     * @param punchInMultiTaskHistoryQuery 查询条件
-     * @return 打卡多任务记录表列表
-     */
-    List<PunchInMultiTaskHistory> queryByCondition(PunchInMultiTaskHistoryQuery punchInMultiTaskHistoryQuery);
-
-    /**
-     * 批量更新打卡多任务记录表
-     * @param punchInMultiTaskHistoryList
-     */
-    void batchUpdate(List<PunchInMultiTaskHistory> punchInMultiTaskHistoryList);
-}

src/main/java/com/punchsettle/server/atomic/service/IPunchInMultiTaskService.java

@@ -1,22 +0,0 @@
-package com.punchsettle.server.atomic.service;
-
-import com.punchsettle.server.atomic.entity.PunchInMultiTask;
-import com.punchsettle.server.pojo.punchIn.PunchInMultiTaskQuery;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:36
- * @description 打卡多任务表 service
- */
-public interface IPunchInMultiTaskService {
-
-    /**
-     * 根据条件查询打卡多任务表
-     * @param punchInMultiTaskQuery
-     * @return
-     */
-    List<PunchInMultiTask> queryByCondition(PunchInMultiTaskQuery punchInMultiTaskQuery);
-}

src/main/java/com/punchsettle/server/atomic/service/IPunchInStatsMonthService.java

@@ -1,22 +0,0 @@
-package com.punchsettle.server.atomic.service;
-
-import com.punchsettle.server.atomic.entity.PunchInStatsMonth;
-import com.punchsettle.server.pojo.punchIn.PunchInStatsMonthQuery;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:37
- * @description 打卡任务月数据统计 service
- */
-public interface IPunchInStatsMonthService {
-
-    /**
-     * 根据条件查询打卡任务月数据统计
-     * @param punchInStatsMonthQuery
-     * @return
-     */
-    List<PunchInStatsMonth> queryByCondition(PunchInStatsMonthQuery punchInStatsMonthQuery);
-}

src/main/java/com/punchsettle/server/atomic/service/IPunchInStatsWeekService.java

@@ -1,22 +0,0 @@
-package com.punchsettle.server.atomic.service;
-
-import com.punchsettle.server.atomic.entity.PunchInStatsWeek;
-import com.punchsettle.server.pojo.punchIn.PunchInStatsWeekQuery;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:37
- * @description 打卡任务周数据统计 service
- */
-public interface IPunchInStatsWeekService {
-
-    /**
-     * 根据条件查询打卡任务周数据统计
-     * @param punchInStatsWeekQuery
-     * @return
-     */
-    List<PunchInStatsWeek> queryByCondition(PunchInStatsWeekQuery punchInStatsWeekQuery);
-}

src/main/java/com/punchsettle/server/atomic/service/IPunchInStatusService.java

@@ -1,22 +0,0 @@
-package com.punchsettle.server.atomic.service;
-
-import com.punchsettle.server.atomic.entity.PunchInStatus;
-import com.punchsettle.server.pojo.punchIn.PunchInStatusQuery;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:37
- * @description 打卡任务状态表 service
- */
-public interface IPunchInStatusService {
-
-    /**
-     * 根据条件查询打卡任务状态
-     * @param punchInStatusQuery
-     * @return
-     */
-    List<PunchInStatus> queryByCondition(PunchInStatusQuery punchInStatusQuery);
-}

src/main/java/com/punchsettle/server/atomic/service/IPunchInTaskExtService.java

@@ -1,22 +0,0 @@
-package com.punchsettle.server.atomic.service;
-
-import com.punchsettle.server.atomic.entity.PunchInTaskExt;
-import com.punchsettle.server.pojo.punchIn.PunchInTaskExtQuery;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:38
- * @description 打卡任务拓展表 service
- */
-public interface IPunchInTaskExtService {
-
-    /**
-     * 根据条件查询打卡任务拓展表
-     * @param punchInTaskExtQuery
-     * @return
-     */
-    List<PunchInTaskExt> queryByCondition(PunchInTaskExtQuery punchInTaskExtQuery);
-}

src/main/java/com/punchsettle/server/atomic/service/IPunchInTaskHistoryService.java

@@ -1,28 +0,0 @@
-package com.punchsettle.server.atomic.service;
-
-import com.punchsettle.server.atomic.entity.PunchInTaskHistory;
-import com.punchsettle.server.pojo.punchIn.PunchInTaskHistoryQuery;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:38
- * @description 打卡任务记录表 service
- */
-public interface IPunchInTaskHistoryService {
-
-    /**
-     * 根据条件查询打卡任务记录
-     * @param punchInTaskHistoryQuery 查询条件
-     * @return
-     */
-    List<PunchInTaskHistory> queryByCondition(PunchInTaskHistoryQuery punchInTaskHistoryQuery);
-
-    /**
-     * 批量更新打卡任务记录
-     * @param punchInTaskHistories
-     */
-    void batchUpdate(List<PunchInTaskHistory> punchInTaskHistories);
-}

src/main/java/com/punchsettle/server/atomic/service/IPunchInTaskService.java

@@ -1,22 +0,0 @@
-package com.punchsettle.server.atomic.service;
-
-import com.punchsettle.server.atomic.entity.PunchInTask;
-import com.punchsettle.server.pojo.punchIn.PunchInTaskQuery;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:38
- * @description 打卡任务表 service
- */
-public interface IPunchInTaskService {
-
-    /**
-     * 根据条件查询打卡任务
-     * @param punchInTaskQuery
-     * @return
-     */
-    List<PunchInTask> queryByCondition(PunchInTaskQuery punchInTaskQuery);
-}

src/main/java/com/punchsettle/server/atomic/service/INewUserStatsService.java → src/main/java/com/punchsettle/server/atomic/service/IStatNewUserService.java

@@ -6,5 +6,5 @@ package com.punchsettle.server.atomic.service;
  * @date 2025/4/8 10:36
  * @description 新用户数据统计 service
  */
-public interface INewUserStatsService {
+public interface IStatNewUserService {
 }

src/main/java/com/punchsettle/server/atomic/service/IStatPiTaskMonthService.java

@@ -0,0 +1,22 @@
+package com.punchsettle.server.atomic.service;
+
+import com.punchsettle.server.atomic.entity.StatPiTaskMonth;
+import com.punchsettle.server.pojo.punchIn.PiStatsMonthQuery;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:37
+ * @description 打卡任务月数据统计 service
+ */
+public interface IStatPiTaskMonthService {
+
+    /**
+     * 根据条件查询打卡任务月数据统计
+     * @param piStatsMonthQuery
+     * @return
+     */
+    List<StatPiTaskMonth> queryByCondition(PiStatsMonthQuery piStatsMonthQuery);
+}

src/main/java/com/punchsettle/server/atomic/service/IStatPiTaskWeekService.java

@@ -0,0 +1,22 @@
+package com.punchsettle.server.atomic.service;
+
+import com.punchsettle.server.atomic.entity.StatPiTaskWeek;
+import com.punchsettle.server.pojo.punchIn.StatPiTaskWeekQuery;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:37
+ * @description 打卡任务周数据统计 service
+ */
+public interface IStatPiTaskWeekService {
+
+    /**
+     * 根据条件查询打卡任务周数据统计
+     * @param statPiTaskWeekQuery
+     * @return
+     */
+    List<StatPiTaskWeek> queryByCondition(StatPiTaskWeekQuery statPiTaskWeekQuery);
+}

src/main/java/com/punchsettle/server/atomic/service/IPunchInStatsYearService.java → src/main/java/com/punchsettle/server/atomic/service/IStatPiTaskYearService.java

@@ -6,5 +6,5 @@ package com.punchsettle.server.atomic.service;
  * @date 2025/4/8 10:37
  * @description 打卡任务年数据统计 service
  */
-public interface IPunchInStatsYearService {
+public interface IStatPiTaskYearService {
 }

src/main/java/com/punchsettle/server/atomic/service/IPointsStatsService.java → src/main/java/com/punchsettle/server/atomic/service/IStatPointsService.java

@@ -6,5 +6,5 @@ package com.punchsettle.server.atomic.service;
  * @date 2025/4/8 10:36
  * @description 积分数据统计 service
  */
-public interface IPointsStatsService {
+public interface IStatPointsService {
 }

src/main/java/com/punchsettle/server/atomic/service/impl/PiMultiTaskExtServiceImpl.java

@@ -0,0 +1,40 @@
+package com.punchsettle.server.atomic.service.impl;
+
+import com.punchsettle.server.atomic.entity.PiMultiTaskExt;
+import com.punchsettle.server.atomic.mapper.PiMultiTaskExtMapper;
+import com.punchsettle.server.atomic.service.IPiMultiTaskExtService;
+import com.punchsettle.server.common.utils.Assert;
+import com.punchsettle.server.pojo.punchIn.PiMultiTaskExtQuery;
+import com.punchsettle.server.utiis.WeekendUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import tk.mybatis.mapper.weekend.Weekend;
+import tk.mybatis.mapper.weekend.WeekendCriteria;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:51
+ * @description 打卡多任务拓展表 service
+ */
+@Service
+public class PiMultiTaskExtServiceImpl implements IPiMultiTaskExtService {
+
+    @Autowired
+    private PiMultiTaskExtMapper piMultiTaskExtMapper;
+
+    @Override
+    public List<PiMultiTaskExt> queryByCondition(PiMultiTaskExtQuery piMultiTaskExtQuery) {
+        Assert.isNull(piMultiTaskExtQuery);
+
+        Weekend<PiMultiTaskExt> weekend = WeekendUtils.createExcludeAuditFields(PiMultiTaskExt.class);
+        WeekendCriteria<PiMultiTaskExt, Object> criteria = weekend.weekendCriteria();
+        if (!CollectionUtils.isEmpty(piMultiTaskExtQuery.getMultiTaskIds())) {
+            criteria.andIn(PiMultiTaskExt::getMultiTaskId, piMultiTaskExtQuery.getMultiTaskIds());
+        }
+        return piMultiTaskExtMapper.selectByExample(weekend);
+    }
+}

src/main/java/com/punchsettle/server/atomic/service/impl/PiMultiTaskHistoryServiceImpl.java

@@ -0,0 +1,50 @@
+package com.punchsettle.server.atomic.service.impl;
+
+import com.punchsettle.server.atomic.entity.PiMultiTaskHistory;
+import com.punchsettle.server.atomic.mapper.PiMultiTaskHistoryMapper;
+import com.punchsettle.server.atomic.service.IPiMultiTaskHistoryService;
+import com.punchsettle.server.common.utils.Assert;
+import com.punchsettle.server.pojo.punchIn.PiMultiTaskHistoryQuery;
+import com.punchsettle.server.utiis.WeekendUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.StringUtils;
+import tk.mybatis.mapper.weekend.Weekend;
+import tk.mybatis.mapper.weekend.WeekendCriteria;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:51
+ * @description 打卡多任务记录表 service
+ */
+@Service
+public class PiMultiTaskHistoryServiceImpl implements IPiMultiTaskHistoryService {
+
+    @Autowired
+    private PiMultiTaskHistoryMapper piMultiTaskHistoryMapper;
+
+    @Override
+    public List<PiMultiTaskHistory> queryByCondition(PiMultiTaskHistoryQuery piMultiTaskHistoryQuery) {
+        Assert.isNull(piMultiTaskHistoryQuery);
+
+        Weekend<PiMultiTaskHistory> weekend = WeekendUtils.createExcludeAuditFields(PiMultiTaskHistory.class);
+        WeekendCriteria<PiMultiTaskHistory, Object> criteria = weekend.weekendCriteria();
+        if (!CollectionUtils.isEmpty(piMultiTaskHistoryQuery.getPunchInMultiTaskUniqueIds())) {
+            criteria.andIn(PiMultiTaskHistory::getMultiTaskUniqueId, piMultiTaskHistoryQuery.getPunchInMultiTaskUniqueIds());
+        }
+        if (StringUtils.hasText(piMultiTaskHistoryQuery.getPunchInDate())) {
+            criteria.andEqualTo(PiMultiTaskHistory::getPunchInDate, piMultiTaskHistoryQuery.getPunchInDate());
+        }
+        return piMultiTaskHistoryMapper.selectByExample(weekend);
+    }
+
+    @Override
+    public void batchUpdate(List<PiMultiTaskHistory> piMultiTaskHistoryList) {
+        Assert.notEmpty(piMultiTaskHistoryList);
+        piMultiTaskHistoryMapper.batchUpdateSelective(piMultiTaskHistoryList);
+    }
+}

src/main/java/com/punchsettle/server/atomic/service/impl/PiMultiTaskRelaServiceImpl.java

@@ -0,0 +1,40 @@
+package com.punchsettle.server.atomic.service.impl;
+
+import com.punchsettle.server.atomic.entity.PiMultiTaskRela;
+import com.punchsettle.server.atomic.mapper.PiMultiTaskRelaMapper;
+import com.punchsettle.server.atomic.service.IPiMultiTaskRelaService;
+import com.punchsettle.server.utiis.WeekendUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import tk.mybatis.mapper.weekend.Weekend;
+import tk.mybatis.mapper.weekend.WeekendCriteria;
+
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:51
+ * @description 打卡多任务关联表 service
+ */
+@Service
+public class PiMultiTaskRelaServiceImpl implements IPiMultiTaskRelaService {
+
+    @Autowired
+    private PiMultiTaskRelaMapper piMultiTaskRelaMapper;
+
+    @Override
+    public List<PiMultiTaskRela> queryByMultiTaskId(Collection<Long> multiTaskIds) {
+        if (!CollectionUtils.isEmpty(multiTaskIds)) {
+            return List.of();
+        }
+        Weekend<PiMultiTaskRela> weekend = WeekendUtils.createExcludeAuditFields(PiMultiTaskRela.class);
+        WeekendCriteria<PiMultiTaskRela, Object> criteria = weekend.weekendCriteria();
+        if (!CollectionUtils.isEmpty(multiTaskIds)) {
+            criteria.andIn(PiMultiTaskRela::getPunchInMultiTaskId, multiTaskIds);
+        }
+        return piMultiTaskRelaMapper.selectByExample(weekend);
+    }
+}

src/main/java/com/punchsettle/server/atomic/service/impl/PiMultiTaskServiceImpl.java

@@ -0,0 +1,44 @@
+package com.punchsettle.server.atomic.service.impl;
+
+import com.punchsettle.server.atomic.entity.PiMultiTask;
+import com.punchsettle.server.atomic.mapper.PiMultiTaskMapper;
+import com.punchsettle.server.atomic.service.IPiMultiTaskService;
+import com.punchsettle.server.common.utils.Assert;
+import com.punchsettle.server.pojo.punchIn.PiMultiTaskQuery;
+import com.punchsettle.server.utiis.WeekendUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import tk.mybatis.mapper.weekend.Weekend;
+import tk.mybatis.mapper.weekend.WeekendCriteria;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:52
+ * @description 打卡多任务表 service
+ */
+@Service
+public class PiMultiTaskServiceImpl implements IPiMultiTaskService {
+
+    @Autowired
+    private PiMultiTaskMapper piMultiTaskMapper;
+
+    @Override
+    public List<PiMultiTask> queryByCondition(PiMultiTaskQuery piMultiTaskQuery) {
+        Assert.isNull(piMultiTaskQuery);
+
+        Weekend<PiMultiTask> weekend = WeekendUtils.createExcludeAuditFields(PiMultiTask.class);
+        WeekendCriteria<PiMultiTask, Object> criteria = weekend.weekendCriteria();
+        if (!CollectionUtils.isEmpty(piMultiTaskQuery.getUserIds())) {
+            criteria.andIn(PiMultiTask::getUserId, piMultiTaskQuery.getUserIds());
+        }
+        if (Objects.nonNull(piMultiTaskQuery.getMultiTaskTaskStatus())) {
+            criteria.andEqualTo(PiMultiTask::getTaskStatus, piMultiTaskQuery.getMultiTaskTaskStatus());
+        }
+        return piMultiTaskMapper.selectByExample(weekend);
+    }
+}

src/main/java/com/punchsettle/server/atomic/service/impl/PunchInStatusHistoryServiceImpl.java → src/main/java/com/punchsettle/server/atomic/service/impl/PiStatusHistoryServiceImpl.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.service.impl;
 
-import com.punchsettle.server.atomic.service.IPunchInStatusHistoryService;
+import com.punchsettle.server.atomic.service.IPiStatusHistoryService;
 import org.springframework.stereotype.Service;
 
 /**
@@ -10,5 +10,5 @@ import org.springframework.stereotype.Service;
  * @description 打卡任务状态记录表 service
  */
 @Service
-public class PunchInStatusHistoryServiceImpl implements IPunchInStatusHistoryService {
+public class PiStatusHistoryServiceImpl implements IPiStatusHistoryService {
 }

src/main/java/com/punchsettle/server/atomic/service/impl/PiStatusServiceImpl.java

@@ -0,0 +1,43 @@
+package com.punchsettle.server.atomic.service.impl;
+
+import com.punchsettle.server.atomic.entity.PiStatus;
+import com.punchsettle.server.atomic.mapper.PiStatusMapper;
+import com.punchsettle.server.atomic.service.IPiStatusService;
+import com.punchsettle.server.common.utils.Assert;
+import com.punchsettle.server.pojo.punchIn.PiStatusQuery;
+import com.punchsettle.server.utiis.WeekendUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import tk.mybatis.mapper.weekend.Weekend;
+import tk.mybatis.mapper.weekend.WeekendCriteria;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:53
+ * @description 打卡任务状态表 service
+ */
+@Service
+public class PiStatusServiceImpl implements IPiStatusService {
+
+    @Autowired
+    private PiStatusMapper piStatusMapper;
+
+    @Override
+    public List<PiStatus> queryByCondition(PiStatusQuery piStatusQuery) {
+        Assert.isNull(piStatusQuery);
+
+        Weekend<PiStatus> weekend = WeekendUtils.createExcludeAuditFields(PiStatus.class);
+        WeekendCriteria<PiStatus, Object> criteria = weekend.weekendCriteria();
+        if (!CollectionUtils.isEmpty(piStatusQuery.getTaskUniqueIds())) {
+            criteria.andIn(PiStatus::getPunchInTaskUniqueId, piStatusQuery.getTaskUniqueIds());
+        }
+        if (!CollectionUtils.isEmpty(piStatusQuery.getUserIds())) {
+            criteria.andIn(PiStatus::getUserId, piStatusQuery.getUserIds());
+        }
+        return piStatusMapper.selectByExample(weekend);
+    }
+}

src/main/java/com/punchsettle/server/atomic/service/impl/PiTaskExtServiceImpl.java

@@ -0,0 +1,40 @@
+package com.punchsettle.server.atomic.service.impl;
+
+import com.punchsettle.server.atomic.entity.PiTaskExt;
+import com.punchsettle.server.atomic.mapper.PiTaskExtMapper;
+import com.punchsettle.server.atomic.service.IPiTaskExtService;
+import com.punchsettle.server.common.utils.Assert;
+import com.punchsettle.server.pojo.punchIn.PiTaskExtQuery;
+import com.punchsettle.server.utiis.WeekendUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import tk.mybatis.mapper.weekend.Weekend;
+import tk.mybatis.mapper.weekend.WeekendCriteria;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:54
+ * @description 打卡任务拓展表 service
+ */
+@Service
+public class PiTaskExtServiceImpl implements IPiTaskExtService {
+
+    @Autowired
+    private PiTaskExtMapper piTaskExtMapper;
+
+    @Override
+    public List<PiTaskExt> queryByCondition(PiTaskExtQuery piTaskExtQuery) {
+        Assert.isNull(piTaskExtQuery);
+
+        Weekend<PiTaskExt> weekend = WeekendUtils.createExcludeAuditFields(PiTaskExt.class);
+        WeekendCriteria<PiTaskExt, Object> criteria = weekend.weekendCriteria();
+        if (!CollectionUtils.isEmpty(piTaskExtQuery.getPunchInTaskIds())) {
+            criteria.andIn(PiTaskExt::getPunchInTaskId, piTaskExtQuery.getPunchInTaskIds());
+        }
+        return piTaskExtMapper.selectByExample(weekend);
+    }
+}

src/main/java/com/punchsettle/server/atomic/service/impl/PiTaskHistoryServiceImpl.java

@@ -0,0 +1,50 @@
+package com.punchsettle.server.atomic.service.impl;
+
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
+import com.punchsettle.server.atomic.mapper.PiTaskHistoryMapper;
+import com.punchsettle.server.atomic.service.IPiTaskHistoryService;
+import com.punchsettle.server.common.utils.Assert;
+import com.punchsettle.server.pojo.punchIn.PiTaskHistoryQuery;
+import com.punchsettle.server.utiis.WeekendUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.StringUtils;
+import tk.mybatis.mapper.weekend.Weekend;
+import tk.mybatis.mapper.weekend.WeekendCriteria;
+
+import java.util.List;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:54
+ * @description 打卡任务记录表 service
+ */
+@Service
+public class PiTaskHistoryServiceImpl implements IPiTaskHistoryService {
+
+    @Autowired
+    private PiTaskHistoryMapper piTaskHistoryMapper;
+
+    @Override
+    public List<PiTaskHistory> queryByCondition(PiTaskHistoryQuery piTaskHistoryQuery) {
+        Assert.isNull(piTaskHistoryQuery);
+
+        Weekend<PiTaskHistory> weekend = WeekendUtils.createExcludeAuditFields(PiTaskHistory.class);
+        WeekendCriteria<PiTaskHistory, Object> criteria = weekend.weekendCriteria();
+        if (!CollectionUtils.isEmpty(piTaskHistoryQuery.getUserIds())) {
+            criteria.andIn(PiTaskHistory::getUserId, piTaskHistoryQuery.getUserIds());
+        }
+        if (StringUtils.hasText(piTaskHistoryQuery.getPunchInDate())) {
+            criteria.andEqualTo(PiTaskHistory::getPunchInDate, piTaskHistoryQuery.getPunchInDate());
+        }
+        return piTaskHistoryMapper.selectByExample(weekend);
+    }
+
+    @Override
+    public void batchUpdate(List<PiTaskHistory> punchInTaskHistories) {
+        Assert.notEmpty(punchInTaskHistories);
+        piTaskHistoryMapper.batchUpdateSelective(punchInTaskHistories);
+    }
+}

src/main/java/com/punchsettle/server/atomic/service/impl/PiTaskServiceImpl.java

@@ -0,0 +1,44 @@
+package com.punchsettle.server.atomic.service.impl;
+
+import com.punchsettle.server.atomic.entity.PiTask;
+import com.punchsettle.server.atomic.mapper.PiTaskMapper;
+import com.punchsettle.server.atomic.service.IPiTaskService;
+import com.punchsettle.server.common.utils.Assert;
+import com.punchsettle.server.pojo.punchIn.PiTaskQuery;
+import com.punchsettle.server.utiis.WeekendUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import tk.mybatis.mapper.weekend.Weekend;
+import tk.mybatis.mapper.weekend.WeekendCriteria;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:54
+ * @description 打卡任务表 service
+ */
+@Service
+public class PiTaskServiceImpl implements IPiTaskService {
+
+    @Autowired
+    private PiTaskMapper piTaskMapper;
+
+    @Override
+    public List<PiTask> queryByCondition(PiTaskQuery piTaskQuery) {
+        Assert.isNull(piTaskQuery);
+
+        Weekend<PiTask> weekend = WeekendUtils.createExcludeAuditFields(PiTask.class);
+        WeekendCriteria<PiTask, Object> criteria = weekend.weekendCriteria();
+        if (!CollectionUtils.isEmpty(piTaskQuery.getTaskUniqueIds())) {
+            criteria.andIn(PiTask::getUniqueId, piTaskQuery.getTaskUniqueIds());
+        }
+        if (Objects.nonNull(piTaskQuery.getTaskStatus())) {
+            criteria.andEqualTo(PiTask::getTaskStatus, piTaskQuery.getTaskStatus());
+        }
+        return piTaskMapper.selectByExample(weekend);
+    }
+}

src/main/java/com/punchsettle/server/atomic/service/impl/PunchInMultiTaskExtServiceImpl.java

@@ -1,40 +0,0 @@
-package com.punchsettle.server.atomic.service.impl;
-
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskExt;
-import com.punchsettle.server.atomic.mapper.PunchInMultiTaskExtMapper;
-import com.punchsettle.server.atomic.service.IPunchInMultiTaskExtService;
-import com.punchsettle.server.common.utils.Assert;
-import com.punchsettle.server.pojo.punchIn.PunchInMultiTaskExtQuery;
-import com.punchsettle.server.utiis.WeekendUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-import tk.mybatis.mapper.weekend.Weekend;
-import tk.mybatis.mapper.weekend.WeekendCriteria;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:51
- * @description 打卡多任务拓展表 service
- */
-@Service
-public class PunchInMultiTaskExtServiceImpl implements IPunchInMultiTaskExtService {
-
-    @Autowired
-    private PunchInMultiTaskExtMapper punchInMultiTaskExtMapper;
-
-    @Override
-    public List<PunchInMultiTaskExt> queryByCondition(PunchInMultiTaskExtQuery punchInMultiTaskExtQuery) {
-        Assert.isNull(punchInMultiTaskExtQuery);
-
-        Weekend<PunchInMultiTaskExt> weekend = WeekendUtils.createExcludeAuditFields(PunchInMultiTaskExt.class);
-        WeekendCriteria<PunchInMultiTaskExt, Object> criteria = weekend.weekendCriteria();
-        if (!CollectionUtils.isEmpty(punchInMultiTaskExtQuery.getMultiTaskIds())) {
-            criteria.andIn(PunchInMultiTaskExt::getMultiTaskId, punchInMultiTaskExtQuery.getMultiTaskIds());
-        }
-        return punchInMultiTaskExtMapper.selectByExample(weekend);
-    }
-}

src/main/java/com/punchsettle/server/atomic/service/impl/PunchInMultiTaskHistoryServiceImpl.java

@@ -1,50 +0,0 @@
-package com.punchsettle.server.atomic.service.impl;
-
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskHistory;
-import com.punchsettle.server.atomic.mapper.PunchInMultiTaskHistoryMapper;
-import com.punchsettle.server.atomic.service.IPunchInMultiTaskHistoryService;
-import com.punchsettle.server.common.utils.Assert;
-import com.punchsettle.server.pojo.punchIn.PunchInMultiTaskHistoryQuery;
-import com.punchsettle.server.utiis.WeekendUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-import org.springframework.util.StringUtils;
-import tk.mybatis.mapper.weekend.Weekend;
-import tk.mybatis.mapper.weekend.WeekendCriteria;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:51
- * @description 打卡多任务记录表 service
- */
-@Service
-public class PunchInMultiTaskHistoryServiceImpl implements IPunchInMultiTaskHistoryService {
-
-    @Autowired
-    private PunchInMultiTaskHistoryMapper punchInMultiTaskHistoryMapper;
-
-    @Override
-    public List<PunchInMultiTaskHistory> queryByCondition(PunchInMultiTaskHistoryQuery punchInMultiTaskHistoryQuery) {
-        Assert.isNull(punchInMultiTaskHistoryQuery);
-
-        Weekend<PunchInMultiTaskHistory> weekend = WeekendUtils.createExcludeAuditFields(PunchInMultiTaskHistory.class);
-        WeekendCriteria<PunchInMultiTaskHistory, Object> criteria = weekend.weekendCriteria();
-        if (!CollectionUtils.isEmpty(punchInMultiTaskHistoryQuery.getPunchInMultiTaskUniqueIds())) {
-            criteria.andIn(PunchInMultiTaskHistory::getPunchInMultiTaskUniqueId, punchInMultiTaskHistoryQuery.getPunchInMultiTaskUniqueIds());
-        }
-        if (StringUtils.hasText(punchInMultiTaskHistoryQuery.getPunchInDate())) {
-            criteria.andEqualTo(PunchInMultiTaskHistory::getPunchInDate, punchInMultiTaskHistoryQuery.getPunchInDate());
-        }
-        return punchInMultiTaskHistoryMapper.selectByExample(weekend);
-    }
-
-    @Override
-    public void batchUpdate(List<PunchInMultiTaskHistory> punchInMultiTaskHistoryList) {
-        Assert.notEmpty(punchInMultiTaskHistoryList);
-        punchInMultiTaskHistoryMapper.batchUpdateSelective(punchInMultiTaskHistoryList);
-    }
-}

src/main/java/com/punchsettle/server/atomic/service/impl/PunchInMultiTaskRelaServiceImpl.java

@@ -1,40 +0,0 @@
-package com.punchsettle.server.atomic.service.impl;
-
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskRela;
-import com.punchsettle.server.atomic.mapper.PunchInMultiTaskRelaMapper;
-import com.punchsettle.server.atomic.service.IPunchInMultiTaskRelaService;
-import com.punchsettle.server.utiis.WeekendUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-import tk.mybatis.mapper.weekend.Weekend;
-import tk.mybatis.mapper.weekend.WeekendCriteria;
-
-import java.util.Collection;
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:51
- * @description 打卡多任务关联表 service
- */
-@Service
-public class PunchInMultiTaskRelaServiceImpl implements IPunchInMultiTaskRelaService {
-
-    @Autowired
-    private PunchInMultiTaskRelaMapper punchInMultiTaskRelaMapper;
-
-    @Override
-    public List<PunchInMultiTaskRela> queryByMultiTaskId(Collection<Long> multiTaskIds) {
-        if (!CollectionUtils.isEmpty(multiTaskIds)) {
-            return List.of();
-        }
-        Weekend<PunchInMultiTaskRela> weekend = WeekendUtils.createExcludeAuditFields(PunchInMultiTaskRela.class);
-        WeekendCriteria<PunchInMultiTaskRela, Object> criteria = weekend.weekendCriteria();
-        if (!CollectionUtils.isEmpty(multiTaskIds)) {
-            criteria.andIn(PunchInMultiTaskRela::getPunchInMultiTaskId, multiTaskIds);
-        }
-        return punchInMultiTaskRelaMapper.selectByExample(weekend);
-    }
-}

src/main/java/com/punchsettle/server/atomic/service/impl/PunchInMultiTaskServiceImpl.java

@@ -1,44 +0,0 @@
-package com.punchsettle.server.atomic.service.impl;
-
-import com.punchsettle.server.atomic.entity.PunchInMultiTask;
-import com.punchsettle.server.atomic.mapper.PunchInMultiTaskMapper;
-import com.punchsettle.server.atomic.service.IPunchInMultiTaskService;
-import com.punchsettle.server.common.utils.Assert;
-import com.punchsettle.server.pojo.punchIn.PunchInMultiTaskQuery;
-import com.punchsettle.server.utiis.WeekendUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-import tk.mybatis.mapper.weekend.Weekend;
-import tk.mybatis.mapper.weekend.WeekendCriteria;
-
-import java.util.List;
-import java.util.Objects;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:52
- * @description 打卡多任务表 service
- */
-@Service
-public class PunchInMultiTaskServiceImpl implements IPunchInMultiTaskService {
-
-    @Autowired
-    private PunchInMultiTaskMapper punchInMultiTaskMapper;
-
-    @Override
-    public List<PunchInMultiTask> queryByCondition(PunchInMultiTaskQuery punchInMultiTaskQuery) {
-        Assert.isNull(punchInMultiTaskQuery);
-
-        Weekend<PunchInMultiTask> weekend = WeekendUtils.createExcludeAuditFields(PunchInMultiTask.class);
-        WeekendCriteria<PunchInMultiTask, Object> criteria = weekend.weekendCriteria();
-        if (!CollectionUtils.isEmpty(punchInMultiTaskQuery.getUserIds())) {
-            criteria.andIn(PunchInMultiTask::getUserId, punchInMultiTaskQuery.getUserIds());
-        }
-        if (Objects.nonNull(punchInMultiTaskQuery.getMultiTaskTaskStatus())) {
-            criteria.andEqualTo(PunchInMultiTask::getMultiTaskStatus, punchInMultiTaskQuery.getMultiTaskTaskStatus());
-        }
-        return punchInMultiTaskMapper.selectByExample(weekend);
-    }
-}

src/main/java/com/punchsettle/server/atomic/service/impl/PunchInStatsMonthServiceImpl.java

@@ -1,44 +0,0 @@
-package com.punchsettle.server.atomic.service.impl;
-
-import com.punchsettle.server.atomic.entity.PunchInStatsMonth;
-import com.punchsettle.server.atomic.mapper.PunchInStatsMonthMapper;
-import com.punchsettle.server.atomic.service.IPunchInStatsMonthService;
-import com.punchsettle.server.common.utils.Assert;
-import com.punchsettle.server.pojo.punchIn.PunchInStatsMonthQuery;
-import com.punchsettle.server.utiis.WeekendUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-import tk.mybatis.mapper.weekend.Weekend;
-import tk.mybatis.mapper.weekend.WeekendCriteria;
-
-import java.util.List;
-import java.util.Objects;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:52
- * @description 打卡任务月数据统计 service
- */
-@Service
-public class PunchInStatsMonthServiceImpl implements IPunchInStatsMonthService {
-
-    @Autowired
-    private PunchInStatsMonthMapper punchInStatsMonthMapper;
-
-    @Override
-    public List<PunchInStatsMonth> queryByCondition(PunchInStatsMonthQuery punchInStatsMonthQuery) {
-        Assert.isNull(punchInStatsMonthQuery);
-
-        Weekend<PunchInStatsMonth> weekend = WeekendUtils.createExcludeAuditFields(PunchInStatsMonth.class);
-        WeekendCriteria<PunchInStatsMonth, Object> criteria = weekend.weekendCriteria();
-        if (!CollectionUtils.isEmpty(punchInStatsMonthQuery.getTaskUniqueIds())) {
-            criteria.andIn(PunchInStatsMonth::getTaskUniqueId, punchInStatsMonthQuery.getTaskUniqueIds());
-        }
-        if (Objects.nonNull(punchInStatsMonthQuery.getStatsTime())) {
-            criteria.andEqualTo(PunchInStatsMonth::getStatsTime, punchInStatsMonthQuery.getStatsTime());
-        }
-        return punchInStatsMonthMapper.selectByExample(weekend);
-    }
-}

src/main/java/com/punchsettle/server/atomic/service/impl/PunchInStatusServiceImpl.java

@@ -1,43 +0,0 @@
-package com.punchsettle.server.atomic.service.impl;
-
-import com.punchsettle.server.atomic.entity.PunchInStatus;
-import com.punchsettle.server.atomic.mapper.PunchInStatusMapper;
-import com.punchsettle.server.atomic.service.IPunchInStatusService;
-import com.punchsettle.server.common.utils.Assert;
-import com.punchsettle.server.pojo.punchIn.PunchInStatusQuery;
-import com.punchsettle.server.utiis.WeekendUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-import tk.mybatis.mapper.weekend.Weekend;
-import tk.mybatis.mapper.weekend.WeekendCriteria;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:53
- * @description 打卡任务状态表 service
- */
-@Service
-public class PunchInStatusServiceImpl implements IPunchInStatusService {
-
-    @Autowired
-    private PunchInStatusMapper punchInStatusMapper;
-
-    @Override
-    public List<PunchInStatus> queryByCondition(PunchInStatusQuery punchInStatusQuery) {
-        Assert.isNull(punchInStatusQuery);
-
-        Weekend<PunchInStatus> weekend = WeekendUtils.createExcludeAuditFields(PunchInStatus.class);
-        WeekendCriteria<PunchInStatus, Object> criteria = weekend.weekendCriteria();
-        if (!CollectionUtils.isEmpty(punchInStatusQuery.getTaskUniqueIds())) {
-            criteria.andIn(PunchInStatus::getPunchInTaskUniqueId, punchInStatusQuery.getTaskUniqueIds());
-        }
-        if (!CollectionUtils.isEmpty(punchInStatusQuery.getUserIds())) {
-            criteria.andIn(PunchInStatus::getUserId, punchInStatusQuery.getUserIds());
-        }
-        return punchInStatusMapper.selectByExample(weekend);
-    }
-}

src/main/java/com/punchsettle/server/atomic/service/impl/PunchInTaskExtServiceImpl.java

@@ -1,40 +0,0 @@
-package com.punchsettle.server.atomic.service.impl;
-
-import com.punchsettle.server.atomic.entity.PunchInTaskExt;
-import com.punchsettle.server.atomic.mapper.PunchInTaskExtMapper;
-import com.punchsettle.server.atomic.service.IPunchInTaskExtService;
-import com.punchsettle.server.common.utils.Assert;
-import com.punchsettle.server.pojo.punchIn.PunchInTaskExtQuery;
-import com.punchsettle.server.utiis.WeekendUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-import tk.mybatis.mapper.weekend.Weekend;
-import tk.mybatis.mapper.weekend.WeekendCriteria;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:54
- * @description 打卡任务拓展表 service
- */
-@Service
-public class PunchInTaskExtServiceImpl implements IPunchInTaskExtService {
-
-    @Autowired
-    private PunchInTaskExtMapper punchInTaskExtMapper;
-
-    @Override
-    public List<PunchInTaskExt> queryByCondition(PunchInTaskExtQuery punchInTaskExtQuery) {
-        Assert.isNull(punchInTaskExtQuery);
-
-        Weekend<PunchInTaskExt> weekend = WeekendUtils.createExcludeAuditFields(PunchInTaskExt.class);
-        WeekendCriteria<PunchInTaskExt, Object> criteria = weekend.weekendCriteria();
-        if (!CollectionUtils.isEmpty(punchInTaskExtQuery.getPunchInTaskIds())) {
-            criteria.andIn(PunchInTaskExt::getPunchInTaskId, punchInTaskExtQuery.getPunchInTaskIds());
-        }
-        return punchInTaskExtMapper.selectByExample(weekend);
-    }
-}

src/main/java/com/punchsettle/server/atomic/service/impl/PunchInTaskHistoryServiceImpl.java

@@ -1,50 +0,0 @@
-package com.punchsettle.server.atomic.service.impl;
-
-import com.punchsettle.server.atomic.entity.PunchInTaskHistory;
-import com.punchsettle.server.atomic.mapper.PunchInTaskHistoryMapper;
-import com.punchsettle.server.atomic.service.IPunchInTaskHistoryService;
-import com.punchsettle.server.common.utils.Assert;
-import com.punchsettle.server.pojo.punchIn.PunchInTaskHistoryQuery;
-import com.punchsettle.server.utiis.WeekendUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-import org.springframework.util.StringUtils;
-import tk.mybatis.mapper.weekend.Weekend;
-import tk.mybatis.mapper.weekend.WeekendCriteria;
-
-import java.util.List;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:54
- * @description 打卡任务记录表 service
- */
-@Service
-public class PunchInTaskHistoryServiceImpl implements IPunchInTaskHistoryService {
-
-    @Autowired
-    private PunchInTaskHistoryMapper punchInTaskHistoryMapper;
-
-    @Override
-    public List<PunchInTaskHistory> queryByCondition(PunchInTaskHistoryQuery punchInTaskHistoryQuery) {
-        Assert.isNull(punchInTaskHistoryQuery);
-
-        Weekend<PunchInTaskHistory> weekend = WeekendUtils.createExcludeAuditFields(PunchInTaskHistory.class);
-        WeekendCriteria<PunchInTaskHistory, Object> criteria = weekend.weekendCriteria();
-        if (!CollectionUtils.isEmpty(punchInTaskHistoryQuery.getUserIds())) {
-            criteria.andIn(PunchInTaskHistory::getUserId, punchInTaskHistoryQuery.getUserIds());
-        }
-        if (StringUtils.hasText(punchInTaskHistoryQuery.getPunchInDate())) {
-            criteria.andEqualTo(PunchInTaskHistory::getPunchInDate, punchInTaskHistoryQuery.getPunchInDate());
-        }
-        return punchInTaskHistoryMapper.selectByExample(weekend);
-    }
-
-    @Override
-    public void batchUpdate(List<PunchInTaskHistory> punchInTaskHistories) {
-        Assert.notEmpty(punchInTaskHistories);
-        punchInTaskHistoryMapper.batchUpdateSelective(punchInTaskHistories);
-    }
-}

src/main/java/com/punchsettle/server/atomic/service/impl/PunchInTaskServiceImpl.java

@@ -1,45 +0,0 @@
-package com.punchsettle.server.atomic.service.impl;
-
-import com.punchsettle.server.atomic.entity.PunchInTask;
-import com.punchsettle.server.atomic.mapper.PunchInTaskMapper;
-import com.punchsettle.server.atomic.service.IPunchInTaskService;
-import com.punchsettle.server.common.utils.Assert;
-import com.punchsettle.server.constant.ArchiveStatusEnum;
-import com.punchsettle.server.pojo.punchIn.PunchInTaskQuery;
-import com.punchsettle.server.utiis.WeekendUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-import tk.mybatis.mapper.weekend.Weekend;
-import tk.mybatis.mapper.weekend.WeekendCriteria;
-
-import java.util.List;
-import java.util.Objects;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/8 10:54
- * @description 打卡任务表 service
- */
-@Service
-public class PunchInTaskServiceImpl implements IPunchInTaskService {
-
-    @Autowired
-    private PunchInTaskMapper punchInTaskMapper;
-
-    @Override
-    public List<PunchInTask> queryByCondition(PunchInTaskQuery punchInTaskQuery) {
-        Assert.isNull(punchInTaskQuery);
-
-        Weekend<PunchInTask> weekend = WeekendUtils.createExcludeAuditFields(PunchInTask.class);
-        WeekendCriteria<PunchInTask, Object> criteria = weekend.weekendCriteria();
-        if (!CollectionUtils.isEmpty(punchInTaskQuery.getTaskUniqueIds())) {
-            criteria.andIn(PunchInTask::getTaskUniqueId, punchInTaskQuery.getTaskUniqueIds());
-        }
-        if (Objects.nonNull(punchInTaskQuery.getTaskStatus())) {
-            criteria.andEqualTo(PunchInTask::getTaskStatus, punchInTaskQuery.getTaskStatus());
-        }
-        return punchInTaskMapper.selectByExample(weekend);
-    }
-}

src/main/java/com/punchsettle/server/atomic/service/impl/NewUserStatsServiceImpl.java → src/main/java/com/punchsettle/server/atomic/service/impl/StatNewUserServiceImpl.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.service.impl;
 
-import com.punchsettle.server.atomic.service.INewUserStatsService;
+import com.punchsettle.server.atomic.service.IStatNewUserService;
 import org.springframework.stereotype.Service;
 
 /**
@@ -10,5 +10,5 @@ import org.springframework.stereotype.Service;
  * @description 新用户数据统计 service
  */
 @Service
-public class NewUserStatsServiceImpl implements INewUserStatsService {
+public class StatNewUserServiceImpl implements IStatNewUserService {
 }

src/main/java/com/punchsettle/server/atomic/service/impl/StatPiTaskMonthServiceImpl.java

@@ -0,0 +1,44 @@
+package com.punchsettle.server.atomic.service.impl;
+
+import com.punchsettle.server.atomic.entity.StatPiTaskMonth;
+import com.punchsettle.server.atomic.mapper.StatPiTaskMonthMapper;
+import com.punchsettle.server.atomic.service.IStatPiTaskMonthService;
+import com.punchsettle.server.common.utils.Assert;
+import com.punchsettle.server.pojo.punchIn.PiStatsMonthQuery;
+import com.punchsettle.server.utiis.WeekendUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import tk.mybatis.mapper.weekend.Weekend;
+import tk.mybatis.mapper.weekend.WeekendCriteria;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/8 10:52
+ * @description 打卡任务月数据统计 service
+ */
+@Service
+public class StatPiTaskMonthServiceImpl implements IStatPiTaskMonthService {
+
+    @Autowired
+    private StatPiTaskMonthMapper statPiTaskMonthMapper;
+
+    @Override
+    public List<StatPiTaskMonth> queryByCondition(PiStatsMonthQuery piStatsMonthQuery) {
+        Assert.isNull(piStatsMonthQuery);
+
+        Weekend<StatPiTaskMonth> weekend = WeekendUtils.createExcludeAuditFields(StatPiTaskMonth.class);
+        WeekendCriteria<StatPiTaskMonth, Object> criteria = weekend.weekendCriteria();
+        if (!CollectionUtils.isEmpty(piStatsMonthQuery.getTaskUniqueIds())) {
+            criteria.andIn(StatPiTaskMonth::getTaskUniqueId, piStatsMonthQuery.getTaskUniqueIds());
+        }
+        if (Objects.nonNull(piStatsMonthQuery.getStatsTime())) {
+            criteria.andEqualTo(StatPiTaskMonth::getStatTime, piStatsMonthQuery.getStatsTime());
+        }
+        return statPiTaskMonthMapper.selectByExample(weekend);
+    }
+}

src/main/java/com/punchsettle/server/atomic/service/impl/PunchInStatsYearServiceImpl.java → src/main/java/com/punchsettle/server/atomic/service/impl/StatPiTaskYearServiceImpl.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.service.impl;
 
-import com.punchsettle.server.atomic.service.IPunchInStatsYearService;
+import com.punchsettle.server.atomic.service.IStatPiTaskYearService;
 import org.springframework.stereotype.Service;
 
 /**
@@ -10,5 +10,5 @@ import org.springframework.stereotype.Service;
  * @description 打卡任务年数据统计 service
  */
 @Service
-public class PunchInStatsYearServiceImpl implements IPunchInStatsYearService {
+public class StatPiTaskYearServiceImpl implements IStatPiTaskYearService {
 }

src/main/java/com/punchsettle/server/atomic/service/impl/PointsStatsServiceImpl.java → src/main/java/com/punchsettle/server/atomic/service/impl/StatPointsServiceImpl.java

@@ -1,6 +1,6 @@
 package com.punchsettle.server.atomic.service.impl;
 
-import com.punchsettle.server.atomic.service.IPointsStatsService;
+import com.punchsettle.server.atomic.service.IStatPointsService;
 import org.springframework.stereotype.Service;
 
 /**
@@ -10,5 +10,5 @@ import org.springframework.stereotype.Service;
  * @description 积分数据统计 service
  */
 @Service
-public class PointsStatsServiceImpl implements IPointsStatsService {
+public class StatPointsServiceImpl implements IStatPointsService {
 }

src/main/java/com/punchsettle/server/constant/SettleStatusEnum.java

@@ -7,7 +7,7 @@ import lombok.Getter;
  * @author tyuio
  * @version 1.0.0
  * @date 2025/4/9 12:26
- * @description 结算状态枚举(未结算-UNSETTLED，宽限期跳过J-GRACE_SKIP，惩罚跳过-PENALTY_SKIP，已结算-SETTLED)
+ * @description 结算状态枚举(未结算-UNSETTLED，宽限期跳过J-GRACE_SKIP，惩罚跳过-PENALTY_SKIP，未完成打卡跳过-UNDONE_SKIP，已结算-SETTLED)
  */
 @Getter
 @AllArgsConstructor
@@ -16,6 +16,7 @@ public enum SettleStatusEnum {
     UNSETTLED("未结算"),
     GRACE_SKIP("宽限期跳过"),
     PENALTY_SKIP("惩罚跳过"),
+    UNDONE_SKIP("未完成打卡跳过"),
     SETTLED("已结算");
 
     /**

src/main/java/com/punchsettle/server/pojo/punchIn/PunchInMultiTaskExtQuery.java → src/main/java/com/punchsettle/server/pojo/punchIn/PiMultiTaskExtQuery.java

@@ -11,7 +11,7 @@ import java.util.Collection;
  * @description 打卡多任务拓展 查询类
  */
 @Data
-public class PunchInMultiTaskExtQuery {
+public class PiMultiTaskExtQuery {
 
     /**
      * 多任务id

src/main/java/com/punchsettle/server/pojo/punchIn/PunchInMultiTaskHistoryQuery.java → src/main/java/com/punchsettle/server/pojo/punchIn/PiMultiTaskHistoryQuery.java

@@ -11,7 +11,7 @@ import java.util.Collection;
  * @description 打卡多任务记录表 查询类
  */
 @Data
-public class PunchInMultiTaskHistoryQuery {
+public class PiMultiTaskHistoryQuery {
 
     /**
      * 打卡多任务记录表唯一id

src/main/java/com/punchsettle/server/pojo/punchIn/PunchInMultiTaskQuery.java → src/main/java/com/punchsettle/server/pojo/punchIn/PiMultiTaskQuery.java

@@ -12,7 +12,7 @@ import java.util.Collection;
  * @description 打卡多任务 查询类
  */
 @Data
-public class PunchInMultiTaskQuery {
+public class PiMultiTaskQuery {
 
     /**
      * 用户id列表

src/main/java/com/punchsettle/server/pojo/punchIn/PunchInStatsMonthQuery.java → src/main/java/com/punchsettle/server/pojo/punchIn/PiStatsMonthQuery.java

@@ -11,7 +11,7 @@ import lombok.Data;
  * @description 打卡任务月数据统计 查询类
  */
 @Data
-public class PunchInStatsMonthQuery {
+public class PiStatsMonthQuery {
 
     /**
      * 打卡任务唯一id集合

src/main/java/com/punchsettle/server/pojo/punchIn/PunchInStatusQuery.java → src/main/java/com/punchsettle/server/pojo/punchIn/PiStatusQuery.java

@@ -11,7 +11,7 @@ import lombok.Data;
  * @description 打卡任务状态 查询类
  */
 @Data
-public class PunchInStatusQuery {
+public class PiStatusQuery {
 
     /**
      * 打卡任务唯一id集合

src/main/java/com/punchsettle/server/pojo/punchIn/PiTaskDto.java

@@ -0,0 +1,52 @@
+package com.punchsettle.server.pojo.punchIn;
+
+import java.util.List;
+
+import com.punchsettle.server.atomic.entity.StatPiTaskMonth;
+import com.punchsettle.server.atomic.entity.StatPiTaskWeek;
+import com.punchsettle.server.atomic.entity.PiStatus;
+import com.punchsettle.server.atomic.entity.PiTask;
+import com.punchsettle.server.atomic.entity.PiTaskExt;
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
+
+import lombok.Data;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/16 10:17
+ * @description 打卡结算 DTO
+ */
+@Data
+public class PiTaskDto {
+
+    /**
+     * 打卡任务
+     */
+    private PiTask piTask;
+
+    /**
+     * 打卡任务拓展信息
+     */
+    private List<PiTaskExt> piTaskExtList;
+
+    /**
+     * 打卡记录
+     */
+    private PiTaskHistory piTaskHistory;
+
+    /**
+     * 打卡周数据据统计
+     */
+    private StatPiTaskWeek statPiTaskWeek;
+
+    /**
+     * 打卡月数据据统计
+     */
+    private StatPiTaskMonth statPiTaskMonth;
+
+    /**
+     * 打卡状态
+     */
+    private PiStatus piStatus;
+}

src/main/java/com/punchsettle/server/pojo/punchIn/PunchInTaskExtQuery.java → src/main/java/com/punchsettle/server/pojo/punchIn/PiTaskExtQuery.java

@@ -11,7 +11,7 @@ import java.util.Collection;
  * @description 打卡任务拓展 查询类
  */
 @Data
-public class PunchInTaskExtQuery {
+public class PiTaskExtQuery {
 
     /**
      * 打卡任务id

src/main/java/com/punchsettle/server/pojo/punchIn/PunchInTaskHistoryQuery.java → src/main/java/com/punchsettle/server/pojo/punchIn/PiTaskHistoryQuery.java

@@ -3,7 +3,6 @@ package com.punchsettle.server.pojo.punchIn;
 import lombok.Data;
 
 import java.util.Collection;
-import java.util.List;
 
 /**
  * @author tyuio
@@ -12,7 +11,7 @@ import java.util.List;
  * @description 打卡任务记录查询类
  */
 @Data
-public class PunchInTaskHistoryQuery {
+public class PiTaskHistoryQuery {
 
     /**
      * 用户id列表

src/main/java/com/punchsettle/server/pojo/punchIn/PunchInTaskQuery.java → src/main/java/com/punchsettle/server/pojo/punchIn/PiTaskQuery.java

@@ -3,7 +3,6 @@ package com.punchsettle.server.pojo.punchIn;
 import java.util.Collection;
 
 import com.punchsettle.server.constant.ArchiveStatusEnum;
-import jakarta.persistence.Column;
 import lombok.Data;
 
 /**
@@ -13,7 +12,7 @@ import lombok.Data;
  * @description 打卡任务查询类
  */
 @Data
-public class PunchInTaskQuery {
+public class PiTaskQuery {
 
     /**
      * 打卡任务唯一ID列表

src/main/java/com/punchsettle/server/pojo/punchIn/PunchInSettleDto.java

@@ -1,10 +1,10 @@
 package com.punchsettle.server.pojo.punchIn;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTask;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskExt;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskHistory;
-import com.punchsettle.server.atomic.entity.PunchInStatus;
-import com.punchsettle.server.atomic.entity.PunchInTaskHistory;
+import com.punchsettle.server.atomic.entity.PiMultiTask;
+import com.punchsettle.server.atomic.entity.PiMultiTaskExt;
+import com.punchsettle.server.atomic.entity.PiMultiTaskHistory;
+import com.punchsettle.server.atomic.entity.PiStatus;
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
 import lombok.Data;
 
 import java.util.List;
@@ -26,30 +26,30 @@ public class PunchInSettleDto {
     /**
      * 打卡多任务
      */
-    private PunchInMultiTask punchInMultiTask;
+    private PiMultiTask piMultiTask;
 
     /**
      * 打卡多任务拓展信息
      */
-    private List<PunchInMultiTaskExt> punchInMultiTaskExtList;
+    private List<PiMultiTaskExt> piMultiTaskExtList;
 
     /**
      * 多任务打卡记录
      */
-    private PunchInMultiTaskHistory punchInMultiTaskHistory;
+    private PiMultiTaskHistory piMultiTaskHistory;
 
     /**
      * 打卡多任务关联的打卡记录
      */
-    private List<PunchInTaskHistory> relaPunchInTaskHistories;
+    private List<PiTaskHistory> relaPunchInTaskHistories;
 
     /**
      * 打卡多任务状态
      */
-    private PunchInStatus punchInStatusInMultiTask;
+    private PiStatus piStatus;
 
     /**
      * 打卡任务列表
      */
-    private List<PunchInTaskDto> punchInTaskDtoList;
+    private List<PiTaskDto> piTaskDtoList;
 }

src/main/java/com/punchsettle/server/pojo/punchIn/PunchInTaskDto.java

@@ -1,52 +0,0 @@
-package com.punchsettle.server.pojo.punchIn;
-
-import java.util.List;
-
-import com.punchsettle.server.atomic.entity.PunchInStatsMonth;
-import com.punchsettle.server.atomic.entity.PunchInStatsWeek;
-import com.punchsettle.server.atomic.entity.PunchInStatus;
-import com.punchsettle.server.atomic.entity.PunchInTask;
-import com.punchsettle.server.atomic.entity.PunchInTaskExt;
-import com.punchsettle.server.atomic.entity.PunchInTaskHistory;
-
-import lombok.Data;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/16 10:17
- * @description 打卡结算 DTO
- */
-@Data
-public class PunchInTaskDto {
-
-    /**
-     * 打卡任务
-     */
-    private PunchInTask punchInTask;
-
-    /**
-     * 打卡任务拓展信息
-     */
-    private List<PunchInTaskExt> punchInTaskExtList;
-
-    /**
-     * 打卡记录
-     */
-    private PunchInTaskHistory punchInTaskHistory;
-
-    /**
-     * 打卡周数据据统计
-     */
-    private PunchInStatsWeek punchInStatsWeek;
-
-    /**
-     * 打卡月数据据统计
-     */
-    private PunchInStatsMonth punchInStatsMonth;
-
-    /**
-     * 打卡状态
-     */
-    private PunchInStatus punchInStatus;
-}

src/main/java/com/punchsettle/server/pojo/punchIn/PunchInStatsWeekQuery.java → src/main/java/com/punchsettle/server/pojo/punchIn/StatPiTaskWeekQuery.java

@@ -3,7 +3,6 @@ package com.punchsettle.server.pojo.punchIn;
 import lombok.Data;
 
 import java.util.Collection;
-import java.util.List;
 
 /**
  * @author tyuio
@@ -12,7 +11,7 @@ import java.util.List;
  * @description 打卡任务周数据统计 查询类
  */
 @Data
-public class PunchInStatsWeekQuery {
+public class StatPiTaskWeekQuery {
 
     /**
      * 打卡任务唯一id集合

src/main/java/com/punchsettle/server/service/manager/IPunchInManager.java

@@ -1,8 +1,8 @@
 package com.punchsettle.server.service.manager;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTask;
-import com.punchsettle.server.atomic.entity.PunchInTask;
-import com.punchsettle.server.atomic.entity.PunchInTaskHistory;
+import com.punchsettle.server.atomic.entity.PiMultiTask;
+import com.punchsettle.server.atomic.entity.PiTask;
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
 import com.punchsettle.server.constant.PunchInStatusEnum;
 
 import java.util.List;
@@ -17,25 +17,25 @@ public interface IPunchInManager {
 
     /**
      * 判断指定日期是否在打卡任务的重复周期内
-     * @param punchInTask 打卡任务
+     * @param piTask 打卡任务
      * @param repeatDateStr 指定日期
      * @return true-在周期内，false-不在周期内
      */
-    boolean judgeRepeat(PunchInTask punchInTask, String repeatDateStr);
+    boolean judgeRepeat(PiTask piTask, String repeatDateStr);
 
     /**
      * 判断打卡状态
-     * @param punchInTask 当前打卡任务
-     * @param punchInTaskHistory 打卡记录
+     * @param piTask 当前打卡任务
+     * @param piTaskHistory 打卡记录
      * @return
      */
-    PunchInStatusEnum judgePunchInStatusInTask(PunchInTask punchInTask, PunchInTaskHistory punchInTaskHistory);
+    PunchInStatusEnum judgePunchInStatusInTask(PiTask piTask, PiTaskHistory piTaskHistory);
 
     /**
      * 判断打卡状态（多任务）
-     * @param punchInMultiTask 打卡多任务任务
-     * @param punchInTaskHistoryList 打卡记录
+     * @param piMultiTask 打卡多任务任务
+     * @param piTaskHistoryList 打卡记录
      * @return
      */
-    PunchInStatusEnum judgePunchInStatusInMultiTask(PunchInMultiTask punchInMultiTask, List<PunchInTaskHistory> punchInTaskHistoryList);
+    PunchInStatusEnum judgePunchInStatusInMultiTask(PiMultiTask piMultiTask, List<PiTaskHistory> piTaskHistoryList);
 }

src/main/java/com/punchsettle/server/service/manager/IPunchInManagerV1.java

@@ -2,15 +2,15 @@ package com.punchsettle.server.service.manager;
 
 import java.util.List;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTask;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskExt;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskHistory;
-import com.punchsettle.server.atomic.entity.PunchInStatsMonth;
-import com.punchsettle.server.atomic.entity.PunchInStatsWeek;
-import com.punchsettle.server.atomic.entity.PunchInStatus;
-import com.punchsettle.server.atomic.entity.PunchInTask;
-import com.punchsettle.server.atomic.entity.PunchInTaskExt;
-import com.punchsettle.server.atomic.entity.PunchInTaskHistory;
+import com.punchsettle.server.atomic.entity.PiMultiTask;
+import com.punchsettle.server.atomic.entity.PiMultiTaskExt;
+import com.punchsettle.server.atomic.entity.PiMultiTaskHistory;
+import com.punchsettle.server.atomic.entity.StatPiTaskMonth;
+import com.punchsettle.server.atomic.entity.StatPiTaskWeek;
+import com.punchsettle.server.atomic.entity.PiStatus;
+import com.punchsettle.server.atomic.entity.PiTask;
+import com.punchsettle.server.atomic.entity.PiTaskExt;
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
 import com.punchsettle.server.constant.PunchInStatusEnum;
 import com.punchsettle.server.pojo.punchinV1.PunchInDataQuery;
 import com.punchsettle.server.pojo.punchinV1.PunchInDataVO;
@@ -83,46 +83,46 @@ public interface IPunchInManagerV1 {
 
     /**
      * 判断指定日期是否在打卡任务的重复周期内
-     * @param punchInTask 打卡任务
+     * @param piTask 打卡任务
      * @param repeatDateStr 指定日期
      * @return true-在周期内，false-不在周期内
      */
-    boolean judgeRepeat(PunchInTask punchInTask, String repeatDateStr);
+    boolean judgeRepeat(PiTask piTask, String repeatDateStr);
 
     /**
      * 判断打卡状态
-     * @param punchInTask 当前打卡任务
-     * @param punchInTaskHistory 打卡记录
+     * @param piTask 当前打卡任务
+     * @param piTaskHistory 打卡记录
      * @param holidayFlag 是否是节假日（是-true，否-false）
      * @return
      */
-    PunchInStatusEnum judgePunchInStatusInTask(PunchInTask punchInTask, PunchInTaskHistory punchInTaskHistory, boolean holidayFlag);
+    PunchInStatusEnum judgePunchInStatusInTask(PiTask piTask, PiTaskHistory piTaskHistory, boolean holidayFlag);
 
     /**
      * 判断打卡状态（多任务）
-     * @param punchInMultiTask 打卡多任务任务
-     * @param punchInTaskHistoryList 打卡记录
+     * @param piMultiTask 打卡多任务任务
+     * @param piTaskHistoryList 打卡记录
      * @param multiTaskNum 参与多任务计算数量
      * @return
      */
-    PunchInStatusEnum judgePunchInStatusInMultiTask(PunchInMultiTask punchInMultiTask, List<PunchInTaskHistory> punchInTaskHistoryList, int multiTaskNum);
+    PunchInStatusEnum judgePunchInStatusInMultiTask(PiMultiTask piMultiTask, List<PiTaskHistory> piTaskHistoryList, int multiTaskNum);
 
     /**
      * 计算任务积分
-     * @param punchInTask 打卡任务
-     * @param punchInTaskExtList 打卡任务拓展信息列表
-     * @param punchInTaskHistory 打卡记录
+     * @param piTask 打卡任务
+     * @param piTaskExtList 打卡任务拓展信息列表
+     * @param piTaskHistory 打卡记录
      * @return
      */
-    int calculatePointsInTask(PunchInTask punchInTask, List<PunchInTaskExt> punchInTaskExtList, PunchInTaskHistory punchInTaskHistory, PunchInStatsWeek punchInStatsWeek, PunchInStatsMonth punchInStatsMonth, PunchInStatus punchInStatus);
+    int calculatePointsInTask(PiTask piTask, List<PiTaskExt> piTaskExtList, PiTaskHistory piTaskHistory, StatPiTaskWeek statPiTaskWeek, StatPiTaskMonth statPiTaskMonth, PiStatus piStatus);
 
 
     /**
      * 计算多任务积分
-     * @param punchInMultiTask
-     * @param punchInMultiTaskExts
-     * @param punchInMultiTaskHistory
+     * @param piMultiTask
+     * @param piMultiTaskExts
+     * @param piMultiTaskHistory
      * @return
      */
-    int calculatePointsInMultiTask(PunchInMultiTask punchInMultiTask, List<PunchInMultiTaskExt> punchInMultiTaskExts, PunchInMultiTaskHistory punchInMultiTaskHistory, PunchInStatus punchInStatus);
+    int calculatePointsInMultiTask(PiMultiTask piMultiTask, List<PiMultiTaskExt> piMultiTaskExts, PiMultiTaskHistory piMultiTaskHistory, PiStatus piStatus);
 }

src/main/java/com/punchsettle/server/service/manager/ISettleManager.java

@@ -1,14 +1,15 @@
 package com.punchsettle.server.service.manager;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTask;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskExt;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskHistory;
-import com.punchsettle.server.atomic.entity.PunchInStatsMonth;
-import com.punchsettle.server.atomic.entity.PunchInStatsWeek;
-import com.punchsettle.server.atomic.entity.PunchInStatus;
-import com.punchsettle.server.atomic.entity.PunchInTask;
-import com.punchsettle.server.atomic.entity.PunchInTaskExt;
-import com.punchsettle.server.atomic.entity.PunchInTaskHistory;
+import com.punchsettle.server.atomic.entity.PiMultiTask;
+import com.punchsettle.server.atomic.entity.PiMultiTaskExt;
+import com.punchsettle.server.atomic.entity.PiMultiTaskHistory;
+import com.punchsettle.server.atomic.entity.StatPiTaskMonth;
+import com.punchsettle.server.atomic.entity.StatPiTaskWeek;
+import com.punchsettle.server.atomic.entity.PiStatus;
+import com.punchsettle.server.atomic.entity.PiTask;
+import com.punchsettle.server.atomic.entity.PiTaskExt;
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
+import com.punchsettle.server.constant.SettleStatusEnum;
 
 import java.util.List;
 
@@ -20,27 +21,35 @@ import java.util.List;
  */
 public interface ISettleManager {
 
+    /**
+     * 判断打卡任务结算状态
+     * @param piTask 打卡任务
+     * @param piTaskHistory 打卡记录
+     * @param piStatus 打卡状态
+     * @return 结算状态
+     */
+    SettleStatusEnum judgeSettleStatusInTask(PiTask piTask, PiTaskHistory piTaskHistory, PiStatus piStatus);
 
     /**
      * 计算任务积分
-     * @param punchInTask 打卡任务
-     * @param punchInTaskExtList 打卡任务拓展信息列表
-     * @param punchInTaskHistory 打卡记录
-     * @param punchInStatsWeek 打卡周统计
-     * @param punchInStatsMonth 打卡月统计
-     * @param punchInStatus 打卡统计
+     * @param piTask 打卡任务
+     * @param piTaskExtList 打卡任务拓展信息列表
+     * @param piTaskHistory 打卡记录
+     * @param statPiTaskWeek 打卡周统计
+     * @param statPiTaskMonth 打卡月统计
+     * @param piStatus 打卡统计
      * @return 积分
      */
-    int calculatePointsInTask(PunchInTask punchInTask, List<PunchInTaskExt> punchInTaskExtList, PunchInTaskHistory punchInTaskHistory, PunchInStatsWeek punchInStatsWeek, PunchInStatsMonth punchInStatsMonth, PunchInStatus punchInStatus);
+    int calculatePointsInTask(PiTask piTask, List<PiTaskExt> piTaskExtList, PiTaskHistory piTaskHistory, StatPiTaskWeek statPiTaskWeek, StatPiTaskMonth statPiTaskMonth, PiStatus piStatus);
 
 
     /**
      * 计算多任务积分
-     * @param punchInMultiTask 打卡多任务
-     * @param punchInMultiTaskExts 打卡多任务拓展信息列表
-     * @param punchInMultiTaskHistory 打卡记录
-     * @param punchInStatus 打卡统计
+     * @param piMultiTask 打卡多任务
+     * @param piMultiTaskExts 打卡多任务拓展信息列表
+     * @param piMultiTaskHistory 打卡记录
+     * @param piStatus 打卡统计
      * @return
      */
-    int calculatePointsInMultiTask(PunchInMultiTask punchInMultiTask, List<PunchInMultiTaskExt> punchInMultiTaskExts, PunchInMultiTaskHistory punchInMultiTaskHistory, PunchInStatus punchInStatus);
+    int calculatePointsInMultiTask(PiMultiTask piMultiTask, List<PiMultiTaskExt> piMultiTaskExts, PiMultiTaskHistory piMultiTaskHistory, PiStatus piStatus);
 }

src/main/java/com/punchsettle/server/service/manager/impl/PunchInManagerImpl.java

@@ -11,9 +11,9 @@ import org.springframework.stereotype.Component;
 import org.springframework.util.CollectionUtils;
 import org.springframework.util.StringUtils;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTask;
-import com.punchsettle.server.atomic.entity.PunchInTask;
-import com.punchsettle.server.atomic.entity.PunchInTaskHistory;
+import com.punchsettle.server.atomic.entity.PiMultiTask;
+import com.punchsettle.server.atomic.entity.PiTask;
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
 import com.punchsettle.server.common.constant.CommonEnableStatusEnum;
 import com.punchsettle.server.common.exception.BusinessException;
 import com.punchsettle.server.common.utils.Assert;
@@ -40,76 +40,76 @@ public class PunchInManagerImpl implements IPunchInManager {
     private ICalendarManager calendarManager;
 
     @Override
-    public boolean judgeRepeat(PunchInTask punchInTask, String repeatDateStr) {
+    public boolean judgeRepeat(PiTask piTask, String repeatDateStr) {
         // 每天
-        if (RepeatCategoryEnum.EVERYDAY.equals(punchInTask.getRepeatCategory())) {
+        if (RepeatCategoryEnum.EVERYDAY.equals(piTask.getRepeatCategory())) {
             return true;
         }
 
         // 法定工作日
-        if (RepeatCategoryEnum.WORKDAY.equals(punchInTask.getRepeatCategory())) {
+        if (RepeatCategoryEnum.WORKDAY.equals(piTask.getRepeatCategory())) {
             return !calendarManager.judgeHoliday(repeatDateStr);
         }
 
         // 法定节假日（含周末）
-        if (RepeatCategoryEnum.HOLIDAY.equals(punchInTask.getRepeatCategory())) {
+        if (RepeatCategoryEnum.HOLIDAY.equals(piTask.getRepeatCategory())) {
             return !calendarManager.judgeHoliday(repeatDateStr);
         }
 
         // 自定义
-        if (RepeatCategoryEnum.CUSTOM.equals(punchInTask.getRepeatCategory())) {
-            if (!StringUtils.hasText(punchInTask.getRepeatCustomDay())) {
+        if (RepeatCategoryEnum.CUSTOM.equals(piTask.getRepeatCategory())) {
+            if (!StringUtils.hasText(piTask.getRepeatCustomDay())) {
                 BusinessException.throwFail(String.format("打卡任务ID：%s， 重复周期类型：自定义重复，没有设定自定义重复日期"));
             }
 
             LocalDate repeatDate = LocalDate.parse(repeatDateStr);
             int dayOfWeekValue = repeatDate.getDayOfWeek().getValue();
-            return punchInTask.getRepeatCustomDay().contains(String.valueOf(dayOfWeekValue));
+            return piTask.getRepeatCustomDay().contains(String.valueOf(dayOfWeekValue));
         }
 
         return false;
     }
 
     @Override
-    public PunchInStatusEnum judgePunchInStatusInTask(PunchInTask punchInTask, PunchInTaskHistory punchInTaskHistory) {
-        Assert.isNullInBusiness(punchInTask, "打卡任务不能为空 ");
+    public PunchInStatusEnum judgePunchInStatusInTask(PiTask piTask, PiTaskHistory piTaskHistory) {
+        Assert.isNullInBusiness(piTask, "打卡任务不能为空 ");
 
         // 没有打卡记录，直接没完成
-        if (Objects.isNull(punchInTaskHistory)) {
+        if (Objects.isNull(piTaskHistory)) {
             return PunchInStatusEnum.UNDONE;
         }
 
         // 单次打卡，不区分是否节假日
-        if (PunchInMethodEnum.SINGLE.equals(punchInTask.getPunchInMethod())) {
-            int countTrack = Optional.ofNullable(punchInTask.getCountTrack()).orElse(0);
+        if (PunchInMethodEnum.SINGLE.equals(piTask.getPunchInMethod())) {
+            int countTrack = Optional.ofNullable(piTask.getCountTrack()).orElse(0);
             return countTrack > 0 ? PunchInStatusEnum.DONE : PunchInStatusEnum.UNDONE;
         }
 
         // 打卡任务的节假日启用配置
-        CommonEnableStatusEnum holidayStatus = Optional.ofNullable(punchInTask.getHolidayStatus()).orElse(CommonEnableStatusEnum.DISABLED);
-        boolean enableHolidayFlag = CommonEnableStatusEnum.ENABLED.equals(holidayStatus) && calendarManager.judgeHoliday(punchInTaskHistory.getPunchInDate());
+        CommonEnableStatusEnum holidayStatus = Optional.ofNullable(piTask.getHolidayStatus()).orElse(CommonEnableStatusEnum.DISABLED);
+        boolean enableHolidayFlag = CommonEnableStatusEnum.ENABLED.equals(holidayStatus) && calendarManager.judgeHoliday(piTaskHistory.getPunchInDate());
 
         // 计数打卡，要区分是否节假日使用不同的判断标准
-        if (PunchInMethodEnum.COUNT.equals(punchInTask.getPunchInMethod())) {
-            int countTrack = enableHolidayFlag ? punchInTask.getHolidayCountTrack() : punchInTask.getCountTrack();
-            int punchInCountTrack = Optional.ofNullable(punchInTaskHistory.getCountTrack()).orElse(0);
-            if (CompareRuleEnum.GTE.equals(punchInTask.getCompareRule()) && punchInCountTrack >= countTrack) {
+        if (PunchInMethodEnum.COUNT.equals(piTask.getPunchInMethod())) {
+            int countTrack = enableHolidayFlag ? piTask.getHolidayCountTrack() : piTask.getCountTrack();
+            int punchInCountTrack = Optional.ofNullable(piTaskHistory.getCountTrack()).orElse(0);
+            if (CompareRuleEnum.GTE.equals(piTask.getCompareRule()) && punchInCountTrack >= countTrack) {
                 return PunchInStatusEnum.DONE;
             }
-            if (CompareRuleEnum.LTE.equals(punchInTask.getCompareRule()) && punchInCountTrack <= countTrack) {
+            if (CompareRuleEnum.LTE.equals(piTask.getCompareRule()) && punchInCountTrack <= countTrack) {
                 return PunchInStatusEnum.DONE;
             }
             return PunchInStatusEnum.UNDONE;
         }
 
         // 计时打卡，要区分是否节假日使用不同的判断标准
-        if (PunchInMethodEnum.TIMING.equals(punchInTask.getPunchInMethod())) {
-            LocalTime timeTrack = enableHolidayFlag ? punchInTask.getHolidayTimeTrack() : punchInTask.getTimeTrack();
-            LocalTime punchInTimeTrack = Optional.ofNullable(punchInTaskHistory.getTimeTrack()).orElse(LocalTime.parse("00:00:00.000"));
-            if (CompareRuleEnum.GTE.equals(punchInTask.getCompareRule()) && punchInTimeTrack.compareTo(timeTrack) > -1) {
+        if (PunchInMethodEnum.TIMING.equals(piTask.getPunchInMethod())) {
+            LocalTime timeTrack = enableHolidayFlag ? piTask.getHolidayTimeTrack() : piTask.getTimeTrack();
+            LocalTime punchInTimeTrack = Optional.ofNullable(piTaskHistory.getTimeTrack()).orElse(LocalTime.parse("00:00:00.000"));
+            if (CompareRuleEnum.GTE.equals(piTask.getCompareRule()) && punchInTimeTrack.compareTo(timeTrack) > -1) {
                 return PunchInStatusEnum.DONE;
             }
-            if (CompareRuleEnum.LTE.equals(punchInTask.getCompareRule()) && punchInTimeTrack.compareTo(timeTrack) < 1) {
+            if (CompareRuleEnum.LTE.equals(piTask.getCompareRule()) && punchInTimeTrack.compareTo(timeTrack) < 1) {
                 return PunchInStatusEnum.DONE;
             }
 
@@ -120,17 +120,17 @@ public class PunchInManagerImpl implements IPunchInManager {
     }
 
     @Override
-    public PunchInStatusEnum judgePunchInStatusInMultiTask(PunchInMultiTask punchInMultiTask, List<PunchInTaskHistory> punchInTaskHistoryList) {
-        if (CollectionUtils.isEmpty(punchInTaskHistoryList)) {
+    public PunchInStatusEnum judgePunchInStatusInMultiTask(PiMultiTask piMultiTask, List<PiTaskHistory> piTaskHistoryList) {
+        if (CollectionUtils.isEmpty(piTaskHistoryList)) {
             return PunchInStatusEnum.UNDONE;
         }
 
         // 完成的打卡数量
-        long punchInDoneCount = punchInTaskHistoryList.stream().filter(v -> PunchInStatusEnum.DONE.equals(v.getPunchInStatus())).count();
+        long punchInDoneCount = piTaskHistoryList.stream().filter(v -> PunchInStatusEnum.DONE.equals(v.getPunchInStatus())).count();
 
         // 当天打卡次数大于等于设置的次数，则完成打卡
         // 没有设置时默认设置一个较大的数，避免出现打卡次数为0的情况
-        Integer doneCount = Optional.ofNullable(punchInMultiTask.getPunchInDoneCount()).orElse(punchInTaskHistoryList.size() + 1);
+        Integer doneCount = Optional.ofNullable(piMultiTask.getPunchInDoneCount()).orElse(piTaskHistoryList.size() + 1);
         return punchInDoneCount >= doneCount ? PunchInStatusEnum.DONE : PunchInStatusEnum.UNDONE;
     }
 }

src/main/java/com/punchsettle/server/service/manager/impl/PunchInManagerV1Impl.java

@@ -17,13 +17,13 @@ import java.util.Optional;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTask;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskExt;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskHistory;
-import com.punchsettle.server.atomic.entity.PunchInStatsMonth;
-import com.punchsettle.server.atomic.entity.PunchInStatsWeek;
-import com.punchsettle.server.atomic.entity.PunchInStatus;
-import com.punchsettle.server.atomic.entity.PunchInTaskExt;
+import com.punchsettle.server.atomic.entity.PiMultiTask;
+import com.punchsettle.server.atomic.entity.PiMultiTaskExt;
+import com.punchsettle.server.atomic.entity.PiMultiTaskHistory;
+import com.punchsettle.server.atomic.entity.StatPiTaskMonth;
+import com.punchsettle.server.atomic.entity.StatPiTaskWeek;
+import com.punchsettle.server.atomic.entity.PiStatus;
+import com.punchsettle.server.atomic.entity.PiTaskExt;
 import com.punchsettle.server.constant.ConsecutiveStatusEnum;
 import com.punchsettle.server.constant.FullAttendancePeriodEnum;
 import com.punchsettle.server.constant.PunchInDimensionEnum;
@@ -38,8 +38,8 @@ import org.springframework.util.CollectionUtils;
 
 import com.punchsettle.server.atomic.entity.PunchIn;
 import com.punchsettle.server.atomic.entity.PunchInRecord;
-import com.punchsettle.server.atomic.entity.PunchInTask;
-import com.punchsettle.server.atomic.entity.PunchInTaskHistory;
+import com.punchsettle.server.atomic.entity.PiTask;
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
 import com.punchsettle.server.atomic.service.IPunchInRecordService;
 import com.punchsettle.server.atomic.service.IPunchInService;
 import com.punchsettle.server.common.exception.BusinessException;
@@ -459,75 +459,75 @@ public class PunchInManagerV1Impl implements IPunchInManagerV1 {
     private ICalendarManager calendarManager;
 
     @Override
-    public boolean judgeRepeat(PunchInTask punchInTask, String repeatDateStr) {
+    public boolean judgeRepeat(PiTask piTask, String repeatDateStr) {
         // 每天
-        if (RepeatCategoryEnum.EVERYDAY.equals(punchInTask.getRepeatCategory())) {
+        if (RepeatCategoryEnum.EVERYDAY.equals(piTask.getRepeatCategory())) {
             return true;
         }
 
         // 法定工作日
-        if (RepeatCategoryEnum.WORKDAY.equals(punchInTask.getRepeatCategory())) {
+        if (RepeatCategoryEnum.WORKDAY.equals(piTask.getRepeatCategory())) {
             return !calendarManager.judgeHoliday(repeatDateStr);
         }
 
         // 法定节假日（含周末）
-        if (RepeatCategoryEnum.HOLIDAY.equals(punchInTask.getRepeatCategory())) {
+        if (RepeatCategoryEnum.HOLIDAY.equals(piTask.getRepeatCategory())) {
             return !calendarManager.judgeHoliday(repeatDateStr);
         }
 
         // 自定义
-        if (RepeatCategoryEnum.CUSTOM.equals(punchInTask.getRepeatCategory())) {
-            if (!StringUtils.hasText(punchInTask.getRepeatCustomDay())) {
+        if (RepeatCategoryEnum.CUSTOM.equals(piTask.getRepeatCategory())) {
+            if (!StringUtils.hasText(piTask.getRepeatCustomDay())) {
                 BusinessException.throwFail(String.format("打卡任务ID：%s， 重复周期类型：自定义重复，没有设定自定义重复日期"));
             }
 
             LocalDate repeatDate = LocalDate.parse(repeatDateStr);
             int dayOfWeekValue = repeatDate.getDayOfWeek().getValue();
-            return punchInTask.getRepeatCustomDay().contains(String.valueOf(dayOfWeekValue));
+            return piTask.getRepeatCustomDay().contains(String.valueOf(dayOfWeekValue));
         }
 
         return false;
     }
 
     @Override
-    public PunchInStatusEnum judgePunchInStatusInTask(PunchInTask punchInTask, PunchInTaskHistory punchInTaskHistory, boolean holidayFlag) {
-        Assert.isNullInBusiness(punchInTask, "打卡任务不能为空 ");
+    public PunchInStatusEnum judgePunchInStatusInTask(PiTask piTask, PiTaskHistory piTaskHistory, boolean holidayFlag) {
+        Assert.isNullInBusiness(piTask, "打卡任务不能为空 ");
         // 没有打卡记录，直接没完成
-        if (Objects.isNull(punchInTaskHistory)) {
+        if (Objects.isNull(piTaskHistory)) {
             return PunchInStatusEnum.UNDONE;
         }
 
         // 单次打卡，不区分是否节假日
-        if (PunchInMethodEnum.SINGLE.equals(punchInTask.getPunchInMethod())) {
-            int countTrack = Optional.ofNullable(punchInTask.getCountTrack()).orElse(0);
+        if (PunchInMethodEnum.SINGLE.equals(piTask.getPunchInMethod())) {
+            int countTrack = Optional.ofNullable(piTask.getCountTrack()).orElse(0);
             return countTrack > 0 ? PunchInStatusEnum.DONE : PunchInStatusEnum.UNDONE;
         }
 
         // 打卡任务的节假日启用配置
-        CommonEnableStatusEnum holidayStatus = Optional.ofNullable(punchInTask.getHolidayStatus()).orElse(CommonEnableStatusEnum.DISABLED);
+        CommonEnableStatusEnum holidayStatus = Optional.ofNullable(piTask.getHolidayStatus()).orElse(CommonEnableStatusEnum.DISABLED);
         boolean enableHolidayFlag = CommonEnableStatusEnum.ENABLED.equals(holidayStatus) && holidayFlag;
 
         // 计数打卡，要区分是否节假日使用不同的判断标准
-        if (PunchInMethodEnum.COUNT.equals(punchInTask.getPunchInMethod())) {
-            int countTrack = enableHolidayFlag ? punchInTask.getHolidayCountTrack() : punchInTask.getCountTrack();
-            int punchInCountTrack = Optional.ofNullable(punchInTaskHistory.getCountTrack()).orElse(0);
-            if (CompareRuleEnum.GTE.equals(punchInTask.getCompareRule()) && punchInCountTrack >= countTrack) {
+        if (PunchInMethodEnum.COUNT.equals(piTask.getPunchInMethod())) {
+            int countTrack = enableHolidayFlag ? piTask.getHolidayCountTrack() : piTask.getCountTrack();
+            int punchInCountTrack = Optional.ofNullable(piTaskHistory.getCountTrack()).orElse(0);
+            if (CompareRuleEnum.GTE.equals(piTask.getCompareRule()) && punchInCountTrack >= countTrack) {
                 return PunchInStatusEnum.DONE;
             }
-            if (CompareRuleEnum.LTE.equals(punchInTask.getCompareRule()) && punchInCountTrack <= countTrack) {
+            if (CompareRuleEnum.LTE.equals(piTask.getCompareRule()) && punchInCountTrack <= countTrack) {
                 return PunchInStatusEnum.DONE;
             }
             return PunchInStatusEnum.UNDONE;
         }
 
         // 计时打卡，要区分是否节假日使用不同的判断标准
-        if (PunchInCategoryEnum.TIME.equals(punchInTask.getPunchInMethod())) {
-            LocalTime timeTrack = enableHolidayFlag ? punchInTask.getHolidayTimeTrack() : punchInTask.getTimeTrack();
-            LocalTime punchInTimeTrack = Optional.ofNullable(punchInTaskHistory.getTimeTrack()).orElse(LocalTime.parse("00:00:00.000"));
-            if (CompareRuleEnum.GTE.equals(punchInTask.getCompareRule()) && punchInTimeTrack.compareTo(timeTrack) > -1) {
+        if (PunchInCategoryEnum.TIME.equals(piTask.getPunchInMethod())) {
+            LocalTime timeTrack = enableHolidayFlag ? piTask.getHolidayTimeTrack() : piTask.getTimeTrack();
+            LocalTime punchInTimeTrack = Optional.ofNullable(piTaskHistory.getTimeTrack()).orElse(LocalTime.parse("00:00:00.000"));
+            if (CompareRuleEnum.GTE.equals(piTask.getCompareRule()) && punchInTimeTrack.compareTo(timeTrack) > -1) {
                 return PunchInStatusEnum.DONE;
             }
-            if (CompareRuleEnum.LTE.equals(punchInTask.getCompareRule()) && punchInTimeTrack.compareTo(timeTrack) < 1) {
+            if (CompareRuleEnum.LTE.equals(piTask.getCompareRule()) && punchInTimeTrack.compareTo(timeTrack) < 1) {
                 return PunchInStatusEnum.DONE;
             }
 
@@ -538,13 +538,13 @@ public class PunchInManagerV1Impl implements IPunchInManagerV1 {
     }
 
     @Override
-    public PunchInStatusEnum judgePunchInStatusInMultiTask(PunchInMultiTask punchInMultiTask, List<PunchInTaskHistory> punchInTaskHistoryList, int multiTaskNum) {
-        if (CollectionUtils.isEmpty(punchInTaskHistoryList) || multiTaskNum == 0) {
+    public PunchInStatusEnum judgePunchInStatusInMultiTask(PiMultiTask piMultiTask, List<PiTaskHistory> piTaskHistoryList, int multiTaskNum) {
+        if (CollectionUtils.isEmpty(piTaskHistoryList) || multiTaskNum == 0) {
             return PunchInStatusEnum.UNDONE;
         }
 
         // 完成的打卡数量
-        long punchInDoneCount = punchInTaskHistoryList.stream().filter(v -> PunchInStatusEnum.DONE.equals(v.getPunchInStatus())).count();
+        long punchInDoneCount = piTaskHistoryList.stream().filter(v -> PunchInStatusEnum.DONE.equals(v.getPunchInStatus())).count();
 
 //        // 次数，当天打卡次数大于等于设置的次数，则完成打卡
 //        if (PunchInMethodMultiEnum.COUNT.equals(punchInMultiTask.getPunchInMethod())) {
@@ -566,40 +566,40 @@ public class PunchInManagerV1Impl implements IPunchInManagerV1 {
     }
 
     @Override
-    public int calculatePointsInTask(PunchInTask punchInTask, List<PunchInTaskExt> punchInTaskExts, PunchInTaskHistory punchInTaskHistory, PunchInStatsWeek punchInStatsWeek, PunchInStatsMonth punchInStatsMonth, PunchInStatus punchInStatus) {
+    public int calculatePointsInTask(PiTask piTask, List<PiTaskExt> piTaskExts, PiTaskHistory piTaskHistory, StatPiTaskWeek statPiTaskWeek, StatPiTaskMonth statPiTaskMonth, PiStatus piStatus) {
         // 未完成打卡，积分为0
-        if (PunchInStatusEnum.UNDONE.equals(punchInTaskHistory.getPunchInStatus())) {
+        if (PunchInStatusEnum.UNDONE.equals(piTaskHistory.getPunchInStatus())) {
             return 0;
         }
 
         // 单次打卡中使用的拓展信息
-        List<PunchInTaskExt> punchInExtList = punchInTaskExts.stream().filter(v -> PunchInDimensionEnum.ONE_DAY.equals(v.getDimension())).collect(Collectors.toList());
+        List<PiTaskExt> punchInExtList = piTaskExts.stream().filter(v -> PunchInDimensionEnum.ONE_DAY.equals(v.getDimension())).collect(Collectors.toList());
         // 打卡任务使用的拓展信息
-        List<PunchInTaskExt> punchInTaskExtList = punchInTaskExts.stream().filter(v -> PunchInDimensionEnum.MULTI_DAY.equals(v.getDimension())).collect(Collectors.toList());
+        List<PiTaskExt> piTaskExtList = piTaskExts.stream().filter(v -> PunchInDimensionEnum.MULTI_DAY.equals(v.getDimension())).collect(Collectors.toList());
 
         // 单个任务积分=基本积分+（可选）额外积分+（可选）连续完成额外积分+法定节假日（含周末）双倍奖励+全勤双倍奖励
         // 基本积分
-        int basicPoints = Optional.ofNullable(punchInTask.getPoints()).orElse(0);
+        int basicPoints = Optional.ofNullable(piTask.getPoints()).orElse(0);
 
         // 额外积分
-        basicPoints += calculateExtraPointsInTask(punchInTask, punchInExtList, punchInTaskHistory, calendarManager.judgeHoliday(punchInTaskHistory.getPunchInDate()));
+        basicPoints += calculateExtraPointsInTask(piTask, punchInExtList, piTaskHistory, calendarManager.judgeHoliday(piTaskHistory.getPunchInDate()));
 
         // 启用了全勤奖励
         int fullAttendancePoints = 0;
-        if (CommonEnableStatusEnum.ENABLED.equals(punchInTask.getFullAttendanceStatus())) {
-            LocalDate punchInDate = LocalDate.parse(punchInTaskHistory.getPunchInDate());
+        if (CommonEnableStatusEnum.ENABLED.equals(piTask.getFullAttendanceStatus())) {
+            LocalDate punchInDate = LocalDate.parse(piTaskHistory.getPunchInDate());
             // 结算周期：周，并且结算日是周末，则双倍奖励；
-            if (FullAttendancePeriodEnum.WEEK.equals(punchInTask.getFullAttendancePeriod()) && punchInDate.getDayOfWeek().getValue() == 7) {
-                int undoneCount = punchInStatsWeek.getPunchInTotalCount() - punchInStatsWeek.getPunchInDoneCount();
-                if (undoneCount <= punchInTask.getFullAttendanceFaultToleranceCnt()) {
+            if (FullAttendancePeriodEnum.WEEK.equals(piTask.getFullAttendancePeriod()) && punchInDate.getDayOfWeek().getValue() == 7) {
+                int undoneCount = statPiTaskWeek.getPunchInTotalCount() - statPiTaskWeek.getPunchInDoneCount();
+                if (undoneCount <= piTask.getFullAttendanceFaultToleranceCnt()) {
                     fullAttendancePoints = basicPoints;
                 }
             }
 
             // 结算周期：月，结算日是当月最后一天，则双倍奖励；
-            if (FullAttendancePeriodEnum.MONTH.equals(punchInTask.getFullAttendancePeriod()) && punchInDate.lengthOfMonth() == punchInDate.getDayOfMonth()) {
-                int undoneCount = punchInStatsMonth.getPunchInTotalCount() - punchInStatsMonth.getPunchInDoneCount();
-                if (undoneCount <= punchInTask.getFullAttendanceFaultToleranceCnt()) {
+            if (FullAttendancePeriodEnum.MONTH.equals(piTask.getFullAttendancePeriod()) && punchInDate.lengthOfMonth() == punchInDate.getDayOfMonth()) {
+                int undoneCount = statPiTaskMonth.getPunchInTotalCount() - statPiTaskMonth.getPunchInDoneCount();
+                if (undoneCount <= piTask.getFullAttendanceFaultToleranceCnt()) {
                     fullAttendancePoints = basicPoints;
                 }
             }
@@ -607,22 +607,22 @@ public class PunchInManagerV1Impl implements IPunchInManagerV1 {
 
         // 启用了法定节假日（含周末）双倍奖励
         int holidayPoints = 0;
-        if (CommonEnableStatusEnum.ENABLED.equals(punchInTask.getHolidayStatus()) && calendarManager.judgeHoliday(punchInTaskHistory.getPunchInDate())) {
+        if (CommonEnableStatusEnum.ENABLED.equals(piTask.getHolidayStatus()) && calendarManager.judgeHoliday(piTaskHistory.getPunchInDate())) {
             holidayPoints = basicPoints;
         }
 
         // 连续完成额外积分
         int taskPoints = 0;
-        if (CommonEnableStatusEnum.ENABLED.equals(punchInTask.getTaskPointsStatus()) && ConsecutiveStatusEnum.CONSECUTIVE.equals(punchInStatus.getConsecutiveStatus())) {
+        if (CommonEnableStatusEnum.ENABLED.equals(piTask.getTaskPointsStatus()) && ConsecutiveStatusEnum.CONSECUTIVE.equals(piStatus.getTaskContinueStatus())) {
             // punchInTaskExtList 根据InitialValue倒序排列
-            punchInTaskExtList.sort(Comparator.comparing(PunchInTaskExt::getInitialValue).reversed());
+            piTaskExtList.sort(Comparator.comparing(PiTaskExt::getInitialValue).reversed());
             // 第二轮标志
             boolean secondRound = false;
             // 上一轮的值
             int prevInitialValue = 0;
-            for (PunchInTaskExt punchInTaskExt : punchInTaskExtList) {
+            for (PiTaskExt piTaskExt : piTaskExtList) {
                 // 比较结果
-                int compareValue = punchInStatus.getConsecutiveDay().compareTo(punchInTaskExt.getInitialValue());
+                int compareValue = piStatus.getTaskContinueDay().compareTo(piTaskExt.getInitialValue());
                 // 如果连续日期小于initialValue，则跳过
                 if (compareValue == -1) {
                     continue;
@@ -631,13 +631,13 @@ public class PunchInManagerV1Impl implements IPunchInManagerV1 {
                 int extraCount = 0;
                 // 如果连续日期大于等于initialValue，则进行第一次计算，并把第二轮标志位设置为true，第二轮/后续轮只需要用上一轮的值进行计算
                 if (secondRound) {
-                    extraCount = prevInitialValue - punchInTaskExt.getInitialValue();
+                    extraCount = prevInitialValue - piTaskExt.getInitialValue();
                 } else if (compareValue >= 0) {
-                    extraCount = punchInStatus.getConsecutiveDay() - punchInTaskExt.getInitialValue() + 1;
+                    extraCount = piStatus.getTaskContinueDay() - piTaskExt.getInitialValue() + 1;
                     secondRound = true;
                 }
-                taskPoints +=  punchInTaskExt.getExtraPoints() * extraCount;
-                prevInitialValue = punchInTaskExt.getInitialValue();
+                taskPoints +=  piTaskExt.getExtraPoints() * extraCount;
+                prevInitialValue = piTaskExt.getInitialValue();
             }
         }
 
@@ -646,28 +646,28 @@ public class PunchInManagerV1Impl implements IPunchInManagerV1 {
 
     /**
      * 计算额外积分
-     * @param punchInTask
-     * @param punchInTaskExtList
+     * @param piTask
+     * @param piTaskExtList
      * @return
      */
-    private int calculateExtraPointsInTask(PunchInTask punchInTask, List<PunchInTaskExt> punchInTaskExtList, PunchInTaskHistory punchInTaskHistory, boolean holidayFlag) {
+    private int calculateExtraPointsInTask(PiTask piTask, List<PiTaskExt> piTaskExtList, PiTaskHistory piTaskHistory, boolean holidayFlag) {
         // 单次打卡或者没有启用额外积分计算则跳过
-        if (PunchInExtraMethodEnum.NONE.equals(punchInTask.getExtraMethod())
-            || PunchInMethodEnum.SINGLE.equals(punchInTask.getPunchInMethod())) {
+        if (PunchInExtraMethodEnum.NONE.equals(piTask.getExtraMethod())
+            || PunchInMethodEnum.SINGLE.equals(piTask.getPunchInMethod())) {
             return 0;
         }
 
         // 计算超出部分，
         int extraCountTrack = 0;
         // 计数打卡
-        if (PunchInMethodEnum.COUNT.equals(punchInTask.getPunchInMethod())) {
-            extraCountTrack = punchInTaskHistory.getCountTrack() - (holidayFlag ? punchInTask.getHolidayCountTrack() : punchInTask.getCountTrack());
+        if (PunchInMethodEnum.COUNT.equals(piTask.getPunchInMethod())) {
+            extraCountTrack = piTaskHistory.getCountTrack() - (holidayFlag ? piTask.getHolidayCountTrack() : piTask.getCountTrack());
         }
         // 计时打卡
-        if (PunchInMethodEnum.TIMING.equals(punchInTask.getPunchInMethod())) {
+        if (PunchInMethodEnum.TIMING.equals(piTask.getPunchInMethod())) {
             // 超出的时间按照时间间隔转换成次数
-            long timeTrack = punchInTaskHistory.getTimeTrack().until((holidayFlag ? punchInTask.getHolidayTimeTrack() : punchInTask.getTimeTrack()), ChronoUnit.MINUTES);
-            extraCountTrack = BigDecimal.valueOf(timeTrack).divide(BigDecimal.valueOf(punchInTask.getExtraTimeStep()), 0, RoundingMode.FLOOR).intValue();
+            long timeTrack = piTaskHistory.getTimeTrack().until((holidayFlag ? piTask.getHolidayTimeTrack() : piTask.getTimeTrack()), ChronoUnit.MINUTES);
+            extraCountTrack = BigDecimal.valueOf(timeTrack).divide(BigDecimal.valueOf(piTask.getExtraTimeStep()), 0, RoundingMode.FLOOR).intValue();
         }
 
         // 如果等于0则没有超出部分，不用计算
@@ -676,17 +676,17 @@ public class PunchInManagerV1Impl implements IPunchInManagerV1 {
         }
 
         // 固定计算
-        if (PunchInExtraMethodEnum.FIXED.equals(punchInTask.getExtraMethod())) {
-            Integer extraPoints = Optional.ofNullable(punchInTask.getExtraPoints()).orElse(0);
+        if (PunchInExtraMethodEnum.FIXED.equals(piTask.getExtraMethod())) {
+            Integer extraPoints = Optional.ofNullable(piTask.getExtraPoints()).orElse(0);
             return extraCountTrack * extraPoints;
         }
 
         // 区间计算
-        if (PunchInExtraMethodEnum.INTERVAL.equals(punchInTask.getExtraMethod()) && !CollectionUtils.isEmpty(punchInTaskExtList)) {
+        if (PunchInExtraMethodEnum.INTERVAL.equals(piTask.getExtraMethod()) && !CollectionUtils.isEmpty(piTaskExtList)) {
             int basicPoints = 0;
             int prevInitialValue = 0;
-            for (PunchInTaskExt punchInTaskExt : punchInTaskExtList) {
-                Integer initialValue = Optional.ofNullable(punchInTaskExt.getInitialValue()).orElse(0);
+            for (PiTaskExt piTaskExt : piTaskExtList) {
+                Integer initialValue = Optional.ofNullable(piTaskExt.getInitialValue()).orElse(0);
                 // 第一轮：initialValue - extraCountTrack的值v1
                 // 如果v1≤0则超出initialValue范围，使用initialValue计算；
                 // 如果v1＞0则在initialValue范围内 使用extraCountTrack
@@ -695,9 +695,9 @@ public class PunchInManagerV1Impl implements IPunchInManagerV1 {
                 // 如果v1＞0则在本轮initialValue范围内 使用extraCountTrack-上一轮initialValue的值v3计算
                 // 下面的代码不适合第一轮的计算
                 if (initialValue - extraCountTrack <= 0) {
-                    basicPoints = punchInTaskExt.getExtraPoints() * Math.abs(prevInitialValue - initialValue);
+                    basicPoints = piTaskExt.getExtraPoints() * Math.abs(prevInitialValue - initialValue);
                 } else {
-                    basicPoints = punchInTaskExt.getExtraPoints() * (extraCountTrack - prevInitialValue);
+                    basicPoints = piTaskExt.getExtraPoints() * (extraCountTrack - prevInitialValue);
                 }
                 prevInitialValue = initialValue;
             }
@@ -708,39 +708,39 @@ public class PunchInManagerV1Impl implements IPunchInManagerV1 {
     }
 
     @Override
-    public int calculatePointsInMultiTask(PunchInMultiTask punchInMultiTask, List<PunchInMultiTaskExt> punchInMultiTaskExts, PunchInMultiTaskHistory punchInMultiTaskHistory, PunchInStatus punchInStatus) {
+    public int calculatePointsInMultiTask(PiMultiTask piMultiTask, List<PiMultiTaskExt> piMultiTaskExts, PiMultiTaskHistory piMultiTaskHistory, PiStatus piStatus) {
         // 未完成打卡或没有启用多任务积分计算，积分为0
-        if (PunchInStatusEnum.UNDONE.equals(punchInMultiTaskHistory.getPunchInStatus())
-            || CommonEnableStatusEnum.ENABLED.equals(punchInMultiTask.getTaskPointsStatus())) {
+        if (PunchInStatusEnum.UNDONE.equals(piMultiTaskHistory.getPunchInStatus())
+            || CommonEnableStatusEnum.ENABLED.equals(piMultiTask.getTaskPointsStatus())) {
             return 0;
         }
 
         // 单次打卡中使用的拓展信息
-        List<PunchInMultiTaskExt> punchInExtList = punchInMultiTaskExts.stream().filter(v -> PunchInDimensionEnum.ONE_DAY.equals(v.getDimension())).collect(Collectors.toList());
+        List<PiMultiTaskExt> punchInExtList = piMultiTaskExts.stream().filter(v -> PunchInDimensionEnum.ONE_DAY.equals(v.getDimension())).collect(Collectors.toList());
         // 打卡任务使用的拓展信息
-        List<PunchInMultiTaskExt> punchInTaskExtList = punchInMultiTaskExts.stream().filter(v -> PunchInDimensionEnum.MULTI_DAY.equals(v.getDimension())).collect(Collectors.toList());
+        List<PiMultiTaskExt> punchInTaskExtList = piMultiTaskExts.stream().filter(v -> PunchInDimensionEnum.MULTI_DAY.equals(v.getDimension())).collect(Collectors.toList());
 
         // 多个任务积分=多任务基本积分+多任务额外积分+连续完成额外积分
         // 基本积分
-        int basicPoints = punchInMultiTask.getPoints();
+        int basicPoints = piMultiTask.getPoints();
 
         // 额外积分
         int extraPoints = 0;
         // 额外次数
-        int extractCount = punchInMultiTaskHistory.getPunchInDoneCount() - punchInMultiTask.getPunchInDoneCount();
+        int extractCount = piMultiTaskHistory.getPunchInDoneCount() - piMultiTask.getPunchInDoneCount();
         // 固定计算
-        if (PunchInExtraMethodEnum.FIXED.equals(punchInMultiTask.getExtraMethod())) {
-            extraPoints = extractCount * punchInMultiTask.getExtraPoints();
+        if (PunchInExtraMethodEnum.FIXED.equals(piMultiTask.getExtraMethod())) {
+            extraPoints = extractCount * piMultiTask.getExtraPoints();
         }
         // 区间计算
-        if (PunchInExtraMethodEnum.INTERVAL.equals(punchInMultiTask.getExtraMethod()) && !CollectionUtils.isEmpty(punchInMultiTaskExts)) {
+        if (PunchInExtraMethodEnum.INTERVAL.equals(piMultiTask.getExtraMethod()) && !CollectionUtils.isEmpty(piMultiTaskExts)) {
             // punchInTaskExtList 根据InitialValue倒序排列
-            punchInExtList.sort(Comparator.comparing(PunchInMultiTaskExt::getInitialValue).reversed());
+            punchInExtList.sort(Comparator.comparing(PiMultiTaskExt::getInitialValue).reversed());
             // 第二轮标志
             boolean secondRound = false;
             // 上一轮的值
             int prevInitialValue = 0;
-            for (PunchInMultiTaskExt punchInTaskExt : punchInTaskExtList) {
+            for (PiMultiTaskExt punchInTaskExt : punchInTaskExtList) {
                 // 比较结果
                 int compareValue = Integer.compare(extractCount, punchInTaskExt.getInitialValue());
                 // 如果连续日期小于initialValue，则跳过
@@ -763,16 +763,16 @@ public class PunchInManagerV1Impl implements IPunchInManagerV1 {
 
         // 连续完成额外积分
         int taskPoints = 0;
-        if (CommonEnableStatusEnum.ENABLED.equals(punchInMultiTask.getTaskPointsStatus()) && ConsecutiveStatusEnum.CONSECUTIVE.equals(punchInStatus.getConsecutiveStatus())) {
+        if (CommonEnableStatusEnum.ENABLED.equals(piMultiTask.getTaskPointsStatus()) && ConsecutiveStatusEnum.CONSECUTIVE.equals(piStatus.getTaskContinueStatus())) {
             // punchInTaskExtList 根据InitialValue倒序排列
-            punchInTaskExtList.sort(Comparator.comparing(PunchInMultiTaskExt::getInitialValue).reversed());
+            punchInTaskExtList.sort(Comparator.comparing(PiMultiTaskExt::getInitialValue).reversed());
             // 第二轮标志
             boolean secondRound = false;
             // 上一轮的值
             int prevInitialValue = 0;
-            for (PunchInMultiTaskExt punchInTaskExt : punchInTaskExtList) {
+            for (PiMultiTaskExt punchInTaskExt : punchInTaskExtList) {
                 // 比较结果
-                int compareValue = punchInStatus.getConsecutiveDay().compareTo(punchInTaskExt.getInitialValue());
+                int compareValue = piStatus.getTaskContinueDay().compareTo(punchInTaskExt.getInitialValue());
                 // 如果连续日期小于initialValue，则跳过
                 if (compareValue == -1) {
                     continue;
@@ -783,7 +783,7 @@ public class PunchInManagerV1Impl implements IPunchInManagerV1 {
                 if (secondRound) {
                     tempExtraCount = prevInitialValue - punchInTaskExt.getInitialValue();
                 } else if (compareValue >= 0) {
-                    tempExtraCount = punchInStatus.getConsecutiveDay() - punchInTaskExt.getInitialValue() + 1;
+                    tempExtraCount = piStatus.getTaskContinueDay() - punchInTaskExt.getInitialValue() + 1;
                     secondRound = true;
                 }
                 taskPoints +=  punchInTaskExt.getExtraPoints() * tempExtraCount;

src/main/java/com/punchsettle/server/service/manager/impl/PunchInStatsWeekServiceImpl.java

@@ -1,46 +0,0 @@
-package com.punchsettle.server.service.manager.impl;
-
-import com.punchsettle.server.atomic.entity.PunchInStatsWeek;
-import com.punchsettle.server.atomic.mapper.PunchInStatsWeekMapper;
-import com.punchsettle.server.atomic.service.IPunchInStatsWeekService;
-import com.punchsettle.server.common.utils.Assert;
-import com.punchsettle.server.pojo.punchIn.PunchInStatsWeekQuery;
-import com.punchsettle.server.utiis.WeekendUtils;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.util.CollectionUtils;
-import tk.mybatis.mapper.weekend.Weekend;
-import tk.mybatis.mapper.weekend.WeekendCriteria;
-
-import java.util.List;
-import java.util.Objects;
-
-/**
- * @author tyuio
- * @version 1.0.0
- * @date 2025/4/15 17:09
- * @description 打卡任务周数据统计 service
- */
-@Slf4j
-@Service
-public class PunchInStatsWeekServiceImpl implements IPunchInStatsWeekService {
-
-    @Autowired
-    private PunchInStatsWeekMapper punchInStatsWeekMapper;
-
-    @Override
-    public List<PunchInStatsWeek> queryByCondition(PunchInStatsWeekQuery punchInStatsWeekQuery) {
-        Assert.isNull(punchInStatsWeekQuery);
-
-        Weekend<PunchInStatsWeek> weekend = WeekendUtils.createExcludeAuditFields(PunchInStatsWeek.class);
-        WeekendCriteria<PunchInStatsWeek, Object> criteria = weekend.weekendCriteria();
-        if (!CollectionUtils.isEmpty(punchInStatsWeekQuery.getTaskUniqueIds())) {
-            criteria.andIn(PunchInStatsWeek::getTaskUniqueId, punchInStatsWeekQuery.getTaskUniqueIds());
-        }
-        if (Objects.nonNull(punchInStatsWeekQuery.getStatsTime())) {
-            criteria.andEqualTo(PunchInStatsWeek::getStatsTime, punchInStatsWeekQuery.getStatsTime());
-        }
-        return punchInStatsWeekMapper.selectByExample(weekend);
-    }
-}

src/main/java/com/punchsettle/server/service/manager/impl/SettleManagerImpl.java

@@ -1,14 +1,14 @@
 package com.punchsettle.server.service.manager.impl;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTask;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskExt;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskHistory;
-import com.punchsettle.server.atomic.entity.PunchInStatsMonth;
-import com.punchsettle.server.atomic.entity.PunchInStatsWeek;
-import com.punchsettle.server.atomic.entity.PunchInStatus;
-import com.punchsettle.server.atomic.entity.PunchInTask;
-import com.punchsettle.server.atomic.entity.PunchInTaskExt;
-import com.punchsettle.server.atomic.entity.PunchInTaskHistory;
+import com.punchsettle.server.atomic.entity.PiMultiTask;
+import com.punchsettle.server.atomic.entity.PiMultiTaskExt;
+import com.punchsettle.server.atomic.entity.PiMultiTaskHistory;
+import com.punchsettle.server.atomic.entity.StatPiTaskMonth;
+import com.punchsettle.server.atomic.entity.StatPiTaskWeek;
+import com.punchsettle.server.atomic.entity.PiStatus;
+import com.punchsettle.server.atomic.entity.PiTask;
+import com.punchsettle.server.atomic.entity.PiTaskExt;
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
 import com.punchsettle.server.common.constant.CommonEnableStatusEnum;
 import com.punchsettle.server.constant.ConsecutiveStatusEnum;
 import com.punchsettle.server.constant.FullAttendancePeriodEnum;
@@ -16,6 +16,7 @@ import com.punchsettle.server.constant.PunchInDimensionEnum;
 import com.punchsettle.server.constant.PunchInExtraMethodEnum;
 import com.punchsettle.server.constant.PunchInMethodEnum;
 import com.punchsettle.server.constant.PunchInStatusEnum;
+import com.punchsettle.server.constant.SettleStatusEnum;
 import com.punchsettle.server.service.manager.ICalendarManager;
 import com.punchsettle.server.service.manager.ISettleManager;
 import lombok.extern.slf4j.Slf4j;
@@ -46,44 +47,87 @@ public class SettleManagerImpl implements ISettleManager {
     private ICalendarManager calendarManager;
 
     @Override
-    public int calculatePointsInTask(PunchInTask punchInTask, List<PunchInTaskExt> punchInTaskExtList,
-        PunchInTaskHistory punchInTaskHistory, PunchInStatsWeek punchInStatsWeek, PunchInStatsMonth punchInStatsMonth,
-        PunchInStatus punchInStatus) {
+    public SettleStatusEnum judgeSettleStatusInTask(PiTask piTask, PiTaskHistory piTaskHistory, PiStatus piStatus) {
+        // 未完成打卡则跳过
+        if (PunchInStatusEnum.UNDONE.equals(piTaskHistory.getPunchInStatus())) {
+            return SettleStatusEnum.UNDONE_SKIP;
+        }
+
+        // 不启用宽限期，则进行跳过
+        if (CommonEnableStatusEnum.DISABLED.equals(piTask.getContinueStatus())) {
+            return SettleStatusEnum.SETTLED;
+        }
+
+        // 宽限期部分，
+        if ("GRACE_STAGE".equals(piStatus.getTaskStage())) {
+            // 计算宽限期结束日，减1是因为开始当日也算在范围内
+            LocalDate graceEndDate = piStatus.getStageStartDate().plusDays(piTask.getGraceDay() - 1);
+            LocalDate punchInDate = LocalDate.parse(piTaskHistory.getPunchInDate());
+            // 如果打卡日期在宽限期范围内，则跳过，否则正常跳过，且进入正常打卡期
+            if (punchInDate.compareTo(graceEndDate) <= 0) {
+                return SettleStatusEnum.GRACE_SKIP;
+            } else {
+                return SettleStatusEnum.SETTLED;
+            }
+        }
+
+        // 正常打卡期
+        if ("NORMAL_STAGE".equals(piStatus.getTaskStage())) {
+            // 如果完成打卡则进入结算，否则进入惩罚期
+            if (PunchInStatusEnum.DONE.equals(piTaskHistory.getPunchInStatus())) {
+                return SettleStatusEnum.SETTLED;
+            } else {
+                return SettleStatusEnum.PENALTY_SKIP;
+            }
+        }
+
+        return SettleStatusEnum.SETTLED;
+    }
+
+    public static void main(String[] args) {
+        LocalDate minSettleDate = LocalDate.now().plusDays(7);
+        System.out.println(minSettleDate);
+    }
+
+    @Override
+    public int calculatePointsInTask(PiTask piTask, List<PiTaskExt> piTaskExtList,
+                                     PiTaskHistory piTaskHistory, StatPiTaskWeek statPiTaskWeek, StatPiTaskMonth statPiTaskMonth,
+                                     PiStatus piStatus) {
         // 未完成打卡，积分为0
-        if (PunchInStatusEnum.UNDONE.equals(punchInTaskHistory.getPunchInStatus())) {
+        if (PunchInStatusEnum.UNDONE.equals(piTaskHistory.getPunchInStatus())) {
             return 0;
         }
 
         // 节假日标识
-        var holidayFlag = calendarManager.judgeHoliday(punchInTaskHistory.getPunchInDate());
+        var holidayFlag = calendarManager.judgeHoliday(piTaskHistory.getPunchInDate());
 
         // 单个任务积分=基本积分+额外积分+法定节假日（含周末）双倍奖励+全勤双倍奖励+连续完成额外积分
         // 基本积分
-        int basicPoints = Optional.ofNullable(punchInTask.getPoints()).orElse(0);
+        int basicPoints = Optional.ofNullable(piTask.getPoints()).orElse(0);
 
         // 额外积分计算
-        List<PunchInTaskExt> punchInOneExtList = punchInTaskExtList.stream()
+        List<PiTaskExt> punchInOneExtList = piTaskExtList.stream()
             .filter(v -> PunchInDimensionEnum.ONE_DAY.equals(v.getDimension())).collect(Collectors.toList());
-        basicPoints += calculateExtraPointsInTask(punchInTask, punchInOneExtList, punchInTaskHistory, holidayFlag);
+        basicPoints += calculateExtraPointsInTask(piTask, punchInOneExtList, piTaskHistory, holidayFlag);
 
         // 全勤积分，全勤则双倍奖励
         int fullAttendancePoints = 0;
-        if (judgeFullAttendanceStatusInTask(punchInTask, punchInTaskHistory, punchInStatsWeek, punchInStatsMonth)) {
+        if (judgeFullAttendanceStatusInTask(piTask, piTaskHistory, statPiTaskWeek, statPiTaskMonth)) {
             fullAttendancePoints = basicPoints;
         }
 
         // 法定节假日积分， 法定节假日（含周末）双倍奖励
         int holidayPoints = 0;
-        if (CommonEnableStatusEnum.ENABLED.equals(punchInTask.getHolidayStatus())
-            && calendarManager.judgeHoliday(punchInTaskHistory.getPunchInDate())) {
+        if (CommonEnableStatusEnum.ENABLED.equals(piTask.getHolidayStatus())
+            && calendarManager.judgeHoliday(piTaskHistory.getPunchInDate())) {
             holidayPoints = basicPoints;
         }
 
         // 打卡任务使用的拓展信息
-        List<PunchInTaskExt> punchInMultiExtList = punchInTaskExtList.stream()
+        List<PiTaskExt> punchInMultiExtList = piTaskExtList.stream()
             .filter(v -> PunchInDimensionEnum.MULTI_DAY.equals(v.getDimension())).collect(Collectors.toList());
         // 连续完成额外积分
-        int taskPoints = calculateConsecutivePointsInTask(punchInTask, punchInMultiExtList, punchInStatus);
+        int taskPoints = calculateConsecutivePointsInTask(piTask, punchInMultiExtList, piStatus);
 
         return basicPoints + fullAttendancePoints + holidayPoints + taskPoints;
     }
@@ -91,20 +135,20 @@ public class SettleManagerImpl implements ISettleManager {
     /**
      * 计算额外积分
      * 
-     * @param punchInTask
-     * @param punchInTaskExtList
+     * @param piTask
+     * @param piTaskExtList
      * @return
      */
-    private int calculateExtraPointsInTask(PunchInTask punchInTask, List<PunchInTaskExt> punchInTaskExtList,
-        PunchInTaskHistory punchInTaskHistory, boolean holidayFlag) {
+    private int calculateExtraPointsInTask(PiTask piTask, List<PiTaskExt> piTaskExtList,
+                                           PiTaskHistory piTaskHistory, boolean holidayFlag) {
         // 单次打卡或者没有启用额外积分计算则跳过
-        if (PunchInExtraMethodEnum.NONE.equals(punchInTask.getExtraMethod())
-            || PunchInMethodEnum.SINGLE.equals(punchInTask.getPunchInMethod())) {
+        if (PunchInExtraMethodEnum.NONE.equals(piTask.getExtraMethod())
+            || PunchInMethodEnum.SINGLE.equals(piTask.getPunchInMethod())) {
             return 0;
         }
 
         // 计算超出部分，获取额外次数
-        int extraCount = getExtraCountInTask(punchInTask, punchInTaskHistory, holidayFlag);
+        int extraCount = getExtraCountInTask(piTask, piTaskHistory, holidayFlag);
 
         // 如果等于0则没有超出部分，不用计算
         if (extraCount == 0) {
@@ -112,14 +156,14 @@ public class SettleManagerImpl implements ISettleManager {
         }
 
         // 固定计算
-        if (PunchInExtraMethodEnum.FIXED.equals(punchInTask.getExtraMethod())) {
-            Integer extraPoints = Optional.ofNullable(punchInTask.getExtraPoints()).orElse(0);
+        if (PunchInExtraMethodEnum.FIXED.equals(piTask.getExtraMethod())) {
+            Integer extraPoints = Optional.ofNullable(piTask.getExtraPoints()).orElse(0);
             return extraCount * extraPoints;
         }
 
         // 区间计算
-        if (PunchInExtraMethodEnum.INTERVAL.equals(punchInTask.getExtraMethod())
-            && !CollectionUtils.isEmpty(punchInTaskExtList)) {
+        if (PunchInExtraMethodEnum.INTERVAL.equals(piTask.getExtraMethod())
+            && !CollectionUtils.isEmpty(piTaskExtList)) {
             // 任务积分
             int extraPoints = 0;
             // 第二轮标志
@@ -127,11 +171,11 @@ public class SettleManagerImpl implements ISettleManager {
             // 上一轮的值
             int prevInitialValue = 0;
             // 拓展信息 根据InitialValue倒序排列
-            punchInTaskExtList.sort(Comparator.comparing(PunchInTaskExt::getInitialValue).reversed());
+            piTaskExtList.sort(Comparator.comparing(PiTaskExt::getInitialValue).reversed());
             // 使用区间计算的方式
-            for (PunchInTaskExt punchInTaskExt : punchInTaskExtList) {
+            for (PiTaskExt piTaskExt : piTaskExtList) {
                 // 比较结果
-                int compareValue = Integer.compare(extraCount, punchInTaskExt.getInitialValue());
+                int compareValue = Integer.compare(extraCount, piTaskExt.getInitialValue());
                 // 如果连续日期小于initialValue，则跳过
                 if (compareValue == -1) {
                     continue;
@@ -140,15 +184,15 @@ public class SettleManagerImpl implements ISettleManager {
                 int tempExtraCount = 0;
                 // 如果连续日期大于等于initialValue，则进行第一次计算，并把第二轮标志位设置为true，第二轮/后续轮只需要用上一轮的值进行计算
                 if (secondRound) {
-                    tempExtraCount = prevInitialValue - punchInTaskExt.getInitialValue();
+                    tempExtraCount = prevInitialValue - piTaskExt.getInitialValue();
                 } else if (compareValue >= 0) {
-                    tempExtraCount = extraCount - punchInTaskExt.getInitialValue() + 1;
+                    tempExtraCount = extraCount - piTaskExt.getInitialValue() + 1;
                     secondRound = true;
                 }
                 // 计算 任务积分
-                extraPoints += punchInTaskExt.getExtraPoints() * tempExtraCount;
+                extraPoints += piTaskExt.getExtraPoints() * tempExtraCount;
                 // 记录本轮的initialValue
-                prevInitialValue = punchInTaskExt.getInitialValue();
+                prevInitialValue = piTaskExt.getInitialValue();
             }
 
             return extraPoints;
@@ -160,26 +204,26 @@ public class SettleManagerImpl implements ISettleManager {
     /**
      * 获取额外次数
      * 
-     * @param punchInTask 打卡任务
-     * @param punchInTaskHistory 打卡记录
+     * @param piTask 打卡任务
+     * @param piTaskHistory 打卡记录
      * @param holidayFlag 是否是法定节假日 true-是，false-不是
      * @return
      */
-    private int getExtraCountInTask(PunchInTask punchInTask, PunchInTaskHistory punchInTaskHistory,
-        boolean holidayFlag) {
+    private int getExtraCountInTask(PiTask piTask, PiTaskHistory piTaskHistory,
+                                    boolean holidayFlag) {
         int extraCount = 0;
         // 计数打卡
-        if (PunchInMethodEnum.COUNT.equals(punchInTask.getPunchInMethod())) {
-            extraCount = punchInTaskHistory.getCountTrack()
-                - (holidayFlag ? punchInTask.getHolidayCountTrack() : punchInTask.getCountTrack());
+        if (PunchInMethodEnum.COUNT.equals(piTask.getPunchInMethod())) {
+            extraCount = piTaskHistory.getCountTrack()
+                - (holidayFlag ? piTask.getHolidayCountTrack() : piTask.getCountTrack());
         }
         // 计时打卡
-        if (PunchInMethodEnum.TIMING.equals(punchInTask.getPunchInMethod())) {
+        if (PunchInMethodEnum.TIMING.equals(piTask.getPunchInMethod())) {
             // 超出的时间按照时间间隔转换成次数
-            long timeTrack = punchInTaskHistory.getTimeTrack().until(
-                (holidayFlag ? punchInTask.getHolidayTimeTrack() : punchInTask.getTimeTrack()), ChronoUnit.MINUTES);
+            long timeTrack = piTaskHistory.getTimeTrack().until(
+                (holidayFlag ? piTask.getHolidayTimeTrack() : piTask.getTimeTrack()), ChronoUnit.MINUTES);
             extraCount = BigDecimal.valueOf(timeTrack)
-                .divide(BigDecimal.valueOf(punchInTask.getExtraTimeStep()), 0, RoundingMode.FLOOR).intValue();
+                .divide(BigDecimal.valueOf(piTask.getExtraTimeStep()), 0, RoundingMode.FLOOR).intValue();
         }
         return extraCount;
     }
@@ -189,46 +233,46 @@ public class SettleManagerImpl implements ISettleManager {
      * 
      * @return true-是全勤，false-不是全勤
      */
-    private boolean judgeFullAttendanceStatusInTask(PunchInTask punchInTask, PunchInTaskHistory punchInTaskHistory,
-        PunchInStatsWeek punchInStatsWeek, PunchInStatsMonth punchInStatsMonth) {
+    private boolean judgeFullAttendanceStatusInTask(PiTask piTask, PiTaskHistory piTaskHistory,
+                                                    StatPiTaskWeek statPiTaskWeek, StatPiTaskMonth statPiTaskMonth) {
         // 没有启用全勤 则直接返回
-        if (CommonEnableStatusEnum.DISABLED.equals(punchInTask.getFullAttendanceStatus())) {
+        if (CommonEnableStatusEnum.DISABLED.equals(piTask.getFullAttendanceStatus())) {
             return false;
         }
 
         // 打卡日期/结算日期
-        LocalDate punchInDate = LocalDate.parse(punchInTaskHistory.getPunchInDate());
+        LocalDate punchInDate = LocalDate.parse(piTaskHistory.getPunchInDate());
 
         // 未完成数，默认设置一个较大值，以防判断有误
-        int undoneCount = punchInTask.getFullAttendanceFaultToleranceCnt() + 1;
+        int undoneCount = piTask.getFullAttendanceFaultToleranceCnt() + 1;
 
         // 结算周期：周，并且结算日是周末；结算周期：月，结算日是当月最后一天；
-        if (FullAttendancePeriodEnum.WEEK.equals(punchInTask.getFullAttendancePeriod())
+        if (FullAttendancePeriodEnum.WEEK.equals(piTask.getFullAttendancePeriod())
             && punchInDate.getDayOfWeek().getValue() == 7) {
-            undoneCount = punchInStatsWeek.getPunchInTotalCount() - punchInStatsWeek.getPunchInDoneCount();
-        } else if (FullAttendancePeriodEnum.MONTH.equals(punchInTask.getFullAttendancePeriod())
+            undoneCount = statPiTaskWeek.getPunchInTotalCount() - statPiTaskWeek.getPunchInDoneCount();
+        } else if (FullAttendancePeriodEnum.MONTH.equals(piTask.getFullAttendancePeriod())
             && punchInDate.lengthOfMonth() == punchInDate.getDayOfMonth()) {
-            undoneCount = punchInStatsMonth.getPunchInTotalCount() - punchInStatsMonth.getPunchInDoneCount();
+            undoneCount = statPiTaskMonth.getPunchInTotalCount() - statPiTaskMonth.getPunchInDoneCount();
         }
 
         // 未完成数在容错范围内，则是全勤
-        return undoneCount <= punchInTask.getFullAttendanceFaultToleranceCnt();
+        return undoneCount <= piTask.getFullAttendanceFaultToleranceCnt();
     }
 
     /**
      * 计算连续积分
      * 
-     * @param punchInTask 打卡任务
-     * @param punchInTaskExtList 打卡任务拓展信息
-     * @param punchInStatus 打卡状态
+     * @param piTask 打卡任务
+     * @param piTaskExtList 打卡任务拓展信息
+     * @param piStatus 打卡状态
      * @return
      */
-    private int calculateConsecutivePointsInTask(PunchInTask punchInTask, List<PunchInTaskExt> punchInTaskExtList,
-        PunchInStatus punchInStatus) {
+    private int calculateConsecutivePointsInTask(PiTask piTask, List<PiTaskExt> piTaskExtList,
+                                                 PiStatus piStatus) {
         // 没有启用任务积分计算、或是连续打卡状态为中断、或是没有拓展信息 则不进行计算
-        if (CommonEnableStatusEnum.DISABLED.equals(punchInTask.getTaskPointsStatus())
-            || ConsecutiveStatusEnum.INTERRUPTED.equals(punchInStatus.getConsecutiveStatus())
-            || CollectionUtils.isEmpty(punchInTaskExtList)) {
+        if (CommonEnableStatusEnum.DISABLED.equals(piTask.getTaskPointsStatus())
+            || ConsecutiveStatusEnum.INTERRUPTED.equals(piStatus.getTaskContinueStatus())
+            || CollectionUtils.isEmpty(piTaskExtList)) {
             return 0;
         }
 
@@ -239,11 +283,11 @@ public class SettleManagerImpl implements ISettleManager {
         // 上一轮的值
         int prevInitialValue = 0;
         // 拓展信息 根据InitialValue倒序排列
-        punchInTaskExtList.sort(Comparator.comparing(PunchInTaskExt::getInitialValue).reversed());
+        piTaskExtList.sort(Comparator.comparing(PiTaskExt::getInitialValue).reversed());
         // 使用区间计算的方式
-        for (PunchInTaskExt punchInTaskExt : punchInTaskExtList) {
+        for (PiTaskExt piTaskExt : piTaskExtList) {
             // 比较结果
-            int compareValue = punchInStatus.getConsecutiveDay().compareTo(punchInTaskExt.getInitialValue());
+            int compareValue = piStatus.getTaskContinueDay().compareTo(piTaskExt.getInitialValue());
             // 如果连续日期小于initialValue，则跳过
             if (compareValue == -1) {
                 continue;
@@ -252,44 +296,44 @@ public class SettleManagerImpl implements ISettleManager {
             int tempExtraCount = 0;
             // 如果连续日期大于等于initialValue，则进行第一次计算，并把第二轮标志位设置为true，第二轮/后续轮只需要用上一轮的值进行计算
             if (secondRound) {
-                tempExtraCount = prevInitialValue - punchInTaskExt.getInitialValue();
+                tempExtraCount = prevInitialValue - piTaskExt.getInitialValue();
             } else if (compareValue >= 0) {
-                tempExtraCount = punchInStatus.getConsecutiveDay() - punchInTaskExt.getInitialValue() + 1;
+                tempExtraCount = piStatus.getTaskContinueDay() - piTaskExt.getInitialValue() + 1;
                 secondRound = true;
             }
             // 计算 任务积分
-            taskPoints += punchInTaskExt.getExtraPoints() * tempExtraCount;
+            taskPoints += piTaskExt.getExtraPoints() * tempExtraCount;
             // 记录本轮的initialValue
-            prevInitialValue = punchInTaskExt.getInitialValue();
+            prevInitialValue = piTaskExt.getInitialValue();
         }
 
         return taskPoints;
     }
 
     @Override
-    public int calculatePointsInMultiTask(PunchInMultiTask punchInMultiTask,
-        List<PunchInMultiTaskExt> punchInMultiTaskExtList, PunchInMultiTaskHistory punchInMultiTaskHistory,
-        PunchInStatus punchInStatus) {
+    public int calculatePointsInMultiTask(PiMultiTask piMultiTask,
+                                          List<PiMultiTaskExt> piMultiTaskExtList, PiMultiTaskHistory piMultiTaskHistory,
+                                          PiStatus piStatus) {
         // 未完成打卡或没有启用多任务积分计算，积分为0
-        if (PunchInStatusEnum.UNDONE.equals(punchInMultiTaskHistory.getPunchInStatus())
-            || CommonEnableStatusEnum.DISABLED.equals(punchInMultiTask.getTaskPointsStatus())) {
+        if (PunchInStatusEnum.UNDONE.equals(piMultiTaskHistory.getPunchInStatus())
+            || CommonEnableStatusEnum.DISABLED.equals(piMultiTask.getTaskPointsStatus())) {
             return 0;
         }
 
         // 多个任务积分=多任务基本积分+多任务额外积分+连续完成额外积分
         // 基本积分
-        int basicPoints = punchInMultiTask.getPoints();
+        int basicPoints = piMultiTask.getPoints();
 
         // 额外积分
-        List<PunchInMultiTaskExt> punchInTaskOneExtList = punchInMultiTaskExtList.stream()
+        List<PiMultiTaskExt> punchInTaskOneExtList = piMultiTaskExtList.stream()
                 .filter(v -> PunchInDimensionEnum.ONE_DAY.equals(v.getDimension())).collect(Collectors.toList());
-        int extraPoints = calculateExtraPointsInMultiTask(punchInMultiTask, punchInTaskOneExtList, punchInMultiTaskHistory);
+        int extraPoints = calculateExtraPointsInMultiTask(piMultiTask, punchInTaskOneExtList, piMultiTaskHistory);
 
         // 连续完成额外积分
-        List<PunchInMultiTaskExt> punchInTaskMultiExtList = punchInMultiTaskExtList.stream()
+        List<PiMultiTaskExt> punchInTaskMultiExtList = piMultiTaskExtList.stream()
             .filter(v -> PunchInDimensionEnum.MULTI_DAY.equals(v.getDimension())).collect(Collectors.toList());
         int taskPoints =
-            calculateConsecutivePointsInMultiTask(punchInMultiTask, punchInTaskMultiExtList, punchInStatus);
+            calculateConsecutivePointsInMultiTask(piMultiTask, punchInTaskMultiExtList, piStatus);
 
         return basicPoints + extraPoints + taskPoints;
     }
@@ -297,25 +341,25 @@ public class SettleManagerImpl implements ISettleManager {
     /**
      * 计算额外积分（多任务）
      * 
-     * @param punchInMultiTask 多任务打卡信息
-     * @param punchInMultiTaskExtList 多任务打卡拓展信息
-     * @param punchInMultiTaskHistory 多任务打卡历史信息
+     * @param piMultiTask 多任务打卡信息
+     * @param piMultiTaskExtList 多任务打卡拓展信息
+     * @param piMultiTaskHistory 多任务打卡历史信息
      * @return
      */
 
-    private int calculateExtraPointsInMultiTask(PunchInMultiTask punchInMultiTask,
-        List<PunchInMultiTaskExt> punchInMultiTaskExtList, PunchInMultiTaskHistory punchInMultiTaskHistory) {
+    private int calculateExtraPointsInMultiTask(PiMultiTask piMultiTask,
+                                                List<PiMultiTaskExt> piMultiTaskExtList, PiMultiTaskHistory piMultiTaskHistory) {
         // 额外次数
-        int extractCount = punchInMultiTaskHistory.getPunchInDoneCount() - punchInMultiTask.getPunchInDoneCount();
+        int extractCount = piMultiTaskHistory.getPunchInDoneCount() - piMultiTask.getPunchInDoneCount();
 
         // 固定计算
-        if (PunchInExtraMethodEnum.FIXED.equals(punchInMultiTask.getExtraMethod())) {
-            return extractCount * punchInMultiTask.getExtraPoints();
+        if (PunchInExtraMethodEnum.FIXED.equals(piMultiTask.getExtraMethod())) {
+            return extractCount * piMultiTask.getExtraPoints();
         }
 
         // 区间计算
-        if (PunchInExtraMethodEnum.INTERVAL.equals(punchInMultiTask.getExtraMethod())
-            && !CollectionUtils.isEmpty(punchInMultiTaskExtList)) {
+        if (PunchInExtraMethodEnum.INTERVAL.equals(piMultiTask.getExtraMethod())
+            && !CollectionUtils.isEmpty(piMultiTaskExtList)) {
             // 额外积分
             int extraPoints = 0;
             // 第二轮标志
@@ -323,9 +367,9 @@ public class SettleManagerImpl implements ISettleManager {
             // 上一轮的值
             int prevInitialValue = 0;
             // punchInMultiTaskExtList 根据InitialValue倒序排列
-            punchInMultiTaskExtList.sort(Comparator.comparing(PunchInMultiTaskExt::getInitialValue).reversed());
+            piMultiTaskExtList.sort(Comparator.comparing(PiMultiTaskExt::getInitialValue).reversed());
 
-            for (PunchInMultiTaskExt punchInTaskExt : punchInMultiTaskExtList) {
+            for (PiMultiTaskExt punchInTaskExt : piMultiTaskExtList) {
                 // 比较结果
                 int compareValue = Integer.compare(extractCount, punchInTaskExt.getInitialValue());
                 // 如果连续日期小于initialValue，则跳过
@@ -354,18 +398,18 @@ public class SettleManagerImpl implements ISettleManager {
     /**
      * 计算多任务连续打卡积分
      * 
-     * @param punchInMultiTask 多任务打卡信息
-     * @param punchInMultiTaskExtList 多任务打卡拓展信息
-     * @param punchInStatus 状态信息
+     * @param piMultiTask 多任务打卡信息
+     * @param piMultiTaskExtList 多任务打卡拓展信息
+     * @param piStatus 状态信息
      * @return
      */
 
-    private int calculateConsecutivePointsInMultiTask(PunchInMultiTask punchInMultiTask,
-        List<PunchInMultiTaskExt> punchInMultiTaskExtList, PunchInStatus punchInStatus) {
+    private int calculateConsecutivePointsInMultiTask(PiMultiTask piMultiTask,
+                                                      List<PiMultiTaskExt> piMultiTaskExtList, PiStatus piStatus) {
         // 没有启用多任务积分计算、或是连续打卡状态为中断、或是没有拓展信息 则不进行计算
-        if (CommonEnableStatusEnum.DISABLED.equals(punchInMultiTask.getTaskPointsStatus())
-            || ConsecutiveStatusEnum.INTERRUPTED.equals(punchInStatus.getConsecutiveStatus())
-            || CollectionUtils.isEmpty(punchInMultiTaskExtList)) {
+        if (CommonEnableStatusEnum.DISABLED.equals(piMultiTask.getTaskPointsStatus())
+            || ConsecutiveStatusEnum.INTERRUPTED.equals(piStatus.getTaskContinueStatus())
+            || CollectionUtils.isEmpty(piMultiTaskExtList)) {
             return 0;
         }
 
@@ -376,11 +420,11 @@ public class SettleManagerImpl implements ISettleManager {
         // 上一轮的值
         int prevInitialValue = 0;
         // punchInMultiTaskExtList 根据InitialValue倒序排列
-        punchInMultiTaskExtList.sort(Comparator.comparing(PunchInMultiTaskExt::getInitialValue).reversed());
+        piMultiTaskExtList.sort(Comparator.comparing(PiMultiTaskExt::getInitialValue).reversed());
 
-        for (PunchInMultiTaskExt punchInTaskExt : punchInMultiTaskExtList) {
+        for (PiMultiTaskExt punchInTaskExt : piMultiTaskExtList) {
             // 比较结果
-            int compareValue = punchInStatus.getConsecutiveDay().compareTo(punchInTaskExt.getInitialValue());
+            int compareValue = piStatus.getTaskContinueDay().compareTo(punchInTaskExt.getInitialValue());
             // 如果连续日期小于initialValue，则跳过
             if (compareValue == -1) {
                 continue;
@@ -391,7 +435,7 @@ public class SettleManagerImpl implements ISettleManager {
             if (secondRound) {
                 tempExtraCount = prevInitialValue - punchInTaskExt.getInitialValue();
             } else if (compareValue >= 0) {
-                tempExtraCount = punchInStatus.getConsecutiveDay() - punchInTaskExt.getInitialValue() + 1;
+                tempExtraCount = piStatus.getTaskContinueDay() - punchInTaskExt.getInitialValue() + 1;
                 secondRound = true;
             }
             // 计算积分

src/main/java/com/punchsettle/server/service/manager/impl/StatPiTaskWeekServiceImpl.java

@@ -0,0 +1,46 @@
+package com.punchsettle.server.service.manager.impl;
+
+import com.punchsettle.server.atomic.entity.StatPiTaskWeek;
+import com.punchsettle.server.atomic.mapper.StatPiTaskWeekMapper;
+import com.punchsettle.server.atomic.service.IStatPiTaskWeekService;
+import com.punchsettle.server.common.utils.Assert;
+import com.punchsettle.server.pojo.punchIn.StatPiTaskWeekQuery;
+import com.punchsettle.server.utiis.WeekendUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import tk.mybatis.mapper.weekend.Weekend;
+import tk.mybatis.mapper.weekend.WeekendCriteria;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * @author tyuio
+ * @version 1.0.0
+ * @date 2025/4/15 17:09
+ * @description 打卡任务周数据统计 service
+ */
+@Slf4j
+@Service
+public class StatPiTaskWeekServiceImpl implements IStatPiTaskWeekService {
+
+    @Autowired
+    private StatPiTaskWeekMapper statPiTaskWeekMapper;
+
+    @Override
+    public List<StatPiTaskWeek> queryByCondition(StatPiTaskWeekQuery statPiTaskWeekQuery) {
+        Assert.isNull(statPiTaskWeekQuery);
+
+        Weekend<StatPiTaskWeek> weekend = WeekendUtils.createExcludeAuditFields(StatPiTaskWeek.class);
+        WeekendCriteria<StatPiTaskWeek, Object> criteria = weekend.weekendCriteria();
+        if (!CollectionUtils.isEmpty(statPiTaskWeekQuery.getTaskUniqueIds())) {
+            criteria.andIn(StatPiTaskWeek::getTaskUniqueId, statPiTaskWeekQuery.getTaskUniqueIds());
+        }
+        if (Objects.nonNull(statPiTaskWeekQuery.getStatsTime())) {
+            criteria.andEqualTo(StatPiTaskWeek::getStatTime, statPiTaskWeekQuery.getStatsTime());
+        }
+        return statPiTaskWeekMapper.selectByExample(weekend);
+    }
+}

src/main/java/com/punchsettle/server/task/PunchInCoreTask.java

@@ -1,38 +1,38 @@
 package com.punchsettle.server.task;
 
-import com.punchsettle.server.atomic.entity.PunchInMultiTask;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskExt;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskHistory;
-import com.punchsettle.server.atomic.entity.PunchInMultiTaskRela;
-import com.punchsettle.server.atomic.entity.PunchInStatsMonth;
-import com.punchsettle.server.atomic.entity.PunchInStatsWeek;
-import com.punchsettle.server.atomic.entity.PunchInStatus;
-import com.punchsettle.server.atomic.entity.PunchInTask;
-import com.punchsettle.server.atomic.entity.PunchInTaskExt;
-import com.punchsettle.server.atomic.entity.PunchInTaskHistory;
-import com.punchsettle.server.atomic.service.IPunchInMultiTaskExtService;
-import com.punchsettle.server.atomic.service.IPunchInMultiTaskHistoryService;
-import com.punchsettle.server.atomic.service.IPunchInMultiTaskRelaService;
-import com.punchsettle.server.atomic.service.IPunchInMultiTaskService;
-import com.punchsettle.server.atomic.service.IPunchInStatsMonthService;
-import com.punchsettle.server.atomic.service.IPunchInStatsWeekService;
-import com.punchsettle.server.atomic.service.IPunchInStatusService;
-import com.punchsettle.server.atomic.service.IPunchInTaskExtService;
-import com.punchsettle.server.atomic.service.IPunchInTaskHistoryService;
-import com.punchsettle.server.atomic.service.IPunchInTaskService;
+import com.punchsettle.server.atomic.entity.PiMultiTask;
+import com.punchsettle.server.atomic.entity.PiMultiTaskExt;
+import com.punchsettle.server.atomic.entity.PiMultiTaskHistory;
+import com.punchsettle.server.atomic.entity.PiMultiTaskRela;
+import com.punchsettle.server.atomic.entity.StatPiTaskMonth;
+import com.punchsettle.server.atomic.entity.StatPiTaskWeek;
+import com.punchsettle.server.atomic.entity.PiStatus;
+import com.punchsettle.server.atomic.entity.PiTask;
+import com.punchsettle.server.atomic.entity.PiTaskExt;
+import com.punchsettle.server.atomic.entity.PiTaskHistory;
+import com.punchsettle.server.atomic.service.IPiMultiTaskExtService;
+import com.punchsettle.server.atomic.service.IPiMultiTaskHistoryService;
+import com.punchsettle.server.atomic.service.IPiMultiTaskRelaService;
+import com.punchsettle.server.atomic.service.IPiMultiTaskService;
+import com.punchsettle.server.atomic.service.IStatPiTaskMonthService;
+import com.punchsettle.server.atomic.service.IStatPiTaskWeekService;
+import com.punchsettle.server.atomic.service.IPiStatusService;
+import com.punchsettle.server.atomic.service.IPiTaskExtService;
+import com.punchsettle.server.atomic.service.IPiTaskHistoryService;
+import com.punchsettle.server.atomic.service.IPiTaskService;
 import com.punchsettle.server.constant.ArchiveStatusEnum;
 import com.punchsettle.server.constant.PunchInStatusEnum;
-import com.punchsettle.server.pojo.punchIn.PunchInMultiTaskExtQuery;
-import com.punchsettle.server.pojo.punchIn.PunchInMultiTaskHistoryQuery;
-import com.punchsettle.server.pojo.punchIn.PunchInMultiTaskQuery;
+import com.punchsettle.server.pojo.punchIn.PiMultiTaskExtQuery;
+import com.punchsettle.server.pojo.punchIn.PiMultiTaskHistoryQuery;
+import com.punchsettle.server.pojo.punchIn.PiMultiTaskQuery;
 import com.punchsettle.server.pojo.punchIn.PunchInSettleDto;
-import com.punchsettle.server.pojo.punchIn.PunchInStatsMonthQuery;
-import com.punchsettle.server.pojo.punchIn.PunchInStatsWeekQuery;
-import com.punchsettle.server.pojo.punchIn.PunchInStatusQuery;
-import com.punchsettle.server.pojo.punchIn.PunchInTaskDto;
-import com.punchsettle.server.pojo.punchIn.PunchInTaskExtQuery;
-import com.punchsettle.server.pojo.punchIn.PunchInTaskHistoryQuery;
-import com.punchsettle.server.pojo.punchIn.PunchInTaskQuery;
+import com.punchsettle.server.pojo.punchIn.PiStatsMonthQuery;
+import com.punchsettle.server.pojo.punchIn.StatPiTaskWeekQuery;
+import com.punchsettle.server.pojo.punchIn.PiStatusQuery;
+import com.punchsettle.server.pojo.punchIn.PiTaskDto;
+import com.punchsettle.server.pojo.punchIn.PiTaskExtQuery;
+import com.punchsettle.server.pojo.punchIn.PiTaskHistoryQuery;
+import com.punchsettle.server.pojo.punchIn.PiTaskQuery;
 import com.punchsettle.server.service.manager.ICalendarManager;
 import com.punchsettle.server.service.manager.IPunchInManager;
 import com.punchsettle.server.service.manager.ISettleManager;
@@ -98,34 +98,34 @@ public class PunchInCoreTask {
     // }
 
     @Autowired
-    private IPunchInTaskService punchInTaskService;
+    private IPiTaskService punchInTaskService;
 
     @Autowired
-    private IPunchInTaskExtService punchInTaskExtService;
+    private IPiTaskExtService punchInTaskExtService;
 
     @Autowired
-    private IPunchInTaskHistoryService punchInTaskHistoryService;
+    private IPiTaskHistoryService punchInTaskHistoryService;
 
     @Autowired
-    private IPunchInStatsMonthService punchInStatsMonthService;
+    private IStatPiTaskMonthService punchInStatsMonthService;
 
     @Autowired
-    private IPunchInStatsWeekService punchInStatsWeekService;
+    private IStatPiTaskWeekService punchInStatsWeekService;
 
     @Autowired
-    private IPunchInStatusService punchInStatusService;
+    private IPiStatusService punchInStatusService;
 
     @Autowired
-    private IPunchInMultiTaskService punchInMultiTaskService;
+    private IPiMultiTaskService punchInMultiTaskService;
 
     @Autowired
-    private IPunchInMultiTaskExtService punchInMultiTaskExtService;
+    private IPiMultiTaskExtService punchInMultiTaskExtService;
 
     @Autowired
-    private IPunchInMultiTaskHistoryService punchInMultiTaskHistoryService;
+    private IPiMultiTaskHistoryService punchInMultiTaskHistoryService;
 
     @Autowired
-    private IPunchInMultiTaskRelaService punchInMultiTaskRelaService;
+    private IPiMultiTaskRelaService punchInMultiTaskRelaService;
 
     @Autowired
     private ICalendarManager calendarManager;
@@ -133,51 +133,51 @@ public class PunchInCoreTask {
     public void manual(List<Long> userIds, String punchInDateStr) {
         List<PunchInSettleDto> punchInSettleData = getPunchInSettleData(userIds, punchInDateStr);
 
-        List<PunchInTaskHistory> updatePunchInTaskHistories = new ArrayList<>(punchInSettleData.size());
-        List<PunchInMultiTaskHistory> updatePunchInMultiTaskHistories = new ArrayList<>(punchInSettleData.size());
+        List<PiTaskHistory> updatePunchInTaskHistories = new ArrayList<>(punchInSettleData.size());
+        List<PiMultiTaskHistory> updatePunchInMultiTaskHistories = new ArrayList<>(punchInSettleData.size());
         for (PunchInSettleDto punchInSettle : punchInSettleData) {
             // 单任务处理部分
-            for (PunchInTaskDto punchInTaskDto : punchInSettle.getPunchInTaskDtoList()) {
-                PunchInTaskHistory updatePunchInTaskHistory = new PunchInTaskHistory();
-                updatePunchInTaskHistory.setId(punchInTaskDto.getPunchInTaskHistory().getId());
-                updatePunchInTaskHistory.setPunchInStatus(PunchInStatusEnum.UNDONE);
+            for (PiTaskDto piTaskDto : punchInSettle.getPiTaskDtoList()) {
+                PiTaskHistory updatePiTaskHistory = new PiTaskHistory();
+                updatePiTaskHistory.setId(piTaskDto.getPiTaskHistory().getId());
+                updatePiTaskHistory.setPunchInStatus(PunchInStatusEnum.UNDONE);
 
                 // 判断打卡状态
-                PunchInStatusEnum punchInStatusResult = punchInManager.judgePunchInStatusInTask(punchInTaskDto.getPunchInTask(), punchInTaskDto.getPunchInTaskHistory());
-                punchInSettle.getPunchInMultiTaskHistory().setPunchInStatus(punchInStatusResult);
-                updatePunchInTaskHistory.setPunchInStatus(punchInStatusResult);
+                PunchInStatusEnum punchInStatusResult = punchInManager.judgePunchInStatusInTask(piTaskDto.getPiTask(), piTaskDto.getPiTaskHistory());
+                punchInSettle.getPiMultiTaskHistory().setPunchInStatus(punchInStatusResult);
+                updatePiTaskHistory.setPunchInStatus(punchInStatusResult);
 
                 // TODO 要判断并设置结算状态
                 // 计算积分
-                int taskPoints = settleManager.calculatePointsInTask(punchInTaskDto.getPunchInTask(), punchInTaskDto.getPunchInTaskExtList(),
-                        punchInTaskDto.getPunchInTaskHistory(), punchInTaskDto.getPunchInStatsWeek(),
-                        punchInTaskDto.getPunchInStatsMonth(), punchInTaskDto.getPunchInStatus());
-                updatePunchInTaskHistory.setSettlePoints(taskPoints);
+                int taskPoints = settleManager.calculatePointsInTask(piTaskDto.getPiTask(), piTaskDto.getPiTaskExtList(),
+                        piTaskDto.getPiTaskHistory(), piTaskDto.getStatPiTaskWeek(),
+                        piTaskDto.getStatPiTaskMonth(), piTaskDto.getPiStatus());
+                updatePiTaskHistory.setSettlePoints(taskPoints);
 
                 // TODO 要设置结算任务执行ID
 
                 // 还有其他的要设置
-                updatePunchInTaskHistory.setSettleTaskHistoryId(punchInTaskDto.getPunchInTask().getId());
-                updatePunchInTaskHistories.add(updatePunchInTaskHistory);
+                updatePiTaskHistory.setSettleTaskHistoryId(piTaskDto.getPiTask().getId());
+                updatePunchInTaskHistories.add(updatePiTaskHistory);
             }
 
             // 多任务处理部分
-            PunchInMultiTaskHistory updatePunchInMultiTaskHistory = new PunchInMultiTaskHistory();
+            PiMultiTaskHistory updatePiMultiTaskHistory = new PiMultiTaskHistory();
 
             // 判断多任务打卡状态并设置
-            PunchInStatusEnum punchInStatusEnumResult = punchInManager.judgePunchInStatusInMultiTask(punchInSettle.getPunchInMultiTask(),
+            PunchInStatusEnum punchInStatusEnumResult = punchInManager.judgePunchInStatusInMultiTask(punchInSettle.getPiMultiTask(),
                     punchInSettle.getRelaPunchInTaskHistories());
-            punchInSettle.getPunchInMultiTaskHistory().setPunchInStatus(punchInStatusEnumResult);
-            updatePunchInMultiTaskHistory.setPunchInStatus(punchInStatusEnumResult);
+            punchInSettle.getPiMultiTaskHistory().setPunchInStatus(punchInStatusEnumResult);
+            updatePiMultiTaskHistory.setPunchInStatus(punchInStatusEnumResult);
 
-            int multiTaskPoints = settleManager.calculatePointsInMultiTask(punchInSettle.getPunchInMultiTask(),
-                    punchInSettle.getPunchInMultiTaskExtList(), punchInSettle.getPunchInMultiTaskHistory(),
-                    punchInSettle.getPunchInStatusInMultiTask());
-            updatePunchInMultiTaskHistory.setSettlePoints(multiTaskPoints);
+            int multiTaskPoints = settleManager.calculatePointsInMultiTask(punchInSettle.getPiMultiTask(),
+                    punchInSettle.getPiMultiTaskExtList(), punchInSettle.getPiMultiTaskHistory(),
+                    punchInSettle.getPiMultiTask());
+            updatePiMultiTaskHistory.setSettlePoints(multiTaskPoints);
 
             // TODO 要判断并设置结算状态
             // TODO 要设置结算任务执行ID
-            updatePunchInMultiTaskHistories.add(updatePunchInMultiTaskHistory);
+            updatePunchInMultiTaskHistories.add(updatePiMultiTaskHistory);
         }
 
         punchInTaskHistoryService.batchUpdate(updatePunchInTaskHistories);
@@ -195,131 +195,131 @@ public class PunchInCoreTask {
         LocalDate punchInDate = LocalDate.parse(punchInDateStr);
 
         // 获取多任务信息，用户ID-多任务关联
-        PunchInMultiTaskQuery punchInMultiTaskQuery = new PunchInMultiTaskQuery();
-        punchInMultiTaskQuery.setMultiTaskTaskStatus(ArchiveStatusEnum.ACTIVE);
-        punchInMultiTaskQuery.setUserIds(userIds);
-        List<PunchInMultiTask> punchInMultiTasks = punchInMultiTaskService.queryByCondition(punchInMultiTaskQuery);
-        Map<Long, PunchInMultiTask> punchInMultiTaskMap = punchInMultiTasks.stream().collect(Collectors.toMap(PunchInMultiTask::getUserId, Function.identity(), (key1, key2) -> key1));
+        PiMultiTaskQuery piMultiTaskQuery = new PiMultiTaskQuery();
+        piMultiTaskQuery.setMultiTaskTaskStatus(ArchiveStatusEnum.ACTIVE);
+        piMultiTaskQuery.setUserIds(userIds);
+        List<PiMultiTask> piMultiTasks = punchInMultiTaskService.queryByCondition(piMultiTaskQuery);
+        Map<Long, PiMultiTask> punchInMultiTaskMap = piMultiTasks.stream().collect(Collectors.toMap(PiMultiTask::getUserId, Function.identity(), (key1, key2) -> key1));
 
         // 多任务ID
-        Set<Long> multiTaskIds = punchInMultiTasks.stream().map(PunchInMultiTask::getId).collect(Collectors.toSet());
+        Set<Long> multiTaskIds = piMultiTasks.stream().map(PiMultiTask::getId).collect(Collectors.toSet());
         // 多任务唯一ID
-        Set<Long> multiTaskUniqueIds = punchInMultiTasks.stream().map(PunchInMultiTask::getMultiTaskUniqueId).collect(Collectors.toSet());
+        Set<Long> multiTaskUniqueIds = piMultiTasks.stream().map(PiMultiTask::getUniqueId).collect(Collectors.toSet());
 
         // 获取多任务拓展信息，多任务ID-多任务拓展关联
-        PunchInMultiTaskExtQuery punchInMultiTaskExtQuery = new PunchInMultiTaskExtQuery();
-        punchInMultiTaskExtQuery.setMultiTaskIds(multiTaskIds);
-        List<PunchInMultiTaskExt> punchInMultiTaskExtList = punchInMultiTaskExtService.queryByCondition(punchInMultiTaskExtQuery);
-        Map<Long, List<PunchInMultiTaskExt>> punchInMultiTaskExtMap = punchInMultiTaskExtList.stream().collect(Collectors.groupingBy(PunchInMultiTaskExt::getMultiTaskId));
+        PiMultiTaskExtQuery piMultiTaskExtQuery = new PiMultiTaskExtQuery();
+        piMultiTaskExtQuery.setMultiTaskIds(multiTaskIds);
+        List<PiMultiTaskExt> piMultiTaskExtList = punchInMultiTaskExtService.queryByCondition(piMultiTaskExtQuery);
+        Map<Long, List<PiMultiTaskExt>> punchInMultiTaskExtMap = piMultiTaskExtList.stream().collect(Collectors.groupingBy(PiMultiTaskExt::getMultiTaskId));
 
         // 获取多任务打卡历史信息，多任务唯一ID-多任务打卡历史关联
-        PunchInMultiTaskHistoryQuery punchInMultiTaskHistoryQuery = new PunchInMultiTaskHistoryQuery();
-        punchInMultiTaskHistoryQuery.setPunchInMultiTaskUniqueIds(multiTaskUniqueIds);
-        punchInMultiTaskHistoryQuery.setPunchInDate(punchInDateStr);
-        List<PunchInMultiTaskHistory> punchInMultiTaskHistories = punchInMultiTaskHistoryService.queryByCondition(punchInMultiTaskHistoryQuery);
-        Map<Long, PunchInMultiTaskHistory> punchInMultiTaskHistoryMap = punchInMultiTaskHistories.stream().collect(Collectors.toMap(PunchInMultiTaskHistory::getPunchInMultiTaskUniqueId, Function.identity(), (key1, key2)->key1));
+        PiMultiTaskHistoryQuery piMultiTaskHistoryQuery = new PiMultiTaskHistoryQuery();
+        piMultiTaskHistoryQuery.setPunchInMultiTaskUniqueIds(multiTaskUniqueIds);
+        piMultiTaskHistoryQuery.setPunchInDate(punchInDateStr);
+        List<PiMultiTaskHistory> punchInMultiTaskHistories = punchInMultiTaskHistoryService.queryByCondition(piMultiTaskHistoryQuery);
+        Map<Long, PiMultiTaskHistory> punchInMultiTaskHistoryMap = punchInMultiTaskHistories.stream().collect(Collectors.toMap(PiMultiTaskHistory::getMultiTaskUniqueId, Function.identity(), (key1, key2)->key1));
 
         // 打卡任务状态，用户ID-打卡状态关联
-        PunchInStatusQuery punchInStatusQuery = new PunchInStatusQuery();
-        punchInStatusQuery.setUserIds(userIds);
-        List<PunchInStatus> punchInStatusList = punchInStatusService.queryByCondition(punchInStatusQuery);
-        Map<Long, List<PunchInStatus>> punchInStatusMap = punchInStatusList.stream().collect(Collectors.groupingBy(PunchInStatus::getUserId));
+        PiStatusQuery piStatusQuery = new PiStatusQuery();
+        piStatusQuery.setUserIds(userIds);
+        List<PiStatus> piStatusList = punchInStatusService.queryByCondition(piStatusQuery);
+        Map<Long, List<PiStatus>> punchInStatusMap = piStatusList.stream().collect(Collectors.groupingBy(PiStatus::getUserId));
 
         // 多任务关联打卡任务，多任务ID-多任务关联打卡任务关联
-        List<PunchInMultiTaskRela> punchInMultiTaskRelaList = punchInMultiTaskRelaService.queryByMultiTaskId(multiTaskIds);
-        Map<Long, List<PunchInMultiTaskRela>> punchInMultiTaskRelaMap = punchInMultiTaskRelaList.stream().collect(Collectors.groupingBy(PunchInMultiTaskRela::getPunchInMultiTaskId));
+        List<PiMultiTaskRela> piMultiTaskRelaList = punchInMultiTaskRelaService.queryByMultiTaskId(multiTaskIds);
+        Map<Long, List<PiMultiTaskRela>> punchInMultiTaskRelaMap = piMultiTaskRelaList.stream().collect(Collectors.groupingBy(PiMultiTaskRela::getPunchInMultiTaskId));
 
         // 获取打卡记录，用户ID-打卡记录关联
-        PunchInTaskHistoryQuery punchInTaskHistoryQuery = new PunchInTaskHistoryQuery();
-        punchInTaskHistoryQuery.setPunchInDate(punchInDateStr);
-        punchInTaskHistoryQuery.setUserIds(userIds);
-        List<PunchInTaskHistory> punchInTaskHistories = punchInTaskHistoryService.queryByCondition(punchInTaskHistoryQuery);
-        Map<Long, List<PunchInTaskHistory>> punchInTaskHistoryMap = punchInTaskHistories.stream().collect(Collectors.groupingBy(PunchInTaskHistory::getUserId));
+        PiTaskHistoryQuery piTaskHistoryQuery = new PiTaskHistoryQuery();
+        piTaskHistoryQuery.setPunchInDate(punchInDateStr);
+        piTaskHistoryQuery.setUserIds(userIds);
+        List<PiTaskHistory> punchInTaskHistories = punchInTaskHistoryService.queryByCondition(piTaskHistoryQuery);
+        Map<Long, List<PiTaskHistory>> punchInTaskHistoryMap = punchInTaskHistories.stream().collect(Collectors.groupingBy(PiTaskHistory::getUserId));
 
         // 打卡任务唯一ID
-        Set<Long> punchInTaskUniqueIdList = punchInTaskHistories.stream().map(PunchInTaskHistory::getPunchInTaskUniqueId).collect(Collectors.toSet());
+        Set<Long> punchInTaskUniqueIdList = punchInTaskHistories.stream().map(PiTaskHistory::getPunchInTaskUniqueId).collect(Collectors.toSet());
 
         // 获取打卡任务信息，打卡任务唯一ID-打卡任务关联
-        PunchInTaskQuery punchInTaskQuery = new PunchInTaskQuery();
-        punchInTaskQuery.setTaskStatus(ArchiveStatusEnum.ACTIVE);
-        punchInTaskQuery.setTaskUniqueIds(punchInTaskUniqueIdList);
-        List<PunchInTask> punchInTasks = punchInTaskService.queryByCondition(punchInTaskQuery);
-        Map<Long, PunchInTask> punchInTaskMap = punchInTasks.stream().collect(Collectors.toMap(PunchInTask::getTaskUniqueId, Function.identity(), (key1, key2) -> key1));
+        PiTaskQuery piTaskQuery = new PiTaskQuery();
+        piTaskQuery.setTaskStatus(ArchiveStatusEnum.ACTIVE);
+        piTaskQuery.setTaskUniqueIds(punchInTaskUniqueIdList);
+        List<PiTask> piTasks = punchInTaskService.queryByCondition(piTaskQuery);
+        Map<Long, PiTask> punchInTaskMap = piTasks.stream().collect(Collectors.toMap(PiTask::getUniqueId, Function.identity(), (key1, key2) -> key1));
 
         // 打卡任务ID
-        Set<Long> punchInTaskIds = punchInTasks.stream().map(PunchInTask::getId).collect(Collectors.toSet());
+        Set<Long> punchInTaskIds = piTasks.stream().map(PiTask::getId).collect(Collectors.toSet());
 
         // 获取打卡任务拓展表，打卡任务ID-打卡任务拓展关联
-        PunchInTaskExtQuery punchInTaskExtQuery = new PunchInTaskExtQuery();
-        punchInTaskExtQuery.setPunchInTaskIds(punchInTaskIds);
-        List<PunchInTaskExt> punchInTaskExtList = punchInTaskExtService.queryByCondition(punchInTaskExtQuery);
-        Map<Long, List<PunchInTaskExt>> punchInTaskExtGroupList = punchInTaskExtList.stream().collect(Collectors.groupingBy(PunchInTaskExt::getPunchInTaskId));
+        PiTaskExtQuery piTaskExtQuery = new PiTaskExtQuery();
+        piTaskExtQuery.setPunchInTaskIds(punchInTaskIds);
+        List<PiTaskExt> piTaskExtList = punchInTaskExtService.queryByCondition(piTaskExtQuery);
+        Map<Long, List<PiTaskExt>> punchInTaskExtGroupList = piTaskExtList.stream().collect(Collectors.groupingBy(PiTaskExt::getPunchInTaskId));
 
         // 获取打卡任务周数据统计，打卡任务唯一ID-打卡任务周数据统计关联
-        PunchInStatsWeekQuery punchInStatsWeekQuery = new PunchInStatsWeekQuery();
-        punchInStatsWeekQuery.setTaskUniqueIds(punchInTaskUniqueIdList);
-        punchInStatsWeekQuery.setStatsTime(DateUtils.getYearWeek(punchInDate));
-        List<PunchInStatsWeek> punchInStatsWeekList = punchInStatsWeekService.queryByCondition(punchInStatsWeekQuery);
-        Map<Long, PunchInStatsWeek> punchInStatsWeekMap = punchInStatsWeekList.stream().collect(Collectors.toMap(PunchInStatsWeek::getTaskUniqueId, Function.identity(), (key1, key2)->key1));
+        StatPiTaskWeekQuery statPiTaskWeekQuery = new StatPiTaskWeekQuery();
+        statPiTaskWeekQuery.setTaskUniqueIds(punchInTaskUniqueIdList);
+        statPiTaskWeekQuery.setStatsTime(DateUtils.getYearWeek(punchInDate));
+        List<StatPiTaskWeek> statPiTaskWeekList = punchInStatsWeekService.queryByCondition(statPiTaskWeekQuery);
+        Map<Long, StatPiTaskWeek> punchInStatsWeekMap = statPiTaskWeekList.stream().collect(Collectors.toMap(StatPiTaskWeek::getTaskUniqueId, Function.identity(), (key1, key2)->key1));
 
         // 获取打卡任务月数据统计，打卡任务唯一ID-打卡任务月数据统计关联
-        PunchInStatsMonthQuery punchInStatsMonthQuery = new PunchInStatsMonthQuery();
-        punchInStatsMonthQuery.setTaskUniqueIds(punchInTaskUniqueIdList);
-        punchInStatsMonthQuery.setStatsTime(DateUtils.getYearMonth(punchInDate));
-        List<PunchInStatsMonth> punchInStatsMonthList = punchInStatsMonthService.queryByCondition(punchInStatsMonthQuery);
-        Map<Long, PunchInStatsMonth> punchInStatsMonthMap = punchInStatsMonthList.stream().collect(Collectors.toMap(PunchInStatsMonth::getTaskUniqueId, Function.identity(), (key1, key2)->key1));
+        PiStatsMonthQuery piStatsMonthQuery = new PiStatsMonthQuery();
+        piStatsMonthQuery.setTaskUniqueIds(punchInTaskUniqueIdList);
+        piStatsMonthQuery.setStatsTime(DateUtils.getYearMonth(punchInDate));
+        List<StatPiTaskMonth> statPiTaskMonthList = punchInStatsMonthService.queryByCondition(piStatsMonthQuery);
+        Map<Long, StatPiTaskMonth> punchInStatsMonthMap = statPiTaskMonthList.stream().collect(Collectors.toMap(StatPiTaskMonth::getTaskUniqueId, Function.identity(), (key1, key2)->key1));
 
         return userIds.stream().map(userId -> {
             PunchInSettleDto punchInSettleDto = new PunchInSettleDto();
             punchInSettleDto.setUserId(userId);
 
-            PunchInMultiTask punchInMultiTask = punchInMultiTaskMap.get(userId);
-            punchInSettleDto.setPunchInMultiTask(punchInMultiTask);
+            PiMultiTask piMultiTask = punchInMultiTaskMap.get(userId);
+            punchInSettleDto.setPiMultiTask(piMultiTask);
 
-            List<PunchInMultiTaskExt> tempPunchInMultiTaskExtList = punchInMultiTaskExtMap.get(punchInMultiTask.getId());
-            punchInSettleDto.setPunchInMultiTaskExtList(tempPunchInMultiTaskExtList);
+            List<PiMultiTaskExt> tempPiMultiTaskExtList = punchInMultiTaskExtMap.get(piMultiTask.getId());
+            punchInSettleDto.setPiMultiTaskExtList(tempPiMultiTaskExtList);
 
-            PunchInMultiTaskHistory punchInMultiTaskHistory = punchInMultiTaskHistoryMap.get(punchInMultiTask.getMultiTaskUniqueId());
-            punchInSettleDto.setPunchInMultiTaskHistory(punchInMultiTaskHistory);
+            PiMultiTaskHistory piMultiTaskHistory = punchInMultiTaskHistoryMap.get(piMultiTask.getUniqueId());
+            punchInSettleDto.setPiMultiTaskHistory(piMultiTaskHistory);
 
-            List<PunchInStatus> tempPunchInStatusList = punchInStatusMap.get(userId);
-            PunchInStatus punchInStatusInMultiTask = tempPunchInStatusList.stream().filter(v -> Objects.nonNull(v.getPunchInMultiTaskUniqueId())).findFirst().get();
-            punchInSettleDto.setPunchInStatusInMultiTask(punchInStatusInMultiTask);
+            List<PiStatus> tempPiStatusList = punchInStatusMap.get(userId);
+            PiStatus punchInStatusInMultiTask = tempPiStatusList.stream().filter(v -> Objects.nonNull(v.getPunchInMultiTaskUniqueId())).findFirst().get();
+            punchInSettleDto.setPiMultiTask(punchInStatusInMultiTask);
 
-            List<PunchInMultiTaskRela> tempPunchInMultiTaskRelaList = punchInMultiTaskRelaMap.get(punchInMultiTask.getId());
-            Set<Long> relaContainTaskIdList = tempPunchInMultiTaskRelaList.stream().map(PunchInMultiTaskRela::getPunchInTaskId).collect(Collectors.toSet());
+            List<PiMultiTaskRela> tempPiMultiTaskRelaList = punchInMultiTaskRelaMap.get(piMultiTask.getId());
+            Set<Long> relaContainTaskIdList = tempPiMultiTaskRelaList.stream().map(PiMultiTaskRela::getPunchInTaskId).collect(Collectors.toSet());
 
-            Map<Long, PunchInStatus> punchInStatusInTaskMap = tempPunchInStatusList.stream().filter(v -> Objects.nonNull(v.getPunchInTaskUniqueId())).collect(Collectors.toMap(PunchInStatus::getPunchInTaskUniqueId, Function.identity(), (key1, key2) -> key1));
+            Map<Long, PiStatus> punchInStatusInTaskMap = tempPiStatusList.stream().filter(v -> Objects.nonNull(v.getPunchInTaskUniqueId())).collect(Collectors.toMap(PiStatus::getPunchInTaskUniqueId, Function.identity(), (key1, key2) -> key1));
 
-            List<PunchInTaskHistory> tempPunchInTaskHistories = punchInTaskHistoryMap.get(userId);
-            List<PunchInTaskDto> punchInTaskDtoList = new ArrayList<>(tempPunchInTaskHistories.size());
-            List<PunchInTaskHistory> relaPunchInTaskHistories = new ArrayList<>(relaContainTaskIdList.size());
-            for (PunchInTaskHistory punchInTaskHistory : tempPunchInTaskHistories) {
-                PunchInTaskDto punchInTaskDto = new PunchInTaskDto();
-                punchInTaskDto.setPunchInTaskHistory(punchInTaskHistory);
+            List<PiTaskHistory> tempPunchInTaskHistories = punchInTaskHistoryMap.get(userId);
+            List<PiTaskDto> piTaskDtoList = new ArrayList<>(tempPunchInTaskHistories.size());
+            List<PiTaskHistory> relaPunchInTaskHistories = new ArrayList<>(relaContainTaskIdList.size());
+            for (PiTaskHistory piTaskHistory : tempPunchInTaskHistories) {
+                PiTaskDto piTaskDto = new PiTaskDto();
+                piTaskDto.setPiTaskHistory(piTaskHistory);
 
-                PunchInTask punchInTask = punchInTaskMap.get(punchInTaskHistory.getPunchInTaskUniqueId());
-                punchInTaskDto.setPunchInTask(punchInTask);
-                if (relaContainTaskIdList.contains(punchInTask.getId())) {
-                    relaPunchInTaskHistories.add(punchInTaskHistory);
+                PiTask piTask = punchInTaskMap.get(piTaskHistory.getPunchInTaskUniqueId());
+                piTaskDto.setPiTask(piTask);
+                if (relaContainTaskIdList.contains(piTask.getId())) {
+                    relaPunchInTaskHistories.add(piTaskHistory);
                 }
 
-                List<PunchInTaskExt> tempPunchInTaskExtList = punchInTaskExtGroupList.get(punchInTask.getId());
-                punchInTaskDto.setPunchInTaskExtList(tempPunchInTaskExtList);
+                List<PiTaskExt> tempPiTaskExtList = punchInTaskExtGroupList.get(piTask.getId());
+                piTaskDto.setPiTaskExtList(tempPiTaskExtList);
 
-                PunchInStatsWeek punchInStatsWeek = punchInStatsWeekMap.get(punchInTask.getTaskUniqueId());
-                punchInTaskDto.setPunchInStatsWeek(punchInStatsWeek);
+                StatPiTaskWeek statPiTaskWeek = punchInStatsWeekMap.get(piTask.getUniqueId());
+                piTaskDto.setStatPiTaskWeek(statPiTaskWeek);
 
-                PunchInStatsMonth punchInStatsMonth = punchInStatsMonthMap.get(punchInTask.getTaskUniqueId());
-                punchInTaskDto.setPunchInStatsMonth(punchInStatsMonth);
+                StatPiTaskMonth statPiTaskMonth = punchInStatsMonthMap.get(piTask.getUniqueId());
+                piTaskDto.setStatPiTaskMonth(statPiTaskMonth);
 
-                PunchInStatus punchInStatus = punchInStatusInTaskMap.get(punchInTaskHistory.getPunchInTaskUniqueId());
-                punchInTaskDto.setPunchInStatus(punchInStatus);
+                PiStatus piStatus = punchInStatusInTaskMap.get(piTaskHistory.getPunchInTaskUniqueId());
+                piTaskDto.setPiStatus(piStatus);
 
-                punchInTaskDtoList.add(punchInTaskDto);
+                piTaskDtoList.add(piTaskDto);
             }
 
-            punchInSettleDto.setPunchInTaskDtoList(punchInTaskDtoList);
+            punchInSettleDto.setPiTaskDtoList(piTaskDtoList);
             punchInSettleDto.setRelaPunchInTaskHistories(relaPunchInTaskHistories);
 
             return punchInSettleDto;