first commit

src/main/java/com/budwk/app/task/conn/NutConnectionProvider.java

@@ -0,0 +1,30 @@
+package com.budwk.app.task.conn;
+
+import org.nutz.boot.AppContext;
+import org.nutz.ioc.Ioc;
+import org.quartz.utils.ConnectionProvider;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+public class NutConnectionProvider implements ConnectionProvider {
+    
+    protected DataSource dataSource;
+    protected String iocname = "dataSource";
+
+    public Connection getConnection() throws SQLException {
+        return dataSource.getConnection();
+    }
+
+    public void shutdown() throws SQLException {}
+
+    @SuppressWarnings("deprecation")
+    public void initialize() throws SQLException {
+        if (dataSource != null)
+            return;
+        Ioc ioc = AppContext.getDefault().getIoc();
+        dataSource = ioc.get(DataSource.class, iocname);
+    }
+
+}

src/main/java/com/budwk/app/task/job/SysUserAllRenewJob.java

@@ -0,0 +1,62 @@
+package com.budwk.app.task.job;
+
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.StrUtil;
+import com.budwk.app.base.param.ConditionGroup;
+import com.budwk.app.sys.enums.SysDataUpdateMode;
+import com.budwk.app.sys.models.Sys_user_source;
+import com.budwk.app.sys.param.SysDataUserUpdateParam;
+import com.budwk.app.sys.services.SysDataUserPullService;
+import com.budwk.app.sys.services.SysDataUserUpdateService;
+import lombok.extern.slf4j.Slf4j;
+import org.nutz.dao.Cnd;
+import org.nutz.dao.Dao;
+import org.nutz.ioc.loader.annotation.Inject;
+import org.nutz.ioc.loader.annotation.IocBean;
+import org.nutz.json.Json;
+import org.nutz.lang.util.NutMap;
+import org.quartz.Job;
+import org.quartz.JobDataMap;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+
+import java.util.Date;
+
+/**
+ * 人员全量更新任务
+ */
+@IocBean
+@Slf4j
+public class SysUserAllRenewJob implements Job {
+
+    @Inject
+    private Dao dao;
+    @Inject
+    private SysDataUserPullService sysDataUserPullService;
+    @Inject
+    private SysDataUserUpdateService sysDataUserUpdateService;
+
+    @Override
+    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
+        Date pullTime = sysDataUserPullService.pull();
+        JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
+        NutMap conditionGroupMap = (NutMap)jobDataMap.get("conditionGroup");
+        if(conditionGroupMap == null || conditionGroupMap.isEmpty()){
+            log.error("SysUserAllRenewJob定时任务执行中止，原因：conditionGroup为null");
+        }
+        String conditionGroupStr = Json.toJson(conditionGroupMap).replace("@currentDate", DateUtil.today());
+        ConditionGroup conditionGroup = null;
+        try {
+            conditionGroup = Json.fromJson(ConditionGroup.class, conditionGroupStr);
+        } catch (Exception e) {
+            log.error("SysUserAllRenewJob定时任务执行失败，原因：{}", e.getMessage());
+        }
+
+        SysDataUserUpdateParam param = new SysDataUserUpdateParam();
+        param.setPullTime(DateUtil.formatDateTime(pullTime));
+        param.setUpdateMode(SysDataUpdateMode.ALL.name());
+        param.setConditionGroup(conditionGroup);
+
+        // sysDataUserUpdateService.update(param);
+    }
+}

src/main/java/com/budwk/app/task/job/TestJob.java

@@ -0,0 +1,32 @@
+package com.budwk.app.task.job;
+
+import com.budwk.app.sys.services.SysTaskService;
+import org.nutz.dao.Chain;
+import org.nutz.dao.Cnd;
+import org.nutz.ioc.loader.annotation.Inject;
+import org.nutz.ioc.loader.annotation.IocBean;
+import org.nutz.log.Log;
+import org.nutz.log.Logs;
+import org.quartz.Job;
+import org.quartz.JobDataMap;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+
+/**
+ * Created by Wizzer.cn on 2015/6/27.
+ */
+@IocBean
+public class TestJob implements Job {
+
+    private static final Log log = Logs.get();
+    @Inject
+    protected SysTaskService sysTaskService;
+
+    public void execute(JobExecutionContext context) throws JobExecutionException {
+        JobDataMap data = context.getJobDetail().getJobDataMap();
+        String taskId = context.getJobDetail().getKey().getName();
+        String hi = data.getString("hi");
+        log.info("Test Job hi::" + hi);
+        sysTaskService.update(Chain.make("exeAt", (int) (System.currentTimeMillis() / 1000)).add("exeResult", "执行成功"), Cnd.where("id", "=", taskId));
+    }
+}

src/main/java/com/budwk/app/task/job/club/ClubGeneratePayRecordJob.java

@@ -0,0 +1,60 @@
+package com.budwk.app.task.job.club;
+
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.json.JSONObject;
+import com.budwk.app.web.commons.auth.utils.SecurityUtil;
+import com.budwk.app.zhgh.club.model.ClubPayRecord;
+import com.budwk.app.zhgh.club.model.ClubUser;
+import org.nutz.dao.Cnd;
+import org.nutz.dao.Dao;
+import org.nutz.ioc.loader.annotation.Inject;
+import org.nutz.ioc.loader.annotation.IocBean;
+import org.quartz.Job;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @ClassName ClubGeneratePayRecordJob
+ * @Author JyuHsin
+ * @Date 2026/1/22 16:56
+ * @Version 1.0
+ * @Description 每年的1月1日生成社团成员下年的缴费记录
+ */
+@IocBean
+public class ClubGeneratePayRecordJob implements Job {
+
+	@Inject
+	private Dao dao;
+
+	@Override
+	public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
+		// 当前年份
+		int thisYear = DateUtil.thisYear();
+		// 获取最新的社团成员信息
+		List<ClubUser> clubUserList = dao.query(ClubUser.class, Cnd.NEW());
+		// 生成缴费记录对象
+		List<ClubPayRecord> list = new ArrayList<>();
+		for (ClubUser clubUser : clubUserList) {
+			ClubPayRecord clubPayRecord = new ClubPayRecord();
+			clubPayRecord.setYear(thisYear);
+			clubPayRecord.setClubId(clubUser.getClubId());
+			clubPayRecord.setUserId(clubUser.getUserId());
+			clubPayRecord.setPayed(false);
+
+			JSONObject log = new JSONObject();
+			log.set("operatorUserId", "task");
+			log.set("operatorUserName", "定时任务");
+			log.set("operatorTime", DateUtil.now());
+			log.set("operatorType", "缴费管理-定时任务自动设置");
+			log.set("oldValue", null);
+			log.set("newValue", false);
+			clubPayRecord.setOperateLogs(List.of(log));
+
+			list.add(clubPayRecord);
+		}
+		dao.insert(list);
+	}
+}

src/main/java/com/budwk/app/task/job/fitnesswalk/FitnessWalkAddActivityJob.java

@@ -0,0 +1,196 @@
+package com.budwk.app.task.job.fitnesswalk;
+
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.util.StrUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.budwk.app.sys.models.Sys_task;
+import com.budwk.app.zhgh.activity.fitnesswalk.model.FitnessWalkActivity;
+import com.budwk.app.zhgh.activity.fitnesswalk.model.FitnessWalkActivityRelationProject;
+import com.budwk.app.zhgh.activity.fitnesswalk.service.FitnessWalkCommonService;
+import com.budwk.app.zhgh.activity.fitnesswalk.service.impl.FitnessWalkCommonServiceImpl;
+import com.budwk.app.zhgh.activity.fitnesswalk.utils.WeAppCloudUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.nutz.aop.interceptor.ioc.TransAop;
+import org.nutz.dao.Chain;
+import org.nutz.dao.Cnd;
+import org.nutz.dao.Dao;
+import org.nutz.ioc.Ioc;
+import org.nutz.ioc.aop.Aop;
+import org.nutz.ioc.loader.annotation.IocBean;
+import org.nutz.json.Json;
+import org.nutz.mvc.Mvcs;
+import org.quartz.Job;
+import org.quartz.JobDataMap;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+
+import java.util.Arrays;
+
+/**
+ * @author zhf
+ * @date 2026/4/11 14:01
+ * @description 自动创建活动
+ */
+@IocBean
+@Slf4j
+public class FitnessWalkAddActivityJob implements Job {
+    @Override
+    @Aop(TransAop.READ_COMMITTED)
+    public void execute(JobExecutionContext context) throws JobExecutionException {
+        Ioc ioc = Mvcs.ctx().getDefaultIoc();
+        Dao dao = ioc.get(Dao.class);
+        WeAppCloudUtil weAppCloudUtil = ioc.get(WeAppCloudUtil.class);
+        // Quartz 任务上下文里按接口取 Bean 容易命中 Nutz 的接口实例化异常，这里统一按实现类获取后再走 service 公共方法。
+        FitnessWalkCommonService fitnessWalkCommonService = ioc.get(FitnessWalkCommonServiceImpl.class);
+
+        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
+        String sourceActivityId = getJobString(jobDataMap, "sourceActivityId");
+        String deleteId = getJobString(jobDataMap, "deleteId");
+        long targetDate = getJobLong(jobDataMap, "targetDate");
+
+        try {
+            FitnessWalkActivity sourceActivity = loadSourceActivity(weAppCloudUtil, sourceActivityId);
+            if (sourceActivity == null) {
+                disableCurrentTask(dao, deleteId, sourceActivityId);
+                return;
+            }
+
+            FitnessWalkActivity newActivity = JSON.parseObject(JSON.toJSONString(sourceActivity), FitnessWalkActivity.class);
+            shiftActivityDate(sourceActivity, newActivity, targetDate);
+            resetBranchActivityNameByRelationProject(dao, newActivity, targetDate);
+            long currentTime = System.currentTimeMillis();
+            long normalizedTargetDate = DateUtil.beginOfDay(DateUtil.date(targetDate)).getTime();
+            newActivity.set_id(null);
+            newActivity.setCreatedAt(currentTime);
+            newActivity.setUpdatedAt(currentTime);
+            // 自动复制出的活动补充来源标记，便于后续编辑原活动时识别哪些日期已经真正生成过活动。
+            newActivity.setAutoCreateSourceActivityId(sourceActivityId);
+            newActivity.setAutoCreateTargetDate(normalizedTargetDate);
+
+            JSONObject insertResult = weAppCloudUtil.request(WeAppCloudUtil.CRUD.INSERT,
+                    "db.collection('activity').add({data:" + Json.toJson(newActivity) + "})");
+            if (insertResult.containsKey("id_list") && insertResult.getJSONArray("id_list") != null && !insertResult.getJSONArray("id_list").isEmpty()) {
+                newActivity.set_id(insertResult.getJSONArray("id_list").getString(0));
+            }
+
+            // 自动复制出的活动也要同步刷新缓存，并补齐该活动自身的抽奖任务。
+            fitnessWalkCommonService.addLotteryTask(newActivity);
+            fitnessWalkCommonService.addOrEditDoSaveRedis(newActivity);
+        } catch (Exception e) {
+            log.error("自动连续创建活动失败, sourceActivityId={}", sourceActivityId, e);
+            throw new JobExecutionException(e);
+        } finally {
+            disableCurrentTask(dao, deleteId, sourceActivityId);
+        }
+    }
+
+    /**
+     * Quartz 的 JobDataMap 可能直接存的是 Long、Integer 等对象，不能一律用 getString 读取。
+     * 这里统一兜底转成字符串，避免任务参数类型变化时再次触发 ClassCastException。
+     */
+    private String getJobString(JobDataMap jobDataMap, String key) {
+        Object value = jobDataMap.get(key);
+        return value == null ? null : String.valueOf(value);
+    }
+
+    /**
+     * 定时任务中的日期时间参数既可能是数字，也可能是字符串。
+     * 这里统一兼容处理，确保 targetDate 在测试和正式任务下都能稳定转成时间戳。
+     */
+    private long getJobLong(JobDataMap jobDataMap, String key) {
+        Object value = jobDataMap.get(key);
+        if (value == null) {
+            throw new IllegalArgumentException("定时任务缺少参数:" + key);
+        }
+        if (value instanceof Number) {
+            return ((Number) value).longValue();
+        }
+        return Long.parseLong(String.valueOf(value));
+    }
+
+    /**
+     * 根据原活动ID查询原活动。
+     * 定时任务执行时统一从云库读取最新活动内容，确保复制时拿到的是当前活动的最新配置。
+     */
+    private FitnessWalkActivity loadSourceActivity(WeAppCloudUtil weAppCloudUtil, String sourceActivityId) {
+        JSONObject jsonObject = weAppCloudUtil.request(WeAppCloudUtil.CRUD.QUERY,
+                "db.collection('activity').doc('" + sourceActivityId + "').get()");
+        return jsonObject.getJSONArray("data").stream()
+                .map(item -> JSON.parseObject((String) item, FitnessWalkActivity.class))
+                .findFirst()
+                .orElse(null);
+    }
+
+    /**
+     * 将活动的报名时间和活动时间整体平移到目标日期。
+     * 这里保留原活动的时分秒和时长，仅根据目标日期替换所属自然日。
+     */
+    private void shiftActivityDate(FitnessWalkActivity sourceActivity, FitnessWalkActivity newActivity, long targetDate) {
+        DateTime sourceStartDate = DateUtil.beginOfDay(DateUtil.date(sourceActivity.getStartTime()));
+        DateTime targetStartDate = DateUtil.beginOfDay(DateUtil.date(targetDate));
+        long offsetMillis = targetStartDate.getTime() - sourceStartDate.getTime();
+
+        if (sourceActivity.getApplyTime() != null && sourceActivity.getApplyTime().length == 2) {
+            Long[] applyTime = Arrays.copyOf(sourceActivity.getApplyTime(), 2);
+            applyTime[0] = applyTime[0] + offsetMillis;
+            applyTime[1] = applyTime[1] + offsetMillis;
+            newActivity.setApplyTime(applyTime);
+            newActivity.setApplyStartTime(applyTime[0]);
+            newActivity.setApplyEndTime(applyTime[1]);
+        }
+
+        if (sourceActivity.getTime() != null && sourceActivity.getTime().length == 2) {
+            Long[] time = Arrays.copyOf(sourceActivity.getTime(), 2);
+            time[0] = time[0] + offsetMillis;
+            time[1] = time[1] + offsetMillis;
+            newActivity.setTime(time);
+            newActivity.setStartTime(time[0]);
+            newActivity.setEndTime(time[1]);
+        }
+    }
+
+    /**
+     * 自动连续创建活动时，分活动名称统一取“关联活动配置名称 + 日期前缀”。
+     * 优先读取关联活动配置表中的主活动名称；若当前活动没有配置关联活动，则回退到原分活动名称。
+     */
+    private void resetBranchActivityNameByRelationProject(Dao dao, FitnessWalkActivity newActivity, long targetDate) {
+        if (newActivity == null) {
+            return;
+        }
+        String datePrefix = DateUtil.format(DateUtil.date(targetDate), "yyyy年MM月dd日");
+        String targetName = null;
+        if (StrUtil.isNotBlank(newActivity.getRelationActivityId())) {
+            FitnessWalkActivityRelationProject relationProject = dao.fetch(
+                    FitnessWalkActivityRelationProject.class,
+                    Cnd.where("id", "=", newActivity.getRelationActivityId())
+            );
+            if (relationProject != null && StrUtil.isNotBlank(relationProject.getMasterActivityName())) {
+                targetName = relationProject.getMasterActivityName().trim();
+            }
+        }
+
+        if (StrUtil.isBlank(targetName) && StrUtil.isNotBlank(newActivity.getBranchActivityName())) {
+            targetName = newActivity.getBranchActivityName().trim();
+        }
+        if (StrUtil.isBlank(targetName)) {
+            return;
+        }
+        if (targetName.startsWith(datePrefix)) {
+            newActivity.setBranchActivityName(targetName);
+            return;
+        }
+        newActivity.setBranchActivityName(datePrefix + " " + targetName);
+    }
+
+    /**
+     * 当前任务执行完成后禁用自身，避免同一日期重复创建活动。
+     */
+    private void disableCurrentTask(Dao dao, String deleteId, String sourceActivityId) {
+        dao.update(Sys_task.class, Chain.make("disabled", 1),
+                Cnd.where("data", "like", "%" + deleteId + "%").and("data", "like", "%" + sourceActivityId + "%"));
+    }
+}
+
+

src/main/java/com/budwk/app/task/job/fitnesswalk/FitnessWalkLotteryJob.java

@@ -0,0 +1,203 @@
+package com.budwk.app.task.job.fitnesswalk;
+
+import cn.hutool.core.date.DateUtil;
+import com.budwk.app.sys.models.Sys_task;
+import com.budwk.app.zhgh.activity.fitnesswalk.model.FitnessWalkAwardUser;
+import com.budwk.app.zhgh.activity.fitnesswalk.model.FitnessWalkRaffleUser;
+import lombok.extern.slf4j.Slf4j;
+import org.nutz.aop.interceptor.ioc.TransAop;
+import org.nutz.dao.Chain;
+import org.nutz.dao.Cnd;
+import org.nutz.dao.Dao;
+import org.nutz.dao.Sqls;
+import org.nutz.dao.sql.Sql;
+import org.nutz.dao.util.Daos;
+import org.nutz.dao.util.cri.Static;
+import org.nutz.ioc.Ioc;
+import org.nutz.ioc.aop.Aop;
+import org.nutz.ioc.loader.annotation.IocBean;
+import org.nutz.lang.Strings;
+import org.nutz.lang.random.R;
+import org.nutz.lang.util.NutMap;
+import org.nutz.mvc.Mvcs;
+import org.quartz.Job;
+import org.quartz.JobDataMap;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@IocBean
+@Slf4j
+public class FitnessWalkLotteryJob implements Job {
+
+    @Override
+    @Aop(TransAop.READ_COMMITTED)
+    public void execute(JobExecutionContext context) throws JobExecutionException {
+        Ioc ioc = Mvcs.ctx().getDefaultIoc();
+        Dao dao = ioc.get(Dao.class);
+
+        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
+        String deleteId = jobDataMap.getString("deleteId");
+
+        int lotteryQualificationStep = Integer.parseInt(jobDataMap.getString("lotteryQualificationStep"));
+        int lotteryUserNum = Integer.parseInt(jobDataMap.getString("lotteryUserNum"));
+        String mode = jobDataMap.getString("mode");
+        String activityId = jobDataMap.getString("id");
+        String lotteryQualificationDay = jobDataMap.getString("lotteryQualificationDay");
+
+        String awardName;
+        Date startDate = null;
+        Date endDate = null;
+        if ("custom".equals(mode)) {
+            awardName = jobDataMap.getString("awardName");
+            String startTimeStr = jobDataMap.getString("startDate");
+            String endTimeStr = jobDataMap.getString("endDate");
+            startDate = DateUtil.parse(startTimeStr, "yyyy-MM-dd");
+            endDate = DateUtil.parse(endTimeStr, "yyyy-MM-dd");
+        } else {
+            awardName = null;
+        }
+        List<NutMap> userList = new ArrayList<>();
+
+        if ("custom".equals(mode)) {
+            //查询出符合条件的用户
+            Sql sql = Sqls.create("""
+                    SELECT
+                        u.id,
+                        COALESCE(SUM(sub.step), 0) AS total_steps,
+                        u.loginname,
+                        u.username,
+                        u.unionid,
+                        u.unionname,
+                        u.unitid,
+                        u.unitname,
+                        over3k.standardsDays
+                    FROM
+                        `user` u
+                        LEFT JOIN (
+                            SELECT
+                                userId,
+                                applyDate,
+                                step
+                            FROM
+                                `fitness_walk_step`
+                            WHERE
+                                activityId = @activityId
+                                AND DATE(applyDate) >= @startDate
+                                AND DATE(applyDate) <= @endDate
+                                $lotteryQualificationDaySql
+                            GROUP BY
+                                userId,
+                                applyDate
+                        ) AS sub ON u.id = sub.userId
+                    LEFT JOIN (
+                                SELECT
+                                    userId,
+                                    COUNT(DISTINCT DATE(applyDate)) AS standardsDays
+                                FROM
+                                    `fitness_walk_step`
+                                WHERE
+                                    activityId = @activityId
+                                    AND DATE(applyDate) >= @startDate
+                                    AND DATE(applyDate) <= @endDate
+                                    $lotteryQualificationDaySql
+                                GROUP BY
+                                    userId
+                            ) AS over3k ON u.id = over3k.userId
+                    $whereSql
+                    GROUP BY
+                        u.id,
+                        u.username,
+                        u.loginname,
+                        u.unionname,
+                        u.unitname
+                    HAVING
+                        $stepHavingSql
+                    """);
+            if (Strings.isNotBlank(lotteryQualificationDay)) {
+                sql.setVar("lotteryQualificationDaySql", new Static(" AND step >= '%s' ".formatted(lotteryQualificationStep)));
+                sql.setVar("stepHavingSql", new Static(" over3k.standardsDays >= '%s' ".formatted(lotteryQualificationDay)));
+            } else {
+                sql.setVar("stepHavingSql", new Static(" COALESCE(SUM(sub.step), 0) >= '%s' ".formatted(lotteryQualificationStep)));
+            }
+            sql.setVar("whereSql", new Static(" where u.loginname not in (select loginName from fitness_walk_award_user where activityId = " + activityId + " ) "));
+            sql.setParam("activityId", activityId);
+            sql.setParam("step", lotteryQualificationStep);
+            sql.setParam("startDate", startDate);
+            sql.setParam("endDate", endDate);
+            userList = (List<NutMap>) Daos.query(dao, sql.toString(), Sqls.callback.maps());
+        } else if ("everyday".equals(mode)) {
+            Sql sql = Sqls.create("""
+                    SELECT
+                    	jws.userId AS id,
+                    	u.username,
+                    	u.loginname,
+                    	u.unionid,
+                    	u.unionname,
+                    	u.unitid,
+                    	u.unitname
+                    FROM
+                    	fitness_walk_step jws
+                    	LEFT JOIN `user` u ON u.id = jws.userId
+                    WHERE
+                    	jws.activityId = @activityId
+                    	AND jws.step >= @step
+                    	AND jws.applyDate = @date
+                    """);
+            sql.setParam("activityId", activityId);
+            sql.setParam("step", lotteryQualificationStep);
+            sql.setParam("date", DateUtil.today());
+            userList = (List<NutMap>) Daos.query(dao, sql.toString(), Sqls.callback.maps());
+        }
+
+        // 记录达标人员，表明这些人有资格抽奖
+        List<FitnessWalkRaffleUser> raffleUserList = userList.stream().map(v -> {
+            FitnessWalkRaffleUser raffleUser = new FitnessWalkRaffleUser();
+            raffleUser.setId(R.UU32());
+            raffleUser.setActivityId(activityId);
+            raffleUser.setUserId(v.getString("id"));
+            raffleUser.setLoginName(v.getString("loginname"));
+            raffleUser.setUsername(v.getString("username"));
+            if ("custom".equals(mode)) {
+                raffleUser.setStandardsDays(v.getInt("standardsDays"));
+                raffleUser.setAwardSteps(v.getString("total_steps"));
+            }
+            raffleUser.setIsRaffle(false);
+            return raffleUser;
+        }).collect(Collectors.toList());
+
+        dao.fastInsert(raffleUserList);
+
+        // 随机抽奖，中奖人数为传递过来的 lotteryUserNum
+        Collections.shuffle(userList);
+        List<NutMap> lotteryUserList = userList.stream().limit(lotteryUserNum).collect(Collectors.toList());
+
+        Date finalStartDate = startDate;
+        Date finalEndDate = endDate;
+        List<FitnessWalkAwardUser> awardLists = lotteryUserList.stream().map(v -> {
+            FitnessWalkAwardUser awardUser = new FitnessWalkAwardUser();
+            awardUser.setActivityId(activityId);
+            awardUser.setUserId(v.getString("id"));
+            awardUser.setUsername(v.getString("username"));
+            awardUser.setLoginName(v.getString("loginname"));
+            awardUser.setAwardName(awardName);
+            awardUser.setUnionId(v.getString("unionid"));
+            awardUser.setUnionName(v.getString("unionname"));
+            awardUser.setUnitId(v.getString("unitid"));
+            awardUser.setUnitName(v.getString("unitname"));
+            awardUser.setApplyDate(new Date());
+            awardUser.setStartDate(finalStartDate);
+            awardUser.setEndDate(finalEndDate);
+            awardUser.setAwardSteps(v.getString("total_steps"));
+            return awardUser;
+        }).collect(Collectors.toList());
+        dao.insert(awardLists);
+
+        // 执行完此定时任务后，禁用此定时任务确保不会下次执行
+        dao.update(Sys_task.class, Chain.make("disabled", 1), Cnd.where("data", "like", "%" + deleteId + "%").and("data", "like", "%" + activityId + "%"));
+    }
+}
+
+

src/main/java/com/budwk/app/task/job/holiday/HolidayJob.java

@@ -0,0 +1,54 @@
+package com.budwk.app.task.job.holiday;
+
+import cn.hutool.http.HttpUtil;
+import com.budwk.app.sys.models.SysHoliday;
+import org.nutz.dao.Dao;
+import org.nutz.ioc.loader.annotation.Inject;
+import org.nutz.ioc.loader.annotation.IocBean;
+import org.nutz.json.Json;
+import org.nutz.lang.Lang;
+import org.nutz.lang.util.NutMap;
+import org.quartz.Job;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @Author: JyuHsin
+ * @Date: 2024/6/6 15:16
+ * @Version: v1.0.0
+ * @Description: 获取所有节假日，每年执行一次
+ **/
+@IocBean
+public class HolidayJob implements Job {
+
+    private static final String URL = "https://timor.tech/api/holiday/year?type=Y";
+
+    @Inject
+    private Dao dao;
+
+    @Override
+    public void execute(JobExecutionContext context) throws JobExecutionException {
+        NutMap resMap = Json.fromJson(NutMap.class, HttpUtil.get(URL));
+        if(resMap.getInt("code") == 0) {
+            NutMap holidayMap = resMap.getAs("type", NutMap.class);
+            List<SysHoliday> result = new ArrayList<>();
+            holidayMap.keySet().forEach(k -> {
+                NutMap day = (NutMap) holidayMap.get(k);
+                if(day.getInt("type") == 2) {
+                    SysHoliday h = new SysHoliday();
+                    h.setDay(k);
+                    h.setName(day.getString("name"));
+                    h.setWeek(day.getString("week"));
+                    result.add(h);
+                }
+            });
+            if(Lang.isNotEmpty(result)) {
+                dao.insert(result);
+            }
+        }
+    }
+
+}

src/main/java/com/budwk/app/task/services/TaskPlatformService.java

@@ -0,0 +1,53 @@
+package com.budwk.app.task.services;
+
+import java.util.List;
+
+/**
+ * Created by wizzer on 2018/3/19.
+ */
+public interface TaskPlatformService {
+    /**
+     * 判断任务是否存在
+     *
+     * @param jobName
+     * @param jobGroup
+     * @return
+     */
+    boolean isExist(String jobName, String jobGroup);
+
+    /**
+     * 添加新任务
+     *
+     * @param jobName
+     * @param jobGroup
+     * @param className
+     * @param cron
+     * @param comment
+     * @param dataMap
+     */
+    void add(String jobName, String jobGroup, String className, String cron, String comment, String dataMap);
+
+    /**
+     * 删除任务
+     *
+     * @param jobName
+     * @param jobGroup
+     * @return
+     */
+    boolean delete(String jobName, String jobGroup);
+
+    /**
+     * 清除所有任务
+     */
+    void clear();
+
+    /**
+     * 获取cron表达式最近执行时间
+     *
+     * @param cronExpression
+     * @return
+     */
+    List<String> getCronExeTimes(String cronExpression) throws Exception;
+
+    List<String> getCronExeTimesPlus(String cronExpression) throws Exception;
+}

src/main/java/com/budwk/app/task/services/impl/TaskPlatformServiceImpl.java

@@ -0,0 +1,118 @@
+package com.budwk.app.task.services.impl;
+
+import com.budwk.app.task.services.TaskPlatformService;
+import org.nutz.integration.quartz.QuartzJob;
+import org.nutz.integration.quartz.QuartzManager;
+import org.nutz.ioc.loader.annotation.Inject;
+import org.nutz.ioc.loader.annotation.IocBean;
+import org.quartz.CronExpression;
+import org.quartz.JobKey;
+import org.quartz.TriggerUtils;
+import org.quartz.impl.triggers.CronTriggerImpl;
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * Created by wizzer on 2018/3/19.
+ */
+@IocBean
+public class TaskPlatformServiceImpl implements TaskPlatformService {
+    @Inject
+    private QuartzManager quartzManager;
+
+    /**
+     * 判断任务是否存在
+     *
+     * @param jobName
+     * @param jobGroup
+     * @return
+     */
+    public boolean isExist(String jobName, String jobGroup) {
+        return quartzManager.exist(new JobKey(jobName, jobGroup));
+    }
+
+    /**
+     * 添加新任务
+     *
+     * @param jobName
+     * @param jobGroup
+     * @param className
+     * @param cron
+     * @param comment
+     * @param dataMap
+     */
+    public void add(String jobName, String jobGroup, String className, String cron, String comment, String dataMap) {
+        QuartzJob qj = new QuartzJob();
+        qj.setJobName(jobName);
+        qj.setJobGroup(jobGroup);
+        qj.setClassName(className);
+        qj.setCron(cron);
+        qj.setComment(comment);
+        qj.setDataMap(dataMap);
+        quartzManager.add(qj);
+    }
+
+    /**
+     * 删除任务
+     *
+     * @param jobName
+     * @param jobGroup
+     * @return
+     */
+    public boolean delete(String jobName, String jobGroup) {
+        QuartzJob qj = new QuartzJob();
+        qj.setJobName(jobName);
+        qj.setJobGroup(jobGroup);
+        return quartzManager.delete(qj);
+    }
+
+    /**
+     * 清除任务
+     */
+    public void clear() {
+        quartzManager.clear();
+    }
+
+    /**
+     * 获取cron表达式最近执行时间
+     *
+     * @param cronExpression
+     * @return
+     */
+    public List<String> getCronExeTimes(String cronExpression) throws Exception {
+        List<String> list = new ArrayList<>();
+        CronTriggerImpl cronTriggerImpl = new CronTriggerImpl();
+        cronTriggerImpl.setCronExpression(cronExpression);
+        Calendar calendar = Calendar.getInstance();
+        Date now = calendar.getTime();
+        calendar.add(2, 1);
+        List<Date> dates = TriggerUtils.computeFireTimesBetween(cronTriggerImpl, null, now, calendar.getTime());
+        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        for (int i = 0; i < dates.size() && i <= 4; ++i) {
+            list.add(dateFormat.format((Date) dates.get(i)));
+        }
+        return list;
+    }
+
+
+    @Override
+    public List<String> getCronExeTimesPlus(String cronExpression) throws Exception {
+        // 创建一个列表来存储执行时间
+        List<String> executionTimes = new ArrayList<>();
+        // 创建 CronTriggerImpl 对象，并设置 cron 表达式
+        CronTriggerImpl cronTrigger = new CronTriggerImpl();
+        cronTrigger.setCronExpression(new CronExpression(cronExpression));
+        // 计算未来的执行时间
+        List<Date> nextExecutionTimes = TriggerUtils.computeFireTimes(cronTrigger, null, 5);
+        // 格式化日期并添加到执行时间列表中
+        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        for (Date date : nextExecutionTimes) {
+            executionTimes.add(dateFormat.format(date));
+        }
+        return executionTimes;
+    }
+}