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

package com.izouma.nineth.service;

import com.alibaba.excel.util.CollectionUtils;
import com.izouma.nineth.domain.MetaProp;
import com.izouma.nineth.domain.MetaTask;
import com.izouma.nineth.domain.MetaTaskToUser;
import com.izouma.nineth.domain.MetaUserTaskProgress;
import com.izouma.nineth.dto.MetaRestResult;
import com.izouma.nineth.dto.PageQuery;
import com.izouma.nineth.enums.MetaTaskStatus;
import com.izouma.nineth.repo.MetaPropRepo;
import com.izouma.nineth.repo.MetaTaskRepo;
import com.izouma.nineth.repo.MetaTaskToUserRepo;
import com.izouma.nineth.repo.MetaUserTaskProgressRepo;
import com.izouma.nineth.utils.JpaUtils;
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 java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Objects;

@Service
@AllArgsConstructor
@Slf4j
public class MetaTaskToUserService {

    private MetaTaskToUserRepo       metaTaskToUserRepo;
    private MetaTaskRepo             metaTaskRepo;
    private MetaUserTaskProgressRepo metaUserTaskProgressRepo;
    private MetaPropRepo             metaPropRepo;

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

    public MetaRestResult<MetaTaskToUser> receiveTask(MetaTaskToUser metaTaskToUser) {
        if (Objects.nonNull(metaTaskToUser.getId())) {
            return MetaRestResult.returnError("Illegal parameter : id must be null");
        }
        if (Objects.isNull(metaTaskToUser.getTaskId())) {
            return MetaRestResult.returnError("Illegal parameter : taskId can not be null");
        }
        if (Objects.isNull(metaTaskToUser.getUserId())) {
            return MetaRestResult.returnError("Illegal parameter : userId can not be null");
        }
        MetaTask metaTask = metaTaskRepo.findByIdAndDel(metaTaskToUser.getTaskId(), false);
        if (Objects.isNull(metaTask)) {
            return MetaRestResult.returnError(String.format("根据任务id[%S]查询不到任务详情", metaTaskToUser.getTaskId()));
        }
        if (!metaTask.isPublish()) {
            return MetaRestResult.returnError("status error : task has not been published");
        }
        if (metaTask.isFinish()) {
            return MetaRestResult.returnError("status error : task has been finished");
        }
        if (StringUtils.isBlank(metaTask.getName())) {
            return MetaRestResult.returnError(String.format("任务[%S]缺少任务名称", metaTaskToUser.getTaskId()));
        }
        if (Objects.isNull(metaTask.getType())) {
            return MetaRestResult.returnError(String.format("任务[%S]缺少任务类型", metaTaskToUser.getTaskId()));
        }
        if (Objects.isNull(metaTask.getAwardType())) {
            return MetaRestResult.returnError(String.format("任务[%S]缺少任务奖励类型", metaTaskToUser.getTaskId()));
        }
        if (Objects.isNull(metaTask.getDetail())) {
            return MetaRestResult.returnError(String.format("任务[%S]缺少任务详情", metaTaskToUser.getTaskId()));
        }
        // 判断当前玩家是否领取过任务
        MetaTaskToUser dbMetaTaskToUser = metaTaskToUserRepo.findByUserIdAndTaskIdAndDel(metaTaskToUser.getUserId(), metaTaskToUser.getTaskId(), false);
        if (Objects.nonNull(dbMetaTaskToUser)) {
            return MetaRestResult.returnError(String.format("当前用户已在[%S]领取过该任务[%S]", dbMetaTaskToUser.getGetTime(), metaTask.getName()));
        }
        if (Objects.nonNull(metaTask.getAwardPic())) {
            metaTaskToUser.setAwardPic(metaTask.getAwardPic());
        }
        if (metaTask.getGoldNum() > 0) {
            metaTaskToUser.setGoldNum(metaTask.getGoldNum());
        }
        if (Objects.nonNull(metaTask.getMetaPropId())) {
            metaTaskToUser.setMetaPropId(metaTask.getMetaPropId());
        }
        metaTaskToUser.setTaskName(metaTask.getName());
        metaTaskToUser.setTaskType(metaTask.getType());
        metaTaskToUser.setDetail(metaTask.getDetail());
        metaTaskToUser.setGetTime(LocalDateTime.now());
        metaTaskToUser.setAwardType(metaTask.getAwardType());
        metaTaskToUser.setStatus(MetaTaskStatus.PROGRESS);
        metaTaskToUser.setChannelId(metaTask.getChannelId());
        MetaTaskToUser save = metaTaskToUserRepo.save(metaTaskToUser);
        setProgress(save);
        return MetaRestResult.returnSuccess(save);
    }


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

    public MetaRestResult<MetaTaskToUser> findProgress(Long id) {
        MetaTaskToUser metaTaskToUser = metaTaskToUserRepo.findByIdAndDel(id, false);
        if (Objects.isNull(metaTaskToUser)) {
            return MetaRestResult.returnError(String.format("根据id[%S]查询不到用户领取记录", id));
        }
        setProgress(metaTaskToUser);
        return MetaRestResult.returnSuccess(metaTaskToUser);
    }


    /**
     * 设置任务进度
     *
     * @param metaTaskToUser 参数
     */
    private void setProgress(MetaTaskToUser metaTaskToUser) {
        if (Objects.nonNull(metaTaskToUser.getMetaPropId())) {
            MetaProp metaProp = metaPropRepo.findByIdAndDel(metaTaskToUser.getMetaPropId(), false);
            if (Objects.nonNull(metaProp)) {
                metaTaskToUser.setMetaProp(metaProp);
            }
        }
        MetaTask metaTask = metaTaskRepo.findByIdAndDel(metaTaskToUser.getTaskId(), false);
        if (Objects.isNull(metaTask)) {
            log.error("任务信息为空");
        }
        String value = metaTask.getValue();
        String PREFIX = "0/";
        switch (metaTaskToUser.getTaskType()) {
            case COLLECT_COLLECTION:
                if (StringUtils.isBlank(value)) {
                    String errMsg = "任务进度显示异常，缺少藏品id配置";
                    log.error(errMsg);
                    metaTaskToUser.setProcess(errMsg);
                    break;
                }
                String[] split = value.split(" ");
                List<MetaUserTaskProgress> collectCollection = metaUserTaskProgressRepo.findAllByMetaTaskToUserIdAndDel(metaTaskToUser.getId(), false);
                if (CollectionUtils.isEmpty(collectCollection)) {
                    metaTaskToUser.setProcess(PREFIX.concat(String.valueOf(split.length)));
                    break;
                }
                metaTaskToUser.setProcess(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);
                    metaTaskToUser.setProcess(errMsg);
                    break;
                }
                MetaUserTaskProgress onLineTimeDaily = metaUserTaskProgressRepo.findByMetaTaskToUserIdAndDelAndCreatedAtAfter(metaTaskToUser.getId(), false, LocalDateTime.now().withHour(0).withMinute(0).withSecond(0));
                if (Objects.isNull(onLineTimeDaily)) {
                    metaTaskToUser.setProcess(PREFIX.concat(value));
                    break;
                }
                metaTaskToUser.setProcess(onLineTimeDaily.getRemark().concat("/").concat(value));
                break;
            case ACCUMULATE:
                if (StringUtils.isBlank(value)) {
                    String errMsg = "任务进度显示异常，缺少累计任务的数量配置";
                    log.error(errMsg);
                    metaTaskToUser.setProcess(errMsg);
                    break;
                }
                List<MetaUserTaskProgress> accumulate = metaUserTaskProgressRepo.findAllByMetaTaskToUserIdAndDel(metaTaskToUser.getId(), false);
                if (CollectionUtils.isEmpty(accumulate)) {
                    metaTaskToUser.setProcess(PREFIX.concat(value));
                    break;
                }
                metaTaskToUser.setProcess(String.valueOf(accumulate.size()).concat("/").concat(value));
                break;
            default:
                break;
        }
    }


    /**
     * 计算累计签到天数
     *
     * @param value            开始日期配置
     * @param metaTaskToUserId 用户领取任务记录id
     * @return 累计签到天数
     */
    private int countSignIn(String value, Long metaTaskToUserId) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDateTime startTime = LocalDate.parse(value, formatter).atStartOfDay();
        LocalDateTime endTime = LocalDateTime.now();
        List<MetaUserTaskProgress> metaUserTaskProgresses = metaUserTaskProgressRepo.findAllByMetaTaskToUserIdAndDelAndCreatedAtBetweenOrderByCreatedAtDesc(metaTaskToUserId, false, startTime, endTime);
        int num = 0;
        if (CollectionUtils.isEmpty(metaUserTaskProgresses)) {
            return num;
        }
        int i = 0;
        for (MetaUserTaskProgress metaUserTaskProgress : metaUserTaskProgresses) {
            if (metaUserTaskProgress.getCreatedAt().isAfter(endTime.withHour(0).withMinute(0).withSecond(0))) {
                num = num + 1;
                continue;
            }
            i = i + 1;
            if (metaUserTaskProgress.getCreatedAt().isAfter(endTime.withHour(0).withMinute(0).withSecond(0).plusDays(-i))
                    && metaUserTaskProgress.getCreatedAt().isBefore(endTime.withHour(0).withMinute(0).plusDays(-(i - 1)))) {
                num = num + 1;
                continue;
            }
            break;
        }
        if (num > 7) {
            num = num % 7;
        }
        return num;
    }
}