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

package com.izouma.nineth.service;

import com.izouma.nineth.domain.MetaProp;
import com.izouma.nineth.domain.MetaUserProp;
import com.izouma.nineth.dto.MetaRestResult;
import com.izouma.nineth.dto.PageQuery;
import com.izouma.nineth.enums.MetaPropOperationType;
import com.izouma.nineth.enums.MetaPropUsedType;
import com.izouma.nineth.repo.MetaPropRepo;
import com.izouma.nineth.repo.MetaUserPropRepo;
import com.izouma.nineth.utils.JpaUtils;
import lombok.AllArgsConstructor;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.util.Objects;

@Service
@AllArgsConstructor
public class MetaUserPropService {

    private MetaUserPropRepo metaUserPropRepo;

    private MetaPropRepo metaPropRepo;

    private MetaUserPropRecordService metaUserPropRecordService;

    private MetaUserGoldService metaUserGoldService;

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

    @Transactional
    public MetaRestResult<MetaUserProp> operate(Long userId, Long metaPropId, MetaPropOperationType operationType, int num) {
        if (Objects.isNull(metaPropId)) {
            return MetaRestResult.returnError("Illegal parameter : metaPropId can not be null");
        }
        MetaProp metaProp = metaPropRepo.findById(metaPropId).orElse(null);
        if (Objects.isNull(metaProp)) {
            return MetaRestResult.returnError("道具不存在！");
        }
        MetaUserProp dbMetaUserProp = metaUserPropRepo.findByUserIdAndMetaPropIdAndDel(userId, metaPropId, false);
        if (MetaPropOperationType.RECEIVE.equals(operationType)) {
            if (num < 1) {
                return MetaRestResult.returnError("道具数量最少为1");
            }
            return receive(userId, dbMetaUserProp, metaProp, num);
        }
        if (MetaPropOperationType.CANCEL_USE.equals(operationType)) {
            return cancelUse(dbMetaUserProp, metaProp);
        }
        return use(dbMetaUserProp, metaProp);
    }

    /**
     * 永久道具 取消使用
     *
     * @param metaUserProp 永久道具持有信息
     * @param metaProp     道具信息
     * @return
     */
    @Transactional
    public MetaRestResult<MetaUserProp> cancelUse(MetaUserProp metaUserProp, MetaProp metaProp) {
        if (Objects.isNull(metaUserProp)) {
            return MetaRestResult.returnError("玩家未拥有该道具！");
        }
        if (!MetaPropUsedType.PERMANENT.equals(metaProp.getUsedType())) {
            return MetaRestResult.returnError("仅限永久道具才能取消使用！");
        }
        metaUserProp.setUsed(false);
        metaUserPropRecordService.save(metaUserProp.getUserId(), metaProp, MetaPropOperationType.CANCEL_USE, 1);
        return MetaRestResult.returnSuccess("取消使用成功", metaUserPropRepo.save(metaUserProp));
    }

    /**
     * 获得道具
     *
     * @param userId       用户id
     * @param metaUserProp 道具持有信息
     * @param metaProp     道具信息
     * @param num          数量
     * @return
     */
    @Transactional
    public MetaRestResult<MetaUserProp> receive(Long userId, MetaUserProp metaUserProp, MetaProp metaProp, int num) {
        boolean init = false;
        if (Objects.isNull(metaUserProp)) {
            metaUserProp = MetaUserProp.create(userId, metaProp, num);
            init = true;
        } else {
            metaUserProp.setNum(metaUserProp.getNum() + num);
        }
        if (MetaPropUsedType.PERMANENT.equals(metaProp.getUsedType()) && 1 < metaUserProp.getNum()) {
            int metaPropPrice = metaProp.getGoldNum();
            int metaPropNum = metaUserProp.getNum() - 1;
            if (0 >= metaPropPrice) {
                metaPropPrice = 100;
            }
            int goldNum = metaPropPrice * metaPropNum;
            metaUserGoldService.changeNum(userId, goldNum, String.format("永久道具:[%S],数量:[%S],单价:[%S],转化成金币[%S]", metaProp.getId(), metaPropNum, metaPropPrice, goldNum));
            // 未拥有该道具，领取一个，多余转化为金币
            if (init) {
                metaUserProp.setNum(1);
                MetaUserProp save = metaUserPropRepo.save(metaUserProp);
                metaUserPropRecordService.save(metaUserProp.getUserId(), metaProp, MetaPropOperationType.RECEIVE, 1);
                return MetaRestResult.returnSuccess(String.format("永久道具仅限持有一个，多余道具将转化为[%S]个金币！", goldNum), save);
            }
            // 已拥有该道具，全部转为道具后返回
            return MetaRestResult.returnSuccess(String.format("玩家已拥有该道具，所领取的道具将转化为[%S]个金币！", goldNum));
        }
        MetaUserProp save = metaUserPropRepo.save(metaUserProp);
        metaUserPropRecordService.save(metaUserProp.getUserId(), metaProp, MetaPropOperationType.RECEIVE, num);
        return MetaRestResult.returnSuccess("道具领取成功！", save);

    }

    /**
     * 使用道具
     *
     * @param metaUserProp 道具持有信息
     * @param metaProp     道具信息
     * @return
     */
    @Transactional
    public MetaRestResult<MetaUserProp> use(MetaUserProp metaUserProp, MetaProp metaProp) {
        if (Objects.isNull(metaUserProp)) {
            return MetaRestResult.returnError("玩家未拥有该道具！");
        }
        // 永久道具 不对背包做操作，增加一条操作记录
        if (MetaPropUsedType.PERMANENT.equals(metaProp.getUsedType())) {
            metaUserProp.setUsed(true);
            metaUserPropRecordService.save(metaUserProp.getUserId(), metaProp, MetaPropOperationType.USE, 1);
            return MetaRestResult.returnSuccess(metaUserPropRepo.save(metaUserProp));
        }
        // 数量为1的非永久道具，成功使用后直接删除背包中该道具数据，增加一条操作记录
        if (1 == metaUserProp.getNum()) {
            metaUserProp.setNum(0);
            metaUserPropRecordService.save(metaUserProp.getUserId(), metaProp, MetaPropOperationType.USE, 1);
            metaUserPropRepo.deleteByUserIdAndMetaPropId(metaUserProp.getUserId(), metaProp.getId());
            return MetaRestResult.returnSuccess(metaUserProp);
        }
        // 数量大于1的非永久道具，背包中该道具数量减1，增加一条操作记录
        metaUserProp.setNum(metaUserProp.getNum() - 1);
        metaUserPropRecordService.save(metaUserProp.getUserId(), metaProp, MetaPropOperationType.USE, 1);
        return MetaRestResult.returnSuccess(metaUserPropRepo.save(metaUserProp));
    }

    public void aspect() {
        metaUserPropRepo.deleteNumZero();
    }
}