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

package com.izouma.nineth.service;

import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.excel.util.CollectionUtils;
import com.izouma.nineth.config.Constants;
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.MetaAwardTypeEnum;
import com.izouma.nineth.enums.MetaTaskStatus;
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.SecurityUtils;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
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.List;
import java.util.Objects;

@Service
@AllArgsConstructor
@Slf4j
public class MetaTaskToUserNewService {

    private MetaTaskToUserNewRepo metaTaskToUserNewRepo;

    private MetaAtomTaskRepo metaAtomTaskRepo;

    private MetaTaskNewRepo metaTaskNewRepo;

    private MetaPropRepo metaPropRepo;

    private MetaTaskBindRepo metaTaskBindRepo;

    private MetaUserTaskProgressNewRepo metaUserTaskProgressNewRepo;

    private final String PREFIX = "0/";

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

    @Transactional
    public MetaRestResult<Void> autoReceiveTask() {
        Long userId = SecurityUtils.getAuthenticatedUser().getId();
        List<MetaTaskNew> metaTaskNews = metaTaskNewRepo.findUnReceivedAndAutoReceivedTask(userId);
        if (CollectionUtil.isNotEmpty(metaTaskNews)) {
            metaTaskNews.forEach(metaTaskNew -> {
                MetaTaskToUserNew metaTaskToUserNew = new MetaTaskToUserNew();
                metaTaskToUserNew.setUserId(userId);
                metaTaskToUserNew.setTaskId(metaTaskNew.getId());
                // 设置主动领取第一个索引的基础任务
                if (MetaTaskType.MAIN_LINE.equals(metaTaskNew.getType())) {
                    Long atomTaskId = metaTaskBindRepo.findAtomTaskId(metaTaskNew.getId(), MetaTaskType.NODE.toString());
                    if (Objects.nonNull(atomTaskId)) {
                        metaTaskToUserNew.setAtomTaskId(atomTaskId);
                    }
                }
                if (MetaTaskType.BRANCH_LINE.equals(metaTaskNew.getType())) {
                    Long atomTaskId = metaTaskBindRepo.findAtomTaskId(metaTaskNew.getId(), MetaTaskType.BRANCH_LINE.toString());
                    if (Objects.nonNull(atomTaskId)) {
                        metaTaskToUserNew.setAtomTaskId(atomTaskId);
                    }
                }
                if (MetaTaskType.DAILY.equals(metaTaskNew.getType())) {
                    Long atomTaskId = metaTaskBindRepo.findAtomTaskId(metaTaskNew.getId(), MetaTaskType.DAILY.toString());
                    if (Objects.nonNull(atomTaskId)) {
                        metaTaskToUserNew.setAtomTaskId(atomTaskId);
                    }
                }
                MetaRestResult<MetaTaskToUserNew> result = receiveTask(metaTaskToUserNew, false);
                if (Constants.MetaRestCode.success != result.getCode()) {
                    throw new BusinessException(result.getMessage());
                }
            });
            return MetaRestResult.returnSuccess("主动任务领取成功");
        }
        return MetaRestResult.returnSuccess("玩家主动领取任务已经全部领取");
    }

    @Transactional
    public MetaRestResult<MetaTaskToUserNew> receiveTask(MetaTaskToUserNew metaTaskToUserNew, boolean progress) {
        if (Objects.isNull(metaTaskToUserNew.getUserId())) {
            return MetaRestResult.returnError("Illegal parameter : userId can not be null");
        }
        if (Objects.isNull(metaTaskToUserNew.getTaskId())) {
            return MetaRestResult.returnError("Illegal parameter : taskId can not be null");
        }
        if (Objects.isNull(metaTaskToUserNew.getAtomTaskId())) {
            return MetaRestResult.returnError("Illegal parameter : atomTaskId can not be null");
        }
        MetaTaskNew metaTaskNew = metaTaskNewRepo.findByIdAndDel(metaTaskToUserNew.getTaskId(), false);
        MetaServiceResult checkMetaTaskNewResult = checkMetaTaskNew(metaTaskNew);
        if (!checkMetaTaskNewResult.isSuccess()) {
            return MetaRestResult.returnError(checkMetaTaskNewResult.getMessage());
        }
        MetaAtomTask metaAtomTask = metaAtomTaskRepo.findByIdAndDel(metaTaskToUserNew.getAtomTaskId(), false);
        MetaServiceResult checkMetaAtomTaskResult = checkMetaAtomTask(metaAtomTask);
        if (!checkMetaAtomTaskResult.isSuccess()) {
            return MetaRestResult.returnError(checkMetaAtomTaskResult.getMessage());
        }
        // 判断当前玩家是否领取过基础任务
        MetaTaskToUserNew dbMetaTaskToUserNew = metaTaskToUserNewRepo.findByUserIdAndTaskIdAndAtomTaskIdAndDel(metaTaskToUserNew.getUserId(), metaTaskToUserNew.getTaskId(), metaTaskToUserNew.getAtomTaskId(), false);
        if (Objects.nonNull(dbMetaTaskToUserNew)) {
            return MetaRestResult.returnError(String.format("当前用户已在[%S]领取过该任务", dbMetaTaskToUserNew.getGetTime()));
        }
        metaTaskToUserNew.setGetTime(LocalDateTime.now());
        metaTaskToUserNew.setStatus(MetaTaskStatus.PROGRESS);
        metaTaskToUserNew.setChannelId(metaTaskNew.getChannelId());
        if (MetaAwardTypeEnum.META_PROP.equals(metaAtomTask.getAwardType())) {
            MetaProp metaProp = metaPropRepo.findByIdAndDel(Long.parseLong(metaAtomTask.getAwardConfig()), false);
            if (Objects.isNull(metaProp)) {
                return MetaRestResult.returnError(String.format("基础任务[%S]奖励配置的道具不存在", metaTaskToUserNew.getAtomTaskId()));
            }
            metaTaskToUserNew.setMetaProp(metaProp);
        }
        metaTaskToUserNew.setMetaTaskNew(metaTaskNew);
        metaTaskToUserNew.setMetaAtomTask(metaAtomTask);
        MetaTaskToUserNew save = metaTaskToUserNewRepo.save(metaTaskToUserNew);
        save.setMetaTaskNew(metaTaskNew);
        save.setMetaAtomTask(metaAtomTask);
        if (progress) {
            setProgress(save);
        }
        return MetaRestResult.returnSuccess(save);
    }

    public MetaRestResult<List<MetaTaskToUserNew>> findByStatus(Long userId, Long channelId, MetaTaskStatus status) {
        List<MetaTaskToUserNew> metaTaskToUsers = metaTaskToUserNewRepo.findAllByUserIdAndChannelIdAndStatusAndDel(userId, channelId, status, false);
        metaTaskToUsers.forEach(this::setSingleProgress);
        return MetaRestResult.returnSuccess(metaTaskToUsers);
    }

    public MetaRestResult<MetaTaskToUserNew> setSingleProgress(MetaTaskToUserNew metaTaskToUserNew) {
        MetaAtomTask metaAtomTask = metaAtomTaskRepo.findByIdAndDel(metaTaskToUserNew.getAtomTaskId(), false);
        MetaServiceResult checkMetaAtomTaskResult = checkMetaAtomTask(metaAtomTask);
        if (!checkMetaAtomTaskResult.isSuccess()) {
            return MetaRestResult.returnError(checkMetaAtomTaskResult.getMessage());
        }
        metaTaskToUserNew.setMetaAtomTask(metaAtomTask);
        MetaTaskNew metaTaskNew = metaTaskNewRepo.findByIdAndDel(metaTaskToUserNew.getTaskId(), false);
        MetaServiceResult checkMetaTaskNewResult = checkMetaTaskNew(metaTaskNew);
        if (!checkMetaTaskNewResult.isSuccess()) {
            return MetaRestResult.returnError(checkMetaTaskNewResult.getMessage());
        }
        metaTaskToUserNew.setMetaTaskNew(metaTaskNew);
        setProgress(metaTaskToUserNew);
        return MetaRestResult.returnSuccess(metaTaskToUserNew);
    }

    /**
     * 设置任务进度
     *
     * @param metaTaskToUserNew 任务领取信息
     */
    private void setProgress(MetaTaskToUserNew metaTaskToUserNew) {
        MetaAtomTask metaAtomTask = metaTaskToUserNew.getMetaAtomTask();
        List<Long> atomTaskIds = metaTaskBindRepo.findAtomTaskIds(metaTaskToUserNew.getTaskId());
        List<MetaTaskToUserNew> completed = metaTaskToUserNewRepo.findAllByUserIdAndStatusAndDelAndAtomTaskIdIn(metaTaskToUserNew.getUserId(), MetaTaskStatus.COMPLETION, false, atomTaskIds);
        metaTaskToUserNew.setProcess(String.valueOf(completed.size()).concat("/").concat(String.valueOf(atomTaskIds.size())));
        String value = metaAtomTask.getTargetConfig();
        switch (metaAtomTask.getTargetType()) {
            case COLLECT_COLLECTION:
                if (StringUtils.isBlank(value)) {
                    String errMsg = "任务进度显示异常，缺少藏品id配置";
                    log.error(errMsg);
                    metaTaskToUserNew.setAtomTaskProcess(errMsg);
                    break;
                }
                String[] split = value.split(" ");
                List<MetaUserTaskProgressNew> collectCollection = metaUserTaskProgressNewRepo.findAllByMetaTaskToUserNewIdAndDel(metaTaskToUserNew.getId(), false);
                if (CollectionUtils.isEmpty(collectCollection)) {
                    metaTaskToUserNew.setAtomTaskProcess(PREFIX.concat(String.valueOf(split.length)));
                    break;
                }
                metaTaskToUserNew.setAtomTaskProcess(String.valueOf(collectCollection.size()).concat("/").concat(String.valueOf(split.length)));
                break;
            case ON_LINE_TIME_DAILY:
                if (StringUtils.isBlank(value)) {
                    String errMsg = "任务进度显示异常，缺少在线时长配置";
                    log.error(errMsg);
                    metaTaskToUserNew.setAtomTaskProcess(errMsg);
                    break;
                }
                MetaUserTaskProgressNew onLineTimeDaily = metaUserTaskProgressNewRepo.findByMetaTaskToUserNewIdAndDelAndCreatedAtAfter(metaTaskToUserNew.getId(), false, LocalDateTime.now().withHour(0).withMinute(0).withSecond(0));
                if (Objects.isNull(onLineTimeDaily)) {
                    metaTaskToUserNew.setAtomTaskProcess("0");
                    break;
                }
                metaTaskToUserNew.setAtomTaskProcess(onLineTimeDaily.getRemark().concat("/").concat(value));
                break;
            case ACCUMULATE:
                if (StringUtils.isBlank(value)) {
                    String errMsg = "任务进度显示异常，缺少累计任务的数量配置";
                    log.error(errMsg);
                    metaTaskToUserNew.setAtomTaskProcess(errMsg);
                    break;
                }
                List<MetaUserTaskProgressNew> accumulate = metaUserTaskProgressNewRepo.findAllByMetaTaskToUserNewIdAndDel(metaTaskToUserNew.getId(), false);
                if (CollectionUtils.isEmpty(accumulate)) {
                    metaTaskToUserNew.setAtomTaskProcess(PREFIX.concat(value));
                    break;
                }
                metaTaskToUserNew.setAtomTaskProcess(String.valueOf(accumulate.size()).concat("/").concat(value));
                break;
            default:
                String errMsg = "不存在的任务类型";
                log.error(errMsg);
                metaTaskToUserNew.setAtomTaskProcess(errMsg);
                break;
        }
    }

    /**
     * 校验基础任务
     *
     * @param metaAtomTask 基础任务
     * @return result
     */
    private MetaServiceResult checkMetaAtomTask(MetaAtomTask metaAtomTask) {
        if (Objects.isNull(metaAtomTask)) {
            return MetaServiceResult.returnError("基础任务不存在");
        }
        if (StringUtils.isBlank(metaAtomTask.getName())) {
            return MetaServiceResult.returnError(String.format("基础任务[%S]缺少任务名称", metaAtomTask.getId()));
        }
        if (Objects.isNull(metaAtomTask.getDetail())) {
            return MetaServiceResult.returnError(String.format("基础任务[%S]缺少任务详情", metaAtomTask.getId()));
        }
        if (Objects.isNull(metaAtomTask.getTargetType())) {
            return MetaServiceResult.returnError(String.format("基础任务[%S]缺少目标", metaAtomTask.getId()));
        }
        if (StringUtils.isBlank(metaAtomTask.getTargetConfig())) {
            return MetaServiceResult.returnError(String.format("基础任务[%S]缺少目标配置", metaAtomTask.getId()));
        }
        if (Objects.isNull(metaAtomTask.getAwardType())) {
            return MetaServiceResult.returnError(String.format("基础任务[%S]缺少奖励类型", metaAtomTask.getId()));
        }
        if (StringUtils.isBlank(metaAtomTask.getAwardConfig())) {
            return MetaServiceResult.returnError(String.format("基础任务[%S]缺少奖励配置", metaAtomTask.getId()));
        }
        return MetaServiceResult.returnSuccess();
    }

    /**
     * 校验任务
     *
     * @param metaTaskNew 任务信息
     * @return result
     */
    private MetaServiceResult checkMetaTaskNew(MetaTaskNew metaTaskNew) {
        if (Objects.isNull(metaTaskNew)) {
            return MetaServiceResult.returnError("任务不存在");
        }
        if (!metaTaskNew.isPublish()) {
            return MetaServiceResult.returnError("status error : task has not been published");
        }
        if (StringUtils.isBlank(metaTaskNew.getName())) {
            return MetaServiceResult.returnError(String.format("任务[%S]缺少任务名称", metaTaskNew.getId()));
        }
        if (Objects.isNull(metaTaskNew.getDetail())) {
            return MetaServiceResult.returnError(String.format("任务[%S]缺少任务详情", metaTaskNew.getId()));
        }
        if (Objects.isNull(metaTaskNew.getType())) {
            return MetaServiceResult.returnError(String.format("任务[%S]缺少任务类型", metaTaskNew.getId()));
        }
        return MetaServiceResult.returnSuccess();
    }
}