liebao-cloud/lb-module/src/main/java/com/ydd/module/service/impl/MemberBalanceLogServiceImpl.java

package com.ydd.module.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ydd.common.core.domain.entity.SysUser;
import com.ydd.common.core.page.PageResult;
import com.ydd.common.enums.UserTypeEnums;
import com.ydd.module.domain.*;
import com.ydd.module.dto.MemberBalanceLogDto;
import com.ydd.module.dto.ProfitsMerchantDTO;
import com.ydd.module.dto.RechargeDto;
import com.ydd.module.dto.SystemMemberBalanceLogDto;
import com.ydd.module.enums.LogSourceEnum;
import com.ydd.module.mapper.MemberBalanceLogMapper;
import com.ydd.module.mapper.MemberMapper;
import com.ydd.module.mapper.OrderMapper;
import com.ydd.module.request.AccountFlowListRequest;
import com.ydd.module.service.IAgentService;
import com.ydd.module.service.IMemberService;
import com.ydd.module.service.IProfitsDetailService;
import lombok.RequiredArgsConstructor;
import org.apache.commons.compress.utils.Lists;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ydd.module.service.IMemberBalanceLogService;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 用户账户明细Service业务层处理
 *
 * @author douya
 * @date 2021-02-01
 */
@Service
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class MemberBalanceLogServiceImpl extends ServiceImpl<MemberBalanceLogMapper, MemberBalanceLog> implements IMemberBalanceLogService {

    private final MemberMapper memberMapper;

    private final IAgentService iAgentService;

    private final IMemberService iMemberService;

    private final OrderMapper orderMapper;

    private final IProfitsDetailService iProfitsDetailService;

    @Override
    public List<MemberBalanceLog> queryList(SystemMemberBalanceLogDto memberBalanceLog) {
        LambdaQueryWrapper<MemberBalanceLog> lqw = Wrappers.lambdaQuery();
        if (memberBalanceLog.getOrderId() != null) {
            lqw.eq(MemberBalanceLog::getOrderId, memberBalanceLog.getOrderId());
        }
        if (CollectionUtils.isNotEmpty(memberBalanceLog.getOrderIds())) {
            lqw.in(MemberBalanceLog::getOrderId, memberBalanceLog.getOrderIds());
        }
        if (memberBalanceLog.getMemberId() != null) {
            lqw.eq(MemberBalanceLog::getMemberId, memberBalanceLog.getMemberId());
        }
        if(memberBalanceLog.getPaymentType() != null) {
            lqw.eq(MemberBalanceLog::getPaymentType, memberBalanceLog.getPaymentType());
        }
        if (memberBalanceLog.getType() != null) {
            lqw.eq(MemberBalanceLog::getType, memberBalanceLog.getType());
        }
        if (memberBalanceLog.getSource() != null) {
            lqw.eq(MemberBalanceLog::getSource, memberBalanceLog.getSource());
        }
        if (memberBalanceLog.getAmount() != null) {
            lqw.eq(MemberBalanceLog::getAmount, memberBalanceLog.getAmount());
        }
        if (memberBalanceLog.getMerchantId() != null) {
            lqw.eq(MemberBalanceLog::getMerchantId, memberBalanceLog.getMerchantId());
        }
        if (memberBalanceLog.getStartTime() != null && memberBalanceLog.getStartTime() != "") {
            lqw.ge(MemberBalanceLog::getCreateTime, memberBalanceLog.getStartTime());
        }
        if (memberBalanceLog.getEndTime() != null && memberBalanceLog.getEndTime() != "") {
            lqw.le(MemberBalanceLog::getCreateTime, memberBalanceLog.getEndTime());
        }
        if (memberBalanceLog.getShowOther()) {
            lqw.and(wq -> wq.eq(MemberBalanceLog::getSource, LogSourceEnum.SUBSIDY.getStatus())
                    .or().eq(MemberBalanceLog::getSource, LogSourceEnum.BACK_REFUND.getStatus()));
        }
        lqw.orderByDesc(MemberBalanceLog::getCreateTime);

        List<MemberBalanceLog> logList = this.list(lqw);

        // if (memberBalanceLog.getShowOther()) {
            for (MemberBalanceLog log : logList) {
                if (log.getOrderId() != null) {
                    Order order = orderMapper.getAllOrderByOrderId(log.getOrderId());
                    if (order != null) {
                        log.setOrderSn(order.getOrderSn());
                    }
                }


                // 查看自己的佣金
                List<ProfitsDetail> profitsDetailList = iProfitsDetailService.getByCommissionId(log.getOrderId());

                List<ProfitsDetail> profitsDetail = profitsDetailList.stream().filter(item -> item.getAgentId() != null).collect(Collectors.toList());
                if (profitsDetail.size() > 0){
                    log.setGetCommission(profitsDetail.stream().map(ProfitsDetail::getCommission).reduce(BigDecimal.ZERO, BigDecimal::add));
                }

                if (log.getMemberId() != null) {
                        Member member = memberMapper.selectById(log.getMemberId());
                        if (member != null) {
                            log.setMobile(member.getMobile());
                        }
                }
            }
        // }
        return logList;
    }

    @Override
    public void updateMemberBalanceLog(Long memberId, BigDecimal amount, Integer source, Integer type, String desc,Long merchantId, Integer paymentType) {
        MemberBalanceLog memberBalanceLog = new MemberBalanceLog();
        memberBalanceLog.setMemberId(memberId);
        memberBalanceLog.setAmount(amount);
        memberBalanceLog.setType(type);
        memberBalanceLog.setSource(source);
        memberBalanceLog.setRemark(desc);
        memberBalanceLog.setMerchantId(merchantId);
        memberBalanceLog.setPaymentType(paymentType);
        baseMapper.insert(memberBalanceLog);
        memberMapper.updateMemberBalance(memberId, amount, type);
    }

    @Override
    public BigDecimal countNumByType(Long memberId, Integer type) {
        return baseMapper.countNumByType(memberId, type);
    }

    @Override
    public BigDecimal sumNumAmountByMemberId(Long merchantId, Integer source, ProfitsMerchant profitsMerchant) {
        return baseMapper.sumNumAmountByMemberId(merchantId, source, profitsMerchant);
    }

    @Override
    public BigDecimal sumNumAmountDtoByMemberId(Long merchantId, Integer source, ProfitsMerchantDTO profitsMerchantDTO) {
        return baseMapper.sumNumAmountDtoByMemberId(merchantId, source, profitsMerchantDTO);
    }


    @Override
    public BigDecimal sumNumAmountById(Long memberId, Integer source) {
        return baseMapper.sumNumAmountById(memberId, source);
    }

    @Override
    public List<MemberBalanceLog> getMyLogs(Long memberId, Integer source, String time,Long shopId) {
//        QueryWrapper<MemberBalanceLog> wrapper = new QueryWrapper<>();
//        memberId = 1L;
//        wrapper.eq("member_id", memberId);
//        wrapper.orderByDesc("create_time");
        List<MemberBalanceLog> balanceLogs = baseMapper.findLogs(memberId, source, time,shopId);
        balanceLogs.forEach(item -> {
            if (LogSourceEnum.BACK_REFUND.getStatus().equals(item.getSource())) {
                item.setRemark("取消订单退款");
            }
            if (LogSourceEnum.SUBSIDY.getStatus().equals(item.getSource())) {
                item.setRemark("后台补贴");
            }
        });
        //过滤掉退款金额为0的记录
        return balanceLogs;
    }

    @Override
    public void saveLog(Long loginId, Integer type, String desc, Integer source, BigDecimal payAmount,Long merchantId,Long orderId, Integer paymentType) {
        MemberBalanceLog log = new MemberBalanceLog();
        log.setRemark(desc);
        log.setAmount(payAmount);
        log.setMemberId(loginId);
        log.setSource(source);
        log.setType(type);
        log.setMerchantId(merchantId);
        log.setOrderId(orderId);
        log.setPaymentType(paymentType);
        baseMapper.insert(log);
    }

    @Override
    public PageResult queryRechargeList(Page page, MemberBalanceLog memberBalanceLog, SysUser user) {
        List<Integer> memberIds = new ArrayList<>();
        if (user.getType().equals(UserTypeEnums.AGENT.getCode())) {
            List<Long> agentIds = iAgentService.listAgent(user.getAgentId());
            for (Long agentId : agentIds) {
                List<Integer> memberId = iMemberService.selectMemberIdByAgentId(agentId.intValue());
                memberIds.addAll(memberId);
            }
        }

        List<MemberBalanceLog> list = baseMapper.queryRechargeList(page, memberBalanceLog, memberIds);
        list.stream().forEach(log -> {
            Member member = iMemberService.getById(log.getMemberId());
            if (member != null && member.getAgentId() != null) {
                Agent agent = iAgentService.getById(member.getAgentId());
                if (agent != null && agent.getName() != null) {
                    log.setAgentName(agent.getName());
                }
            }
        });
        page.setRecords(list);
        return new PageResult(page);
    }

    @Override
    public PageResult queryRechargeDto(Page page, MemberBalanceLog memberBalanceLog, SysUser sysUser) {
        List<Integer> memberIds = new ArrayList<>();
        List<Long> agents = Lists.newArrayList();
        if (sysUser.getType().equals(UserTypeEnums.AGENT.getCode()) && memberBalanceLog.getAgentId() == null) {
            List<Long> agentIds = iAgentService.listAgent(sysUser.getAgentId());
            for (Long agentId : agentIds) {
                List<Integer> memberId = iMemberService.selectMemberIdByAgentId(agentId.intValue());
                memberIds.addAll(memberId);
            }
        }

        if (memberBalanceLog.getAgentId() != null) {
            agents = iAgentService.listAgent(memberBalanceLog.getAgentId().longValue());
        }
       // BigDecimal sumPrice=new BigDecimal(0);
        List<RechargeDto> list = baseMapper.queryRechargeDto(page, memberBalanceLog, memberIds, agents);
        if (list!=null && list.size() > 0) {
            for (RechargeDto rechargeDto : list) {
                Member member = iMemberService.getById(rechargeDto.getMemberId());
                if (member != null && member.getAgentId() != null) {
                    Agent agent = iAgentService.getById(member.getAgentId());
                    if (agent != null && agent.getName() != null) {
                        rechargeDto.setAgentName(agent.getName());
                    }
                }
            }
        }
        page.setRecords(list);
        return new PageResult(page);
    }

    @Override
    public Page<MemberBalanceLogDto> getBalanceLogList(AccountFlowListRequest request, Long loginId, List<Long> shopIdList, IPage<MemberBalanceLog> pageArt) {
        return baseMapper.getBalanceLogList(request, loginId, shopIdList, pageArt);
    }
}