Merge remote-tracking branch 'origin/master-v2' into master-v2

cloudroam

2024-10-12 24e21f8ce1a28a78a58f9a95cc6438b4a9c737a6

 src/main/java/com/mzl/flower/service/menber/impl/MemberServiceImpl.java

@@ -4,19 +4,25 @@
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mzl.flower.config.exception.ValidationException;
import com.mzl.flower.config.security.SecurityUtils;
import com.mzl.flower.constant.Constants;
import com.mzl.flower.dto.request.menber.MemberDTO;
import com.mzl.flower.dto.request.menber.MemberQueryDTO;
import com.mzl.flower.dto.response.member.MemberVO;
import com.mzl.flower.entity.menber.Member;
import com.mzl.flower.entity.system.User;
import com.mzl.flower.mapper.customer.CustomerMapper;
import com.mzl.flower.mapper.member.MemberMapper;
import com.mzl.flower.service.menber.MemberService;
import com.mzl.flower.service.system.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.util.List;

/**
@@ -33,21 +39,75 @@

    private final MemberMapper memberMapper;

    private final CustomerMapper customerMapper;

    private final UserService  userService;

    @Override
    public void saveMember(Member member) {
        if (StringUtils.isEmpty(member.getName())) {
    public void saveMember(MemberDTO memberDTO) {
        //是否已经存在endpoint已经有最大值了，有的话需要删除或者修改
        if (memberDTO.getEndPoint() == null) {
//            Member pointByIntegerMaxValue = memberMapper.getEndPointByIntegerMaxValue(Integer.MAX_VALUE);
//            if (!ObjectUtils.isEmpty(pointByIntegerMaxValue)) {
//                throw new ValidationException("系统中已经有一条最大值或者空值记录，请删除或者修改再保存");
//            } else {
                memberDTO.setEndPoint(Integer.MAX_VALUE);
//            }
        }
        if (StringUtils.isEmpty(memberDTO.getName())) {
            throw new ValidationException("会员等级名称不能为空");
        }

        if (member.getStartPoint()>member.getEndPoint()) {
            throw new ValidationException("成长点开始不能大于结束");
        if (StringUtils.isEmpty(memberDTO.getDiscountType())) {
            throw new ValidationException("会员折扣类型不能为空");
        }
        if (Constants.DISCOUNT_TYPE.amount.name().equals(memberDTO.getDiscountType()) && StringUtils.isEmpty(memberDTO.getDiscountAmount())) {
            throw new ValidationException("会员折扣固定金额不能为空");
        }
        if (Constants.DISCOUNT_TYPE.ratio.name().equals(memberDTO.getDiscountType()) && StringUtils.isEmpty(memberDTO.getDiscountRatio())) {
            throw new ValidationException("会员折扣百分比不能为空");
        }

        if (memberDTO.getStartPoint() > memberDTO.getEndPoint()) {
            throw new ValidationException("成长点开始不能大于结束点");
        }
        if (!StringUtils.isEmpty(memberDTO.getDiscountRatio())) {
            int discountRatio1 = memberDTO.getDiscountRatio().compareTo(BigDecimal.ZERO);
            if (discountRatio1 == -1) {
                throw new ValidationException("会员折扣百分比不能小于0");
            }
            int discountRatio2 = memberDTO.getDiscountRatio().compareTo(new BigDecimal(100));
            if (discountRatio2 == 1) {
                throw new ValidationException("会员折扣百分比不能大于100");
            }
        }
        //区间交集判断
        //查询所有等级
        List<Member> allMember = memberMapper.getAllMember();
        allMember.forEach(a -> {
            if (a.getStartPoint() < memberDTO.getEndPoint() && a.getEndPoint() > memberDTO.getStartPoint()) {
                throw new ValidationException("存在交集，不允许保存");
            }
        });
        if (!StringUtils.isEmpty(memberDTO.getDiscountAmount())) {
            int discountAmount = memberDTO.getDiscountAmount().compareTo(BigDecimal.ZERO);
            if (discountAmount == -1) {
                throw new ValidationException("会员折扣固定金额不能小于0");
            }
        }

        //保存时判断是否有重复的名称
        Member memberByName = memberMapper.getMemberByName(member.getName());
        Member memberByName = memberMapper.getMemberByName(memberDTO.getName());
        if (!ObjectUtils.isEmpty(memberByName)) {
            throw new ValidationException("会员等级名称重复");
        }
        Member member = new Member();
        BeanUtils.copyProperties(memberDTO, member);
        member.create(SecurityUtils.getUserId());
        memberMapper.insert(member);
        //更新会员等级
        customerMapper.updateMemberLevelByPoint(member.getId(), memberDTO.getStartPoint(), memberDTO.getEndPoint());

    }

    @Override
@@ -56,35 +116,115 @@
        if (memberInfo == null) {
            throw new ValidationException("会员等级信息不存在");
        }
//        if (!memberInfo.getCreateBy().equals(SecurityUtils.getUserId())) {
//            throw new ValidationException("无权限修改");
//        }
        if (StringUtils.isEmpty(memberDTO.getDiscountType())) {
            throw new ValidationException("会员折扣类型不能为空");
        }
        if (Constants.DISCOUNT_TYPE.amount.name().equals(memberDTO.getDiscountType()) && StringUtils.isEmpty(memberDTO.getDiscountAmount())) {
            throw new ValidationException("会员折扣固定金额不能为空");
        }
        if (Constants.DISCOUNT_TYPE.ratio.name().equals(memberDTO.getDiscountType()) && StringUtils.isEmpty(memberDTO.getDiscountRatio())) {
            throw new ValidationException("会员折扣百分比不能为空");
        }
        if (!StringUtils.isEmpty(memberDTO.getDiscountRatio())) {
            int discountRatio1 = memberDTO.getDiscountRatio().compareTo(BigDecimal.ZERO);
            if (discountRatio1 == -1) {
                throw new ValidationException("会员折扣百分比不能小于0");
            }
            int discountRatio2 = memberDTO.getDiscountRatio().compareTo(new BigDecimal(100));
            if (discountRatio2 == 1) {
                throw new ValidationException("会员折扣百分比不能大于100");
            }
        }
        if (!StringUtils.isEmpty(memberDTO.getDiscountAmount())) {
            int discountAmount = memberDTO.getDiscountAmount().compareTo(BigDecimal.ZERO);
            if (discountAmount == -1) {
                throw new ValidationException("会员折扣固定金额不能小于0");
            }
        }
        Member memberTemp = memberMapper.getMemberByName(memberDTO.getName());
        //判断如果按照会员等级查询到得名称和当前得Id不一致，不能修改。
        if (!ObjectUtils.isEmpty(memberTemp)) {
            if (memberTemp.getName().equals(memberDTO.getName())) {
            if (memberTemp.getId() != memberDTO.getId()) {
                throw new ValidationException("已存在会员等级名称，无法修改");
            }
        }
        //是否已经存在endpoint已经有最大值了，有的话需要删除或者修改
//        if (memberDTO.getEndPoint() == null && memberInfo.getEndPoint() != Integer.MAX_VALUE) {
//            Member pointByIntegerMaxValue = memberMapper.getEndPointByIntegerMaxValue(Integer.MAX_VALUE);
//            if (!ObjectUtils.isEmpty(pointByIntegerMaxValue)) {
//                throw new ValidationException("系统中已经有一条最大值或者空值记录，请删除或者修改再保存");
//            } else {
//                memberDTO.setEndPoint(Integer.MAX_VALUE);
//            }
//        } else if (memberDTO.getEndPoint() == null && memberInfo.getEndPoint() == Integer.MAX_VALUE) {
//            memberDTO.setEndPoint(Integer.MAX_VALUE);
//        }

        if (memberDTO.getEndPoint() == null) {
            if (memberInfo.getEndPoint() != Integer.MAX_VALUE) {
                Member pointByIntegerMaxValue = memberMapper.getEndPointByIntegerMaxValue(Integer.MAX_VALUE);
                if (!ObjectUtils.isEmpty(pointByIntegerMaxValue)) {
                    throw new ValidationException("系统中已经有一条最大值或者空值记录，请删除或者修改再保存");
                } else {
                    memberDTO.setEndPoint(Integer.MAX_VALUE);
                }
            } else {
                memberDTO.setEndPoint(Integer.MAX_VALUE);
            }
        }

        if (memberDTO.getStartPoint() > memberDTO.getEndPoint()) {
            throw new ValidationException("成长点开始不能大于结束");
        }
        //区间交集判断
        //查询所有等级
        List<Member> allMember = memberMapper.getOtherAllMember(memberDTO.getId());
        allMember.forEach(a -> {
            if (a.getStartPoint() < memberDTO.getEndPoint() && a.getEndPoint() > memberDTO.getStartPoint()) {
                throw new ValidationException("存在交集，不允许修改");
            }
        });

        //更新会员等级
        if (memberInfo.getStartPoint() != memberDTO.getStartPoint() || memberInfo.getEndPoint() != memberDTO.getEndPoint()) {
            customerMapper.updateMemberLevelByPoint(memberInfo.getId(), memberDTO.getStartPoint(), memberDTO.getEndPoint());
        }

        BeanUtils.copyProperties(memberDTO,memberInfo);
        memberInfo.update(SecurityUtils.getUserId());
        memberMapper.updateById(memberInfo);

    }

    @Override
    public void deleteMember(String id) {
        if(id.equals(Constants.DEFAULT_MEMBER_ID)){
            throw new ValidationException("默认普通会员只能编辑，不能删除");
        }
        Member member = memberMapper.selectById(id);
        if (member == null) {
            throw new ValidationException("会员等级信息不存在");
        }

        // TODO: 2024/8/26 如果当前会员绑定了优惠券，不能删除，等优惠券逻辑完成。 
        Integer levelId = customerMapper.getByLevelId(id);
        if (levelId > 0) {
            throw new ValidationException("当前会员等级用户已使用，无法删除");
        }
        memberMapper.deleteById(id);
    }

    @Override
    public Page<MemberVO> queryPage(MemberQueryDTO memberQueryDTO, Page page) {
        List<MemberVO> list = memberMapper.queryPage(memberQueryDTO, page);
        if(!CollectionUtils.isEmpty(list)){
            list.forEach(l->{
                if (!StringUtils.isEmpty(l.getUpdateBy())) {
                    User userById = userService.getUserById(l.getUpdateBy());
                    if(!ObjectUtils.isEmpty(userById)){
                        l.setCreateName(userById.getNickName());
                    }
                }
            });
        }
        page.setRecords(list);
        return page;
    }