raex_back/src/main/java/com/izouma/nineth/service/MetaUserTaskProgressNewService.java

package com.izouma.nineth.service;

import com.izouma.nineth.domain.*;
import com.izouma.nineth.dto.MetaRestResult;
import com.izouma.nineth.dto.MetaServiceResult;
import com.izouma.nineth.dto.PageQuery;
import com.izouma.nineth.enums.MetaTaskStatus;
import com.izouma.nineth.enums.MetaTaskTarget;
import com.izouma.nineth.enums.MetaTaskType;
import com.izouma.nineth.exception.BusinessException;
import com.izouma.nineth.repo.*;
import com.izouma.nineth.utils.JpaUtils;
import com.izouma.nineth.utils.MetaUtils;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

@Service
@AllArgsConstructor
public class MetaUserTaskProgressNewService {

    private MetaUserTaskProgressNewRepo metaUserTaskProgressNewRepo;
    private MetaTaskToUserNewRepo       metaTaskToUserNewRepo;
    private MetaAtomTaskRepo            metaAtomTaskRepo;
    private MetaTaskToUserNewService    metaTaskToUserNewService;
    private MetaTaskBindRepo            metaTaskBindRepo;
    private MetaTaskNewRepo             metaTaskNewRepo;

    public Page<MetaUserTaskProgressNew> all(PageQuery pageQuery) {
        return metaUserTaskProgressNewRepo.findAll(JpaUtils.toSpecification(pageQuery, MetaUserTaskProgressNew.class), JpaUtils.toPageRequest(pageQuery));
    }

    @Transactional
    public MetaRestResult<Boolean> metaSave(MetaUserTaskProgressNew metaUserTaskProgressNew) {
        // 校验进度模型参数
        MetaServiceResult result = checkParams(metaUserTaskProgressNew);
        if (!result.isSuccess()) {
            return MetaRestResult.returnError(result.getMessage());
        }
        // 校验任务领取记录
        MetaTaskToUserNew metaTaskToUserNew = metaTaskToUserNewRepo.findByIdAndDel(metaUserTaskProgressNew.getMetaTaskToUserNewId(), false);
        if (Objects.isNull(metaTaskToUserNew)) {
            return MetaRestResult.returnError("无用户领取任务记录");
        }
        if (!metaTaskToUserNew.getStatus().equals(MetaTaskStatus.PROGRESS)) {
            return MetaRestResult.returnError(String.format("状态错误：当前任务状态为[%S]", metaTaskToUserNew.getStatus().getDescription()));
        }
        // 校验任务
        MetaTaskNew metaTaskNew = metaTaskNewRepo.findByIdAndDel(metaTaskToUserNew.getTaskId(), false);
        MetaServiceResult checkMetaTaskNewResult = MetaTaskNew.checkMetaTaskNew(metaTaskNew);
        if (!checkMetaTaskNewResult.isSuccess()) {
            return MetaRestResult.returnError(checkMetaTaskNewResult.getMessage());
        }
        // 校验基础任务
        MetaAtomTask metaAtomTask = metaAtomTaskRepo.findByIdAndDel(metaTaskToUserNew.getAtomTaskId(), false);
        if (Objects.isNull(metaAtomTask)) {
            return MetaRestResult.returnError("基础任务信息为空");
        }
        // 收集藏品类型任务 remark为藏品id 不可为空
        if (metaAtomTask.getTargetType().equals(MetaTaskTarget.COLLECT_COLLECTION) || metaAtomTask.getTargetType().equals(MetaTaskTarget.ON_LINE_TIME_DAILY)) {
            if (StringUtils.isBlank(metaUserTaskProgressNew.getRemark())) {
                return MetaRestResult.returnError(String.format("类型[%S]的任务 remark不可为空", metaAtomTask.getTargetType().getDescription()));
            }
        }
        String value = metaAtomTask.getTargetConfig();
        // 收集藏品任务
        if (metaAtomTask.getTargetType().equals(MetaTaskTarget.COLLECT_COLLECTION)) {
            if (StringUtils.isBlank(value)) {
                return MetaRestResult.returnError("该任务未配置藏品id");
            }
            String[] split = value.split(" ");
            List<String> all = Arrays.asList(split);
            if (!all.contains(metaUserTaskProgressNew.getRemark())) {
                return MetaRestResult.returnError("不在任务规定藏品内");
            }
        }
        // 累计任务
        if (metaAtomTask.getTargetType().equals(MetaTaskTarget.ACCUMULATE)) {
            if (StringUtils.isBlank(value)) {
                return MetaRestResult.returnError("该任务未配置达标次数");
            }
        }
        metaUserTaskProgressNew.setProgressTime(LocalDateTime.now());
        // 在线时长任务 如记录存在则更新remark（每日在线时长） 如不存在则每日首次触发该任务
        if (metaAtomTask.getTargetType().equals(MetaTaskTarget.ON_LINE_TIME_DAILY)) {
            if (StringUtils.isBlank(value)) {
                return MetaRestResult.returnError("在线时长任务未配置达标时间");
            }
            MetaUserTaskProgressNew dbMetaUserTaskProgressNew = metaUserTaskProgressNewRepo.findByMetaTaskToUserNewIdAndDelAndCreatedAtAfter(metaUserTaskProgressNew.getMetaTaskToUserNewId(), false, LocalDateTime.now().withHour(0).withMinute(0).withSecond(0));
            if (Objects.isNull(dbMetaUserTaskProgressNew)) {
                metaUserTaskProgressNewRepo.save(metaUserTaskProgressNew);
            } else {
                int remark = Integer.parseInt(metaUserTaskProgressNew.getRemark()) + Integer.parseInt(dbMetaUserTaskProgressNew.getRemark());
                dbMetaUserTaskProgressNew.setRemark(String.valueOf(remark));
                dbMetaUserTaskProgressNew.setProgressTime(LocalDateTime.now());
                metaUserTaskProgressNewRepo.save(dbMetaUserTaskProgressNew);
            }
        } else {
            // 保存进度
            metaUserTaskProgressNewRepo.save(metaUserTaskProgressNew);
        }
        List<MetaUserTaskProgressNew> metaUserTaskProgressNews = metaUserTaskProgressNewRepo.findAllByMetaTaskToUserNewIdAndDel(metaUserTaskProgressNew.getMetaTaskToUserNewId(), false);
        // 是否完成任务
        switch (metaAtomTask.getTargetType()) {
            case COLLECT_COLLECTION:
                String[] split = value.split(" ");
                List<String> all = Arrays.asList(split);
                List<String> completed = metaUserTaskProgressNews.stream().map(MetaUserTaskProgressNew::getRemark).collect(Collectors.toList());
                if (new HashSet<>(completed).containsAll(all)) {
                    completeTask(metaTaskToUserNew);
                    return MetaRestResult.returnSuccess(true);
                }
                return MetaRestResult.returnSuccess(false);
            case ACCUMULATE:
                if (metaUserTaskProgressNews.size() >= Integer.parseInt(value)) {
                    completeTask(metaTaskToUserNew);
                    return MetaRestResult.returnSuccess(true);
                }
                return MetaRestResult.returnSuccess(false);
            case ON_LINE_TIME_DAILY:
                MetaUserTaskProgressNew dbMetaUserTaskProgressNew = metaUserTaskProgressNewRepo.findByMetaTaskToUserNewIdAndDelAndCreatedAtAfter(metaUserTaskProgressNew.getMetaTaskToUserNewId(), false, LocalDateTime.now().withHour(0).withMinute(0).withSecond(0));
                if (Integer.parseInt(dbMetaUserTaskProgressNew.getRemark()) >= Integer.parseInt(value)) {
                    completeTask(metaTaskToUserNew);
                    return MetaRestResult.returnSuccess(true);
                }
                return MetaRestResult.returnSuccess(false);
            default:
                throw new BusinessException(String.format("不存在的任务类型[%S]", metaAtomTask.getTargetType()));
        }
    }


    /**
     * 完成任务
     *
     * @param metaTaskToUserNew 任务领取记录
     */
    private void completeTask(MetaTaskToUserNew metaTaskToUserNew) {
        metaTaskToUserNew.setFinishTime(LocalDateTime.now());
        metaTaskToUserNew.setStatus(MetaTaskStatus.COMPLETION);
        metaTaskToUserNewRepo.save(metaTaskToUserNew);
        MetaTaskBind metaTaskBind = metaTaskBindRepo.findByTaskIdAndAtomTaskIdAndDel(metaTaskToUserNew.getTaskId(), metaTaskToUserNew.getAtomTaskId(), false);
        // 节点任务完成自动领取下一个节点任务
        if (MetaTaskType.NODE.equals(metaTaskBind.getType())) {
            // 下一个节点任务id
            Long nextAtomTaskId = metaTaskBindRepo.findNextAtomTaskId(metaTaskToUserNew.getTaskId(), metaTaskBind.getAtomTaskIndex());
            if (Objects.isNull(nextAtomTaskId)) {
                return;
            }
            MetaTaskToUserNew next = new MetaTaskToUserNew();
            next.setTaskId(metaTaskToUserNew.getTaskId());
            next.setAtomTaskId(nextAtomTaskId);
            next.setUserId(metaTaskToUserNew.getUserId());
            metaTaskToUserNewService.receiveTask(next, true);
        }

    }

    /**
     * 参数校验
     *
     * @param metaUserTaskProgressNew 待校验参数
     * @return 校验结果
     */
    private MetaServiceResult checkParams(MetaUserTaskProgressNew metaUserTaskProgressNew) {
        if (Objects.nonNull(metaUserTaskProgressNew.getId())) {
            return MetaServiceResult.returnError("Illegal parameter : id must be null");
        }
        if (Objects.isNull(metaUserTaskProgressNew.getMetaTaskToUserNewId())) {
            return MetaServiceResult.returnError("Illegal parameter : metaTaskToUserNewId can not be null");
        }
        if (Objects.isNull(metaUserTaskProgressNew.getUserId())) {
            return MetaServiceResult.returnError("Illegal parameter : userId can not be null");
        }
        MetaServiceResult result = MetaUtils.checkUserExcludeTourist(metaUserTaskProgressNew.getUserId());
        if (!result.isSuccess()) {
            return MetaServiceResult.returnError(result.getMessage());
        }
        // 指定备注唯一，校验是否重复
        if (metaUserTaskProgressNew.isRemarkOnly()) {
            if (StringUtils.isBlank(metaUserTaskProgressNew.getRemark())) {
                return MetaServiceResult.returnError("Illegal parameter : remark can not be null");
            }
            MetaUserTaskProgressNew dbMetaUserTaskProgressNew = metaUserTaskProgressNewRepo.findByMetaTaskToUserNewIdAndRemarkAndDel(metaUserTaskProgressNew.getMetaTaskToUserNewId(), metaUserTaskProgressNew.getRemark(), false);
            if (Objects.nonNull(dbMetaUserTaskProgressNew)) {
                return MetaServiceResult.returnError("重复触发");
            }
        }
        return MetaServiceResult.returnSuccess();
    }
}