feat: prof user sign

hnqz-upms/hnqz-upms-api/src/main/java/com/qunzhixinxi/hnqz/admin/api/entity/WmTaskSubmissionRule.java

@@ -5,7 +5,6 @@ import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.baomidou.mybatisplus.extension.handlers.FastjsonTypeHandler;
-import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
 import com.qunzhixinxi.hnqz.admin.api.constant.UpmsType;
 import com.qunzhixinxi.hnqz.common.core.constant.enums.CommonFlag;
 import lombok.Data;

hnqz-upms/hnqz-upms-biz/src/main/java/com/qunzhixinxi/hnqz/admin/controller/ApiController.java

@@ -1685,7 +1685,7 @@ public class ApiController {
 	@ApiOperation(value = "签到-新增用户签到表", notes = "新增用户签到表")
 	@SysLog("新增用户签到表")
 	@PostMapping("/saveSignInfo")
-	public R save(@RequestBody WmUserSign wmUserSign) {
+	public R<?> save(@RequestBody WmUserSign wmUserSign) {
 
 		// 重置打卡时间，以系统为准，规避端设备时间不准的问题
 		LocalDateTime now = LocalDateTime.now().plusMinutes(5L);

hnqz-upms/hnqz-upms-biz/src/main/java/com/qunzhixinxi/hnqz/admin/service/WmUserSignService.java

@@ -1,20 +1,3 @@
-/*
- *    Copyright (c) 2018-2025, hnqz All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * Neither the name of the pig4cloud.com developer nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- * Author: hnqz
- */
-
 package com.qunzhixinxi.hnqz.admin.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
@@ -29,5 +12,5 @@ import com.qunzhixinxi.hnqz.common.core.util.R;
  */
 public interface WmUserSignService extends IService<WmUserSign> {
 
-	R saveWmUserSign(WmUserSign wmUserSign);
+	R<?> saveWmUserSign(WmUserSign wmUserSign);
 }

hnqz-upms/hnqz-upms-biz/src/main/java/com/qunzhixinxi/hnqz/admin/service/impl/WmUserSignServiceImpl.java

@@ -5,20 +5,18 @@ import cn.hutool.core.bean.copier.CopyOptions;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.util.StrUtil;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.qunzhixinxi.hnqz.admin.api.constant.UpmsType;
 import com.qunzhixinxi.hnqz.admin.api.entity.WmTaskSubmissionPercentRule;
 import com.qunzhixinxi.hnqz.admin.api.entity.WmTaskSubmissionRule;
 import com.qunzhixinxi.hnqz.admin.api.vo.UserVO;
-import com.qunzhixinxi.hnqz.admin.config.UpmsConfig;
 import com.qunzhixinxi.hnqz.admin.entity.*;
 import com.qunzhixinxi.hnqz.admin.enums.EnableEnum;
-import com.qunzhixinxi.hnqz.admin.enums.LockEnum;
 import com.qunzhixinxi.hnqz.admin.mapper.WmUserSignMapper;
 import com.qunzhixinxi.hnqz.admin.service.*;
 import com.qunzhixinxi.hnqz.common.core.constant.enums.CommonFlag;
+import com.qunzhixinxi.hnqz.common.core.exception.BizException;
 import com.qunzhixinxi.hnqz.common.core.util.R;
 import com.qunzhixinxi.hnqz.common.security.util.SecurityUtils;
 import com.qunzhixinxi.hnqz.common.sequence.sequence.Sequence;
@@ -27,17 +25,17 @@ import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang.StringUtils;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.math.BigDecimal;
-import java.time.Duration;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.temporal.ChronoUnit;
+import java.time.temporal.TemporalAdjusters;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.stream.Collectors;
 
 /**
@@ -62,38 +60,18 @@ public class WmUserSignServiceImpl extends ServiceImpl<WmUserSignMapper, WmUserS
 	private final WmUserSignDetailService wmUserSignDetailService;
 	private final WmTaskSubmissionPercentRuleService wmTaskSubmissionPercentRuleService;
 	private final WmTaskSubmissionRuleService wmTaskSubmissionRuleService;
-	private final UpmsConfig upmsConfig;
 	private final Sequence taskSequence;
 
-	@Override
-	public R saveWmUserSign(WmUserSign wmUserSign) {
-		if (StringUtils.isEmpty(wmUserSign.getPackageId())) {
-			return R.failed("关联积分包异常");
-		}
-		if (StringUtils.isEmpty(wmUserSign.getSignEntId())) {
-			return R.failed("打卡地址异常，请退出后重试");
-		}
+	/**
+	 * 校验基础参数
+	 *
+	 * @param wmUserSign 参数
+	 * @return 任务ID
+	 */
+	private String checkBaseInfo(WmUserSign wmUserSign) {
 
-		if (StringUtils.isEmpty(wmUserSign.getSignEntName())) {
-			return R.failed("打卡地址异常，请退出后重试");
-		}
-		if (StringUtils.isEmpty(wmUserSign.getSignEntType())) {
-			wmUserSign.setSignEntType("1");
-		}
-		WmScorePackage tWmScorePackage = wmScorePackageService.getById(wmUserSign.getPackageId());
-		if (StringUtils.isEmpty(tWmScorePackage.getId())) {
-			log.warn("获取不到积分包：{}", wmUserSign.getPackageId());
-			return R.failed("获取不到积分包");
-		}
-		if (StringUtils.isEmpty(tWmScorePackage.getRuleId())) {
-			log.warn("积分包未配置积分规则：{}", wmUserSign.getPackageId());
-			return R.failed("积分包未配置积分规则");
-		}
-		//TODO 测试通过后删除
-		UserVO sysU = sysUserService.selectUserVoById(SecurityUtils.getUser().getId());
-		if (!sysU.getUserId().toString().equals(wmUserSign.getSignUserid())) {
-			log.warn("客户拜访任务，登录人不符：{}", wmUserSign.getSignUserid());
-			return R.failed("客户拜访任务，登录人不符");
+		if (StringUtils.isEmpty(wmUserSign.getSignEntId()) || StringUtils.isEmpty(wmUserSign.getSignEntName())) {
+			throw new BizException("打卡地址异常，请退出后重试");
 		}
 
 		String taskTypeId;
@@ -104,372 +82,566 @@ public class WmUserSignServiceImpl extends ServiceImpl<WmUserSignMapper, WmUserS
 		} else if ("3".equals(wmUserSign.getSignEntType())) {
 			taskTypeId = "33";
 		} else {
-			return R.failed("拜访类型不存在");
+			throw new BizException("拜访类型不存在");
 		}
-		wmUserSign.setTaskTypeId(taskTypeId);
+
+		return taskTypeId;
+	}
+
+	/**
+	 * 获取并校验积分包信息
+	 *
+	 * @param wmUserSign 签到信息
+	 * @return 积分包信息
+	 */
+	private WmScorePackage checkPkgInfo(WmUserSign wmUserSign) {
+		String pkgId = wmUserSign.getPackageId();
+		if (StringUtils.isEmpty(pkgId)) {
+			throw new BizException("关联积分包异常");
+		}
+
+		WmScorePackage tWmScorePackage = wmScorePackageService.getById(pkgId);
+
+		if (tWmScorePackage == null) {
+			log.warn("获取不到积分包：{}", pkgId);
+			throw new BizException("获取不到积分包");
+		}
+
+		if (StringUtils.isEmpty(tWmScorePackage.getRuleId())) {
+			log.warn("积分包未配置积分规则：{}", pkgId);
+			throw new BizException("积分包未配置积分规则");
+		}
+
+		return tWmScorePackage;
+
+	}
+
+	/**
+	 * 获取用户
+	 *
+	 * @param wmUserSign 打卡信息
+	 * @return 用户vo
+	 */
+	private UserVO checkUser(WmUserSign wmUserSign) {
+
+		Integer userId = SecurityUtils.getUser().getId();
+		if (!userId.toString().equals(wmUserSign.getSignUserid())) {
+			log.warn("客户拜访任务，登录人不符：{}", wmUserSign.getSignUserid());
+			throw new BizException("客户拜访任务，登录人不符");
+		}
+
+		UserVO userVO = sysUserService.selectUserVoById(userId);
 
 		// 校验超过60周岁,不能做任务
-		Map<String, String> checkResult = sysUserService.checkSixtyYearsOld(sysU);
+		Map<String, String> checkResult = sysUserService.checkSixtyYearsOld(userVO);
 		if (CollUtil.isNotEmpty(checkResult) && checkResult.containsKey("OVER")) {
-			throw new RuntimeException(checkResult.get("OVER"));
+			throw new BizException(checkResult.get("OVER"));
 		}
 
-		// 查询任务类型启用状态
+		return userVO;
+	}
+
+	/**
+	 * 校验任务类型规则
+	 *
+	 * @param entId      企业ID
+	 * @param taskTypeId 任务类型ID
+	 */
+	private void checkTaskTypeRules(Integer entId, String taskTypeId) {
 		List<WmTaskSubmissionPercentRule> taskTypeRules = wmTaskSubmissionPercentRuleService.list(Wrappers.<WmTaskSubmissionPercentRule>lambdaQuery()
-				.eq(WmTaskSubmissionPercentRule::getDeptId, sysU.getDeptId())
+				.eq(WmTaskSubmissionPercentRule::getDeptId, entId)
 				.eq(WmTaskSubmissionPercentRule::getSubCategory, UpmsType.TaskSubCategory2.TASK_TYPE_CONFIG));
 		if (CollUtil.isEmpty(taskTypeRules)) {
-			throw new RuntimeException("当前企业未开启该任务！");
+			throw new BizException("当前企业未开启该任务！");
 		}
 		String[] taskTypeIds = taskTypeRules.get(0).getRule().getTaskTypeIds();
 		if (!ArrayUtil.contains(taskTypeIds, taskTypeId)) {
-			throw new RuntimeException("当前企业未开启该任务！");
+			throw new BizException("当前企业未开启该任务！");
 		}
 
-		// 校验任务类型是否启用
+	}
+
+	/**
+	 * 校验百分比规则
+	 * 校验任务百分比限制规则（如果积分包值大于【任务配置】-【百分比限制】配置的起始值，
+	 * 且【任务配置】-【百分比限制】所选的任务类型对应的任务总完成积分值>积分包值*【任务配置】-【百分比限制】配置的百分比，则校验不通过）
+	 *
+	 * @param pkg   积分包
+	 * @param entId 企业ID
+	 */
+	private void checkPercentRule(WmScorePackage pkg, Integer entId) {
+		R<?> checkPercentRuleResult =
+				wmTaskSubmissionPercentRuleService.checkPercentRule(pkg, entId, null, Arrays.asList("5", "6", "33"));
+		if (checkPercentRuleResult.getCode() != 0) {
+			throw new BizException(checkPercentRuleResult.getMsg());
+		}
+
+	}
+
+	/**
+	 * 校验任务类型是否启用
+	 *
+	 * @param taskTypeId 任务类型ID
+	 * @param ruleId     规则ID
+	 */
+	private void checkTaskType(String taskTypeId, String ruleId) {
 		WmTaskType _baseTaskType = wmTaskTypeService.getById(taskTypeId);
-		WmTaskType queryTaskType = new WmTaskType();
-		queryTaskType.setRuleId(tWmScorePackage.getRuleId());
-		queryTaskType.setTaskTypeName(_baseTaskType.getTaskTypeName());
-		queryTaskType.setDelFlag("0");
-		List<WmTaskType> deptTaskTypes = wmTaskTypeService.list(Wrappers.query(queryTaskType));
+		String typeName = _baseTaskType.getTaskTypeName();
+		List<WmTaskType> deptTaskTypes = wmTaskTypeService.list(Wrappers.<WmTaskType>lambdaQuery()
+				.eq(WmTaskType::getRuleId, ruleId)
+				.eq(WmTaskType::getTaskTypeName, typeName)
+				.eq(WmTaskType::getDelFlag, "0"));
 		if (CollUtil.isEmpty(deptTaskTypes)) {
-			throw new RuntimeException(_baseTaskType.getTaskTypeName() + "任务类型不存在");
+			throw new BizException(typeName + "任务类型不存在");
 		}
 		if (EnableEnum.DISABLE.val().equals(deptTaskTypes.get(0).getEnableFlag())) {
-			throw new RuntimeException(_baseTaskType.getTaskTypeName() + "任务类型已停用");
+			throw new BizException(typeName + "任务类型已停用");
+		}
+	}
+
+	/**
+	 * 校验积分限制
+	 *
+	 * @param entId  企业ID
+	 * @param userId 用户ID
+	 */
+	private void checkLimitScore(Integer entId, Integer userId) {
+		String limitValue = "30000";
+		// 查询当前企业配置的积分限制
+		List<WmTaskSubmissionRule> scoreLimitRuleList = wmTaskSubmissionRuleService.list(Wrappers.<WmTaskSubmissionRule>lambdaQuery()
+				.in(WmTaskSubmissionRule::getDeptId, CollUtil.newHashSet(entId, 1))
+				.eq(WmTaskSubmissionRule::getOptFlag, CommonFlag.OptFlag.OK)
+				.eq(WmTaskSubmissionRule::getSubCategory, UpmsType.TaskSubCategory.SCORE_LIMIT));
+
+		// 公共参数配置的
+		String userTaskSubScore = sysPublicParamService.getSysPublicParamKeyToValue("USER_TASK_SUB_SCORE");
+
+		if (CollUtil.isNotEmpty(scoreLimitRuleList)) {
+			Map<Integer, WmTaskSubmissionRule.SubmissionRule> submissionRuleMap = scoreLimitRuleList.stream()
+					.collect(Collectors.toMap(WmTaskSubmissionRule::getDeptId, rules ->
+							BeanUtil.toBean(rules.getRule().get(0), WmTaskSubmissionRule.SubmissionRule.class)));
+			WmTaskSubmissionRule.SubmissionRule submissionRule = submissionRuleMap.containsKey(entId) ? submissionRuleMap.get(entId) : submissionRuleMap.get(1);
+			limitValue = String.valueOf(submissionRule.getFrequency().get(0).get("quantity"));
+		} else if (StrUtil.isNotBlank(userTaskSubScore)) {
+			limitValue = userTaskSubScore;
+		}
+
+		boolean fullFlag = wmTaskService.checkUserTaskSubScore(userId.toString(), limitValue);
+		if (fullFlag) {
+			String info = String.format("每日最多提交%s积分", limitValue);
+			log.warn("系统当前限制积分上限：【{}】，提示：【{}】", limitValue, info);
+			throw new BizException(info);
+		}
+
+	}
+
+	/**
+	 * 获取积分包领取明细
+	 *
+	 * @param pkgId  积分包ID
+	 * @param userId 用户ID
+	 * @return 明细
+	 */
+	private WmScorePackageStatus checkPkgStatus(String pkgId, Integer userId) {
+
+		List<WmScorePackageStatus> statusList = wmScorePackageStatusService.list(Wrappers.<WmScorePackageStatus>lambdaQuery()
+				.eq(WmScorePackageStatus::getUserId, userId.toString())
+				.eq(WmScorePackageStatus::getStatus, "2")
+				.eq(WmScorePackageStatus::getTaskAddFlag, "1")
+				.eq(WmScorePackageStatus::getPackageId, pkgId)
+		);
+		if (CollectionUtils.isEmpty(statusList) || statusList.size() != 1) {
+			log.warn("获取积分包异常，任务保存失败：{}", pkgId);
+			throw new BizException("获取积分包领取异常，任务保存失败");
+		}
+
+		return statusList.get(0);
+	}
+
+	/**
+	 * 保存任务
+	 *
+	 * @param taskTypeId 任务ID
+	 * @param wmUserSign 用户签到信息
+	 * @param userVO     用户信息
+	 * @param pkg        积分包信息
+	 * @return 任务结果
+	 */
+	private WmTask createTask(String taskTypeId, WmUserSign wmUserSign, UserVO userVO, WmScorePackage pkg) {
+
+		// 获取任务类型积分
+		WmTaskType wmTaskType = new WmTaskType();
+		wmTaskType.setTaskTypeName(wmTaskTypeService.getById(taskTypeId).getTaskTypeName());
+		wmTaskType.setRuleId(pkg.getRuleId());
+		int score = wmTaskTypeService.getWmTaskTypeByEnt(wmTaskType);
+		if (score < 0) {
+			throw new BizException("获取任务积分失败");
 		}
 
+		// 保存任务详情
+		WmTaskContent wmTaskContent = new WmTaskContent();
+		wmTaskContent.setTemp1(wmUserSign.getLatitude());
+		wmTaskContent.setTemp2(wmUserSign.getLongitude());
+		wmTaskContent.setTemp3(wmUserSign.getId().toString());
+		wmTaskContentService.save(wmTaskContent);
+
+		// 保存任务
+		WmTask wmTask = new WmTask();
+		wmTask.setTaskFrom("1");
+		wmTask.setTaskUserId(userVO.getUserId().toString());
+		wmTask.setTaskTypeId(taskTypeId);
+		wmTask.setSubmitStatus("0");
+		LocalDateTime now = LocalDateTime.now();
+		wmTask.setCreateTime(now);
+		wmTask.setUpdateTime(now);
+		wmTask.setLookintoDate(now);
+		wmTask.setTaskStatus("2"); //直接提交
+		wmTask.setDrugEntId(userVO.getDrugEntId());
+		wmTask.setDeptId(userVO.getDeptId().toString());
+		wmTask.setScorePackageId(pkg.getId());
+		wmTask.setTaskRuleId(pkg.getTaskRuleId());
+		wmTask.setTaskContentId(wmTaskContent.getId().toString());
+		wmTask.setTaskNumber(taskSequence.nextNo());
+		wmTask.setScore(score);
+
+		// 保存任务
+		wmTaskService.save(wmTask);
+
+		return wmTask;
+	}
+
+
+	/**
+	 * 操作积分包和领包状态， 判断任务完成度
+	 *
+	 * @param tWmScorePackage 积分包
+	 * @param packageStatus   领包记录
+	 * @param userVO          用户信息
+	 * @param taskTypeId      任务ID
+	 * @param wmUserSign      签到信息
+	 */
+	private void operatePkgAndPkgStatus(WmScorePackage tWmScorePackage, WmScorePackageStatus packageStatus, UserVO userVO, String taskTypeId, WmUserSign wmUserSign) {
+
+		//  查询出 审核通过和审核中的任务
+		List<WmTask> wmTaskList = wmTaskService.list(Wrappers.<WmTask>lambdaQuery()
+				.eq(WmTask::getScorePackageId, tWmScorePackage.getId())
+				.ne(WmTask::getTaskStatus, "4")
+				.eq(WmTask::getRealFlag, "0"));
+
+		// 判断定量还是定额 1- 定额   2-定量
+		// 20210120 目前 1-定额  1包1人  2-定量   1包多人
 		if ("1".equals(tWmScorePackage.getPackageType1())) {
-			String limitValue = "30000";
-			// 查询当前企业配置的积分限制
-			List<WmTaskSubmissionRule> scoreLimitRuleList = wmTaskSubmissionRuleService.list(Wrappers.<WmTaskSubmissionRule>lambdaQuery()
-					.in(WmTaskSubmissionRule::getDeptId, CollUtil.newHashSet(sysU.getDeptId(), 1))
-					.eq(WmTaskSubmissionRule::getOptFlag, CommonFlag.OptFlag.OK)
-					.eq(WmTaskSubmissionRule::getSubCategory, UpmsType.TaskSubCategory.SCORE_LIMIT));
-
-			// 公共参数配置的
-			String userTaskSubScore = sysPublicParamService.getSysPublicParamKeyToValue("USER_TASK_SUB_SCORE");
-
-			if (CollUtil.isNotEmpty(scoreLimitRuleList)) {
-				Map<Integer, WmTaskSubmissionRule.SubmissionRule> submissionRuleMap = scoreLimitRuleList.stream()
-						.collect(Collectors.toMap(WmTaskSubmissionRule::getDeptId, rules ->
-								BeanUtil.toBean(rules.getRule().get(0), WmTaskSubmissionRule.SubmissionRule.class)));
-				WmTaskSubmissionRule.SubmissionRule submissionRule = null;
-				if (submissionRuleMap.containsKey(sysU.getDeptId())) {
-					submissionRule = submissionRuleMap.get(sysU.getDeptId());
-				} else {
-					submissionRule = submissionRuleMap.get(1);
+
+			int totalCount = wmTaskList.stream().mapToInt(WmTask::getScore).sum();
+
+			if (totalCount >= tWmScorePackage.getScore()) {
+				tWmScorePackage.setTaskAddFlag("0");
+				packageStatus.setTaskAddFlag("0");
+				wmScorePackageStatusService.updateById(packageStatus);
+			}
+
+		} else if ("2".equals(tWmScorePackage.getPackageType1())) {
+
+			String userIdStr = userVO.getUserId().toString();
+			long count = wmTaskList.stream().filter(item -> item.getTaskUserId().equals(userIdStr)).count();
+
+			if (count - packageStatus.getTaskNum() >= 0) {
+				packageStatus.setTaskAddFlag("0");
+				wmScorePackageStatusService.updateById(packageStatus);
+
+				// 改变大包状态
+				List<WmScorePackageStatus> statusAll = wmScorePackageStatusService.list(Wrappers.<WmScorePackageStatus>lambdaQuery()
+						.eq(WmScorePackageStatus::getPackageId, tWmScorePackage.getId())
+						.eq(WmScorePackageStatus::getStatus, "2")
+						.eq(WmScorePackageStatus::getTaskAddFlag, "0"));
+				if (new BigDecimal(tWmScorePackage.getUserNum()).compareTo(new BigDecimal(statusAll.size())) <= 0) {
+					tWmScorePackage.setTaskAddFlag("0");
 				}
-				limitValue = String.valueOf(submissionRule.getFrequency().get(0).get("quantity"));
-			} else if (StrUtil.isNotBlank(userTaskSubScore)) {
-				limitValue = userTaskSubScore;
 			}
+		}
+
+		tWmScorePackage.setIsConduct("1");
+		wmScorePackageService.updateById(tWmScorePackage);
 
-			Boolean fullFlag = wmTaskService.checkUserTaskSubScore(sysU.getUserId() + "", limitValue);
-			if (fullFlag) {
-				String info = String.format("每日最多提交%s积分", limitValue);
-				log.warn("系统当前限制积分上限：【{}】，提示：【{}】", limitValue, info);
-				return R.failed(1, info);
+		// 如果配置了医院拜访的任务类型模板，则关联保存签到详情
+		if (wmDeptTaskTypeTemplateService.checkDeptIdHospitalTemplate(userVO.getDeptId(), taskTypeId)) {
+			WmUserSignDetail userSignDetail = wmUserSign.getUserSignDetail();
+			if (userSignDetail != null) {
+				userSignDetail.setSignId(wmUserSign.getId());
+				wmUserSignDetailService.save(userSignDetail);
 			}
 		}
+	}
 
+
+	/**
+	 * 校验打卡规则
+	 *
+	 * @param taskTypeId          任务类型
+	 * @param wmUserSign          签到信息
+	 * @param relatedServiceEntId 关联企业
+	 */
+	private void checkByRule(String taskTypeId, WmUserSign wmUserSign, String relatedServiceEntId) {
+		// 校验药店打卡
 		if ("33".equals(taskTypeId)) {
-			// 一个用户，在同一打卡地点，4小时内只能打卡一次
-			int total = this.count(Wrappers.<WmUserSign>lambdaQuery()
-					.eq(WmUserSign::getSignUserid, wmUserSign.getSignUserid())
-					.eq(WmUserSign::getSignEntId, wmUserSign.getSignEntId())
-					.gt(WmUserSign::getSignDate, LocalDateTime.now().minus(4, ChronoUnit.HOURS)));
-			// 一个用户，半小时内只能打卡一次
-			int halfHourTotal = this.count(Wrappers.<WmUserSign>lambdaQuery()
-					.eq(WmUserSign::getSignUserid, wmUserSign.getSignUserid())
-					.gt(WmUserSign::getSignDate, LocalDateTime.now().minus(30, ChronoUnit.MINUTES)));
-			if (total != 0 || halfHourTotal != 0) {
-				log.warn("打卡间隔过短：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
-				return R.failed("打卡间隔过短");
-			}
-		} else {
+			checkPharmacySign(wmUserSign);
+		}
+		// 医院拜访
+		else if ("5".equals(taskTypeId)) {
+			checkHospitalSign(relatedServiceEntId, wmUserSign);
+		}
+		// 商业公司拜访
+		else {
+			checkBizSign(relatedServiceEntId, wmUserSign);
+		}
 
-			List<WmTaskSubmissionRule.SubmissionRule> rules = wmTaskContentService.getTaskSubmissionRule(taskTypeId, tWmScorePackage.getRelatedService());
 
-			int dailyLimit = 0;
-			Map<String, Integer> eachLimitMap = new HashMap<>(2);
+	}
+
+	/**
+	 * 校验药店打卡
+	 *
+	 * @param wmUserSign 签到信息
+	 */
+	private void checkPharmacySign(WmUserSign wmUserSign) {
+		// 一个用户，在同一打卡地点，4小时内只能打卡一次
+		int total = this.count(Wrappers.<WmUserSign>lambdaQuery()
+				.eq(WmUserSign::getSignUserid, wmUserSign.getSignUserid())
+				.eq(WmUserSign::getSignEntId, wmUserSign.getSignEntId())
+				.gt(WmUserSign::getSignDate, LocalDateTime.now().minus(4, ChronoUnit.HOURS)));
+		// 一个用户，半小时内只能打卡一次
+		int halfHourTotal = this.count(Wrappers.<WmUserSign>lambdaQuery()
+				.eq(WmUserSign::getSignUserid, wmUserSign.getSignUserid())
+				.gt(WmUserSign::getSignDate, LocalDateTime.now().minus(30, ChronoUnit.MINUTES)));
+		if (total != 0 || halfHourTotal != 0) {
+			log.warn("打卡间隔过短：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
+			throw new BizException("打卡间隔过短");
+		}
+	}
 
-			if (CollUtil.isNotEmpty(rules)) {
-				// 获取限制
-				for (int i = 0, size = rules.size(); i < size; i++) {
-					Map<String, Object> map = (Map<String, Object>) rules.get(i);
-					WmTaskSubmissionRule.SubmissionRule r = BeanUtil.mapToBean(map, WmTaskSubmissionRule.SubmissionRule.class, true, new CopyOptions());
+	/**
+	 * 校验医院打卡
+	 *
+	 * @param relatedServiceEntId 关联企业
+	 * @param wmUserSign          签到信息
+	 */
+	private void checkHospitalSign(String relatedServiceEntId, WmUserSign wmUserSign) {
 
-					if ("拜访次数上限".equals(r.getManual())) {
-						Object o = r.getFrequency().get(0).get("quantity");
-						dailyLimit = o instanceof String ? Integer.parseInt((String) o) : (int) o;
+		checkCommonSign("5", relatedServiceEntId, wmUserSign);
 
-					}
-					if (r.getManual().startsWith("同一个人")) {
+	}
 
-						r.getFrequency().forEach(f -> {
+	/**
+	 * 校验商业公司打卡
+	 *
+	 * @param relatedServiceEntId 关联企业
+	 * @param wmUserSign          签到信息
+	 */
+	private void checkBizSign(String relatedServiceEntId, WmUserSign wmUserSign) {
+		checkCommonSign("6", relatedServiceEntId, wmUserSign);
+	}
 
-							// 获取数量
-							Object o = f.get("quantity");
-							int limit = o instanceof String ? Integer.parseInt((String) o) : (int) o;
+	/**
+	 * 公用打卡校验
+	 *
+	 * @param taskTypeId          任务类型
+	 * @param relatedServiceEntId 服务企业
+	 * @param wmUserSign          签到信息
+	 */
+	@SuppressWarnings("unchecked")
+	private void checkCommonSign(String taskTypeId, String relatedServiceEntId, WmUserSign wmUserSign) {
+
+		List<WmTaskSubmissionRule.SubmissionRule> rules = wmTaskContentService.getTaskSubmissionRule(taskTypeId, relatedServiceEntId);
+
+		Map<String, Integer> eachLimitMap = new HashMap<>(3);
+		Map<String, Integer> totalLimitMap = new HashMap<>(3);
+
+		if (CollUtil.isNotEmpty(rules)) {
+			// 获取限制
+			for (WmTaskSubmissionRule.SubmissionRule rule : rules) {
+				Map<String, Object> map = (Map<String, Object>) rule;
+				WmTaskSubmissionRule.SubmissionRule r = BeanUtil.mapToBean(map, WmTaskSubmissionRule.SubmissionRule.class, true, new CopyOptions());
+
+				if ("拜访次数上限".equals(r.getManual())) {
+					r.getFrequency().forEach(f -> {
+
+						// 获取数量
+						Object o = f.get("quantity");
+						int limit = o instanceof String ? Integer.parseInt((String) o) : (int) o;
+
+						// 获取单位
+						String timeUnit = (String) f.get("timeUnit");
+
+						// 同一个单位只记录最小的
+						if (totalLimitMap.containsKey(timeUnit)) {
+							Integer l1 = totalLimitMap.get(timeUnit);
+							if (l1 != null && l1 > limit) {
+								totalLimitMap.put(timeUnit, limit);
+							}
+						} else {
+							totalLimitMap.put(timeUnit, limit);
+						}
 
-							// 获取单位
-							String timeUnit = (String) f.get("timeUnit");
+					});
 
-							// 同一个单位只记录最小的
-							if (eachLimitMap.containsKey(timeUnit)) {
-								Integer l1 = eachLimitMap.get(timeUnit);
-								if (l1 != null && l1 > limit) {
-									eachLimitMap.put(timeUnit, limit);
-								}
-							} else {
+				}
+				if (r.getManual().startsWith("同一个人")) {
+
+					r.getFrequency().forEach(f -> {
+
+						// 获取数量
+						Object o = f.get("quantity");
+						int limit = o instanceof String ? Integer.parseInt((String) o) : (int) o;
+
+						// 获取单位
+						String timeUnit = (String) f.get("timeUnit");
+
+						// 同一个单位只记录最小的
+						if (eachLimitMap.containsKey(timeUnit)) {
+							Integer l1 = eachLimitMap.get(timeUnit);
+							if (l1 != null && l1 > limit) {
 								eachLimitMap.put(timeUnit, limit);
 							}
+						} else {
+							eachLimitMap.put(timeUnit, limit);
+						}
 
-						});
+					});
 
-					}
 				}
 			}
+		}
 
-			// 按照最大周期进行查询
-			LocalDateTime now = LocalDateTime.now();
-			LocalDateTime start;
-			boolean isMonth = false;
-			if (eachLimitMap.containsKey("MONTH")) {
-				start = now.minusDays(30L);
-				isMonth = true;
-			} else {
-				start = LocalDateTime.of(now.toLocalDate(), LocalTime.MIN);
-			}
+		// 月度为最大单位，以当前时间所在自然月查询范围, 获取签到记录
+		LocalDateTime now = LocalDateTime.now();
+		LocalDateTime start = now.with(TemporalAdjusters.firstDayOfMonth());
+		List<WmUserSign> signs = this.list(Wrappers.<WmUserSign>lambdaQuery()
+				.eq(WmUserSign::getSignUserid, wmUserSign.getSignUserid())
+				.eq(WmUserSign::getTaskTypeId, taskTypeId)
+				.between(WmUserSign::getSignDate, start, now));
+
+		// 本月未有打卡记录
+		if (CollUtil.isEmpty(signs)) {
+			return;
+		}
 
-			List<WmUserSign> signs = this.list(Wrappers.<WmUserSign>lambdaQuery()
-					.eq(WmUserSign::getSignUserid, wmUserSign.getSignUserid())
-					.eq(WmUserSign::getTaskTypeId, taskTypeId)
-					.between(WmUserSign::getSignDate, start, now));
+		// 校验 同一个人，对同一拜访对象
+		Map<String, List<WmUserSign>> collect = signs.stream().collect(Collectors.groupingBy(WmUserSign::getSignEntId));
+		List<WmUserSign> wmUserSigns = collect.get(wmUserSign.getSignEntId());
+		if (CollUtil.isNotEmpty(wmUserSigns)) {
 
+			int currCount = wmUserSigns.size();
+			Integer monthLimit = eachLimitMap.get("MONTH");
+			if (monthLimit != null && monthLimit <= currCount) {
+				log.warn("超过同一个人，对同一拜访对象打卡每月限制：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
+				throw new BizException("超过同一个人，对同一拜访对象打卡每月限制");
+			}
 
-			// 月度限制
-			if (isMonth) {
+			Integer dailyLimit = eachLimitMap.get("DAY");
+			if (dailyLimit != null) {
+				LocalDateTime todayStart = LocalDateTime.of(now.toLocalDate(), LocalTime.MIN);
+				long dailyCount = wmUserSigns.stream().filter(sign -> sign.getSignDate().isAfter(todayStart)).count();
+				if (dailyLimit <= dailyCount) {
+					log.warn("超过同一个人，对同一拜访对象打卡每日限制：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
+					throw new BizException("超过同一个人，对同一拜访对象打卡每日限制");
+				}
+			}
 
-				Map<String, List<WmUserSign>> collect = signs.stream().collect(Collectors.groupingBy(WmUserSign::getSignEntId));
-				List<WmUserSign> wmUserSigns = collect.get(wmUserSign.getSignEntId());
-				if (CollUtil.isNotEmpty(wmUserSigns)) {
-					int monthLimit = eachLimitMap.get("MONTH");
-					if (monthLimit <= wmUserSigns.size()) {
-						log.warn("超过打卡每月限制：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
-						return R.failed("超过打卡每月限制");
-					}
+			Integer hourLimit = eachLimitMap.get("HOUR");
+			if (hourLimit != null) {
+				LocalDateTime hourStart = now.minusHours(1L);
+				long hourCount = wmUserSigns.stream().filter(sign -> sign.getSignDate().isAfter(hourStart)).count();
+				if (hourLimit <= hourCount) {
+					log.warn("超过同一个人，对同一拜访对象打卡每小时限制：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
+					throw new BizException("超过同一个人，对同一拜访对象打卡每小时限制");
 				}
 			}
+		} else {
+			return;
+		}
 
-			// 获取当日的打卡记录
-			LocalDateTime begin = LocalDateTime.of(now.toLocalDate(), LocalTime.MIN);
-			List<WmUserSign> todaySign = signs.stream().filter(s -> s.getSignDate().isAfter(begin)).collect(Collectors.toList());
 
-			// 没有超过日打卡限制
-			int todaySignQty = CollUtil.isNotEmpty(todaySign) ? todaySign.size() : 0;
-			if (dailyLimit > todaySignQty) {
+		//  校验当日的拜访限制
 
-				Map<String, List<WmUserSign>> collect = todaySign.stream().collect(Collectors.groupingBy(WmUserSign::getSignEntId));
-				List<WmUserSign> wmUserSigns = collect.get(wmUserSign.getSignEntId());
-				if (CollUtil.isNotEmpty(wmUserSigns)) {
-					int eachLimit = eachLimitMap.get("DAY");
-					if (wmUserSigns.size() < eachLimit) {
+		int currCount = signs.size();
+		Integer monthLimit = totalLimitMap.get("MONTH");
+		if (monthLimit != null && monthLimit <= currCount) {
+			log.warn("超过拜访次数上限打卡每月限制：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
+			throw new BizException("超过拜访次数上限打卡每月限制");
+		}
 
-						// 一个用户，在同一打卡地点，4小时内只能打卡一次
-						Optional<LocalDateTime> first = wmUserSigns.stream().map(WmUserSign::getSignDate).filter(sd -> Duration.between(sd, now).toMinutes() <= upmsConfig.getDurationLimit()).findFirst();
+		Integer dailyLimit = totalLimitMap.get("DAY");
+		if (dailyLimit != null) {
+			LocalDateTime todayStart = LocalDateTime.of(now.toLocalDate(), LocalTime.MIN);
+			long dailyCount = wmUserSigns.stream().filter(sign -> sign.getSignDate().isAfter(todayStart)).count();
+			if (dailyLimit <= dailyCount) {
+				log.warn("超过拜访次数上限打卡每日限制：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
+				throw new BizException("超过拜访次数上限打卡每日限制");
+			}
+		}
 
-						if (first.isPresent()) {
-							log.warn("打卡间隔过短：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
-							return R.failed("打卡间隔过短");
-						}
+		Integer hourLimit = totalLimitMap.get("HOUR");
+		if (hourLimit != null) {
+			LocalDateTime hourStart = now.minusHours(1L);
+			long hourCount = wmUserSigns.stream().filter(sign -> sign.getSignDate().isAfter(hourStart)).count();
+			if (hourLimit <= hourCount) {
+				log.warn("超过拜访次数上限打卡每小时限制：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
+				throw new BizException("超过拜访次数上限打卡每小时限制");
+			}
+		}
 
-						// 一个用户，半小时内只能打卡一次
-						Optional<LocalDateTime> first1 = signs.stream().map(WmUserSign::getSignDate).filter(sd -> Duration.between(sd, now).toMinutes() <= upmsConfig.getEachDurationLimit()).findFirst();
+	}
 
-						if (first1.isPresent()) {
-							log.warn("打卡间隔过短：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
-							return R.failed("打卡间隔过短");
-						}
 
+	@Override
+	@Transactional(rollbackFor = Exception.class)
+	public R<?> saveWmUserSign(WmUserSign wmUserSign) {
+		// 校验基础参数
+		String taskTypeId = checkBaseInfo(wmUserSign);
 
-					} else {
-						log.warn("超过每个地点打卡每日限制：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
-						return R.failed("超过每个地点打卡每日限制");
-					}
-				}
+		// 校验积分包
+		WmScorePackage tWmScorePackage = checkPkgInfo(wmUserSign);
 
-			} else {
-				log.warn("超过打卡每日总限制：{} {}", wmUserSign.getSignUserid(), wmUserSign.getSignEntName());
-				return R.failed("超过打卡每日总限制");
-			}
+		// 获取用户
+		UserVO sysU = checkUser(wmUserSign);
 
-		}
+		// 查询任务类型启用状态
+		checkTaskTypeRules(sysU.getDeptId(), taskTypeId);
 
-		// 校验任务百分比限制规则（如果积分包值大于【任务配置】-【百分比限制】配置的起始值，
-		// 且【任务配置】-【百分比限制】所选的任务类型对应的任务总完成积分值>积分包值*【任务配置】-【百分比限制】配置的百分比，则校验不通过）
-		R<?> checkPercentRuleResult =
-				wmTaskSubmissionPercentRuleService.checkPercentRule(tWmScorePackage, SecurityUtils.getUser().getDeptId(), null, Arrays.asList("5", "6", "33"));
-		if (checkPercentRuleResult.getCode() != 0) {
-			throw new RuntimeException(checkPercentRuleResult.getMsg());
-		}
+		// 校验任务类型是否启用
+		checkTaskType(taskTypeId, tWmScorePackage.getRuleId());
 
-		/**
-		 * 积分包领取明细
-		 */
-		WmScorePackageStatus query = new WmScorePackageStatus();
-		query.setUserId(sysU.getUserId() + "");
-		query.setStatus("2");
-		query.setTaskAddFlag("1");
-		query.setPackageId(tWmScorePackage.getId());
-		List<WmScorePackageStatus> statusList = wmScorePackageStatusService.list(Wrappers.lambdaQuery(query));
-		if (CollectionUtils.isEmpty(statusList)) {
-			log.warn("获取积分包异常，任务保存失败9001：{}", tWmScorePackage.getId());
-			return R.failed("获取积分包异常，任务保存失败");
-		}
-		if (statusList.size() != 1) {
-			log.warn("获取积分包异常，任务保存失败9002：{}", tWmScorePackage.getId());
-			return R.failed("获取积分包异常，任务保存失败");
+		// 根据规则校验限制
+		checkByRule(taskTypeId, wmUserSign, tWmScorePackage.getRelatedService());
+
+		// 校验百分比参数
+		checkPercentRule(tWmScorePackage, sysU.getDeptId());
+
+		// 校验积分包领取明细
+		WmScorePackageStatus packageStatus = checkPkgStatus(tWmScorePackage.getId(), sysU.getUserId());
+
+		// 校验积分限制
+		if ("1".equals(tWmScorePackage.getPackageType1())) {
+			checkLimitScore(sysU.getDeptId(), sysU.getUserId());
 		}
-		WmScorePackageStatus scorePackageStatus = statusList.get(0);
 
+		// 设置参数 && 保存
+		if (StringUtils.isEmpty(wmUserSign.getSignEntType())) {
+			wmUserSign.setSignEntType("1");
+		}
+		wmUserSign.setTaskTypeId(taskTypeId);
 		boolean saveSign = this.save(wmUserSign);
 
+		// 保存后续操作
 		if (saveSign) {
 
-			WmTask wmTask = new WmTask();
-			wmTask.setTaskFrom("1");
-			wmTask.setTaskUserId(sysU.getUserId() + "");    //任务提交人
-			if ("1".equals(wmUserSign.getSignEntType())) {
-				wmTask.setTaskTypeId("5");                           //任务类型
-			} else if ("2".equals(wmUserSign.getSignEntType())) {
-				wmTask.setTaskTypeId("6");                           //任务类型
-			} else if ("3".equals(wmUserSign.getSignEntType())) {
-				wmTask.setTaskTypeId("33");
-			}
-			wmTask.setSubmitStatus("0");
-			LocalDateTime localDateTime = LocalDateTime.now();
-			wmTask.setUpdateTime(localDateTime);
-			wmTask.setLookintoDate(localDateTime);       //调研时间
-			wmTask.setCreateTime(localDateTime);
-			wmTask.setTaskStatus("2"); //直接提交
-			wmTask.setDrugEntId(sysU.getDrugEntId());
-
-			wmTask.setDeptId(sysU.getDeptId() + "");
-
-			WmTaskType wmTaskType = new WmTaskType();
-
-			if ("1".equals(wmUserSign.getSignEntType())) {
-				WmTaskType wmTaskType1 = wmTaskTypeService.getById(5);
-				wmTaskType.setTaskTypeName(wmTaskType1.getTaskTypeName());
-			} else if ("2".equals(wmUserSign.getSignEntType())) {
-				WmTaskType wmTaskType1 = wmTaskTypeService.getById(6);
-				wmTaskType.setTaskTypeName(wmTaskType1.getTaskTypeName());
-			} else if ("3".equals(wmUserSign.getSignEntType())) {
-				WmTaskType wmTaskType1 = wmTaskTypeService.getById(33);
-				wmTaskType.setTaskTypeName(wmTaskType1.getTaskTypeName());
-			}
-
-			wmTaskType.setRuleId(tWmScorePackage.getRuleId());
-			int score = wmTaskTypeService.getWmTaskTypeByEnt(wmTaskType);
-			if (score < 0) {
-				return R.failed("获取任务积分失败");
-			}
-			wmTask.setScore(score);
-
-			wmTask.setScorePackageId(tWmScorePackage.getId());
-			wmTask.setTaskRuleId(tWmScorePackage.getTaskRuleId());
-
-			WmTaskContent wmTaskContent = new WmTaskContent();
-			wmTaskContent.setTemp1(wmUserSign.getLatitude());
-			wmTaskContent.setTemp2(wmUserSign.getLongitude());
-			wmTaskContent.setTemp3(wmUserSign.getId() + "");
-			wmTaskContentService.save(wmTaskContent);
-
-			wmTask.setTaskContentId(wmTaskContent.getId() + "");
-			wmTask.setTaskNumber(taskSequence.nextNo());
-			//保存任务
-			wmTaskService.save(wmTask);
-
-			/**
-			 * 判断任务完成度
-			 */
-			WmScorePackage updatePke = wmScorePackageService.getById(tWmScorePackage.getId());
-			if (null != updatePke) {
-				/**
-				 * 查询出 审核通过和审核中的任务
-				 */
-				WmTask taskQuery = new WmTask();
-				taskQuery.setScorePackageId(tWmScorePackage.getId());
-				QueryWrapper<WmTask> taskQueryWrapper = Wrappers.query(taskQuery);
-				taskQueryWrapper.lambda()
-						.ne(WmTask::getTaskStatus, "4")
-						.eq(WmTask::getRealFlag, "0");
-//						.ne(WmTask::getRealFlag, "1");
-				List<WmTask> wmTaskList = wmTaskService.list(taskQueryWrapper);
-				/**
-				 * 判断定量还是定额 1- 定额   2-定量
-				 * 20210120 目前 1-定额  1包1人  2-定量   1包多人
-				 */
-
-				if ("1".equals(updatePke.getPackageType1())) {
-
-					int totalCount = 0;
-					for (WmTask wmtask : wmTaskList) {
-						totalCount += wmtask.getScore();
-					}
-
-					if (totalCount >= updatePke.getScore()) {
-						updatePke.setTaskAddFlag("0");
-						scorePackageStatus.setTaskAddFlag("0");
-						wmScorePackageStatusService.updateById(scorePackageStatus);
-					}
-					wmTask.setType("1");
-
-				} else if ("2".equals(updatePke.getPackageType1())) {
-
-					List<WmTask> userTaskList = wmTaskList.stream().filter(item ->
-							item.getTaskUserId().equals(sysU.getUserId() + "")).collect(Collectors.toList());
-
-					if (userTaskList.size() >= scorePackageStatus.getTaskNum()) {
-						scorePackageStatus.setTaskAddFlag("0");
-						wmScorePackageStatusService.updateById(scorePackageStatus);
-
-						/**
-						 * 改变大包状态
-						 */
-						WmScorePackageStatus queryAll = new WmScorePackageStatus();
-						queryAll.setPackageId(tWmScorePackage.getId());
-						queryAll.setStatus("2");
-						queryAll.setTaskAddFlag("0");
-						List<WmScorePackageStatus> statusAll = wmScorePackageStatusService.
-								list(Wrappers.query(queryAll));
-						if (new BigDecimal(updatePke.getUserNum())
-								.compareTo(new BigDecimal(statusAll.size())) <= 0) {
-							updatePke.setTaskAddFlag("0");
-						}
-					}
+			// 保存任务
+			WmTask task = createTask(taskTypeId, wmUserSign, sysU, tWmScorePackage);
+			task.setType(tWmScorePackage.getPackageType1());
+			// 操作积分包
+			operatePkgAndPkgStatus(tWmScorePackage, packageStatus, sysU, taskTypeId, wmUserSign);
 
-//					if (wmTaskList.size() >= updatePke.getTaskNum()) {
-//						updatePke.setTaskAddFlag("0");
-//					}
-					wmTask.setType("2");
-				}
-				updatePke.setIsConduct("1");
-				wmScorePackageService.updateById(updatePke);
-
-				// 如果配置了医院拜访的任务类型模板，则关联保存签到详情
-				if (wmDeptTaskTypeTemplateService.checkDeptIdHospitalTemplate(sysU.getDeptId(), wmTask.getTaskTypeId())) {
-					WmUserSignDetail userSignDetail = wmUserSign.getUserSignDetail();
-					if (userSignDetail != null) {
-						userSignDetail.setSignId(wmUserSign.getId());
-						wmUserSignDetailService.save(userSignDetail);
-					}
-				}
-				return R.ok(wmTask);
-			}
+			return R.ok(task);
 		}
 
 		return R.failed("签到保存失败");