liebao-cloud/lb-app/src/main/java/com/ydd/app/service/impl/ApiDevelopServiceImpl.java

package com.ydd.app.service.impl;

import cn.hutool.core.lang.UUID;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ydd.app.dto.*;
import com.ydd.app.service.*;
import com.ydd.app.vo.OpenMyWalletVo;
import com.ydd.module.dto.OpenCustomerDto;
import com.ydd.app.vo.OpenMemberInfoVo;
import com.ydd.common.constant.Constants;
import com.ydd.common.core.domain.ResponseResult;
import com.ydd.common.core.page.PageResult;
import com.ydd.common.core.redis.RedisCache;
import com.ydd.common.enums.ResponseResultCodeEnum;
import com.ydd.common.utils.DateUtils;
import com.ydd.common.utils.SnCodeUtils;
import com.ydd.common.utils.sign.Md5Utils;
import com.ydd.framework.web.service.TokenService;
import com.ydd.module.domain.*;
import com.ydd.module.enums.*;
import com.ydd.module.service.*;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.concurrent.TimeUnit;

import static com.ydd.module.enums.CacheKeyEnum.SMS_REGISTER_CAPTCHA;

/**
 * Project：lb-server
 * Class：ApiShopServiceImpl
 * Description：TODO
 * Time：2021/3/1 17:40
 *
 * @author zoe
 */
@Slf4j
@Service
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class ApiDevelopServiceImpl implements ApiDevelopService {

    private final IMemberService iMemberService;

    private final IShopService iShopService;

    private final IMerchantService iMerchantService;

    private final IAppInfoService iAppInfoService;
    private final IAppInfoTokenService iAppInfoTokenService;

    private final RedisCache redisCache;

    private final TokenService tokenService;

    private final IRechargeService iRechargeService;
    private final IRechargeOptionService iRechargeOptionService;

    private final IMemberCouponService iMemberCouponService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseResult saveMerchant(Long loginId, DevelopMerchantDto merchantDto) {
        merchantDto.setCategoryId(1l);
        Member member = iMemberService.getMemberByMobile(merchantDto.getUserAccount());
        if (member != null) {
            return ResponseResult.error(ResponseResultCodeEnum.USER_MOBILE_EXIST);
        }


        Merchant merchant = new Merchant();
        BeanUtils.copyProperties(merchantDto, merchant);
        merchant.setStatus(MerchantStatusEnum.TO_BE_CERTIFIED.getStatus());
        merchant.setCode(SnCodeUtils.createMerchantSn());

        iMerchantService.save(merchant);
        Shop shop = new Shop();
        shop.setAddress(merchantDto.getAddress());
        shop.setCategoryId(merchantDto.getCategoryId());
        shop.setCode(SnCodeUtils.createShopSn());
        shop.setContactName(merchantDto.getContactName());
        shop.setLat(merchantDto.getLat());
        shop.setLng(merchantDto.getLng());
        shop.setMerchantId(merchant.getId());
        shop.setMobile(merchantDto.getMobile());
        shop.setName(merchantDto.getMerchantName());
        shop.setStreet(merchantDto.getStreet());
        shop.setProvinceName(merchantDto.getProvinceName());
        shop.setCityName(merchantDto.getCityName());
        shop.setDistrictName(merchantDto.getDistrictName());
        shop.setCityCode(merchantDto.getCityCode());
        shop.setBizLicense(merchantDto.getBizLicense());
        shop.setBizLicenseNo(merchantDto.getBizLicenseNo());
        shop.setLegalPerson(merchantDto.getLegalPerson());
        shop.setIdcardNo(merchantDto.getIdcardNo());
        shop.setIdcardFront(merchantDto.getIdcardFront());
        shop.setIdcardBack(merchantDto.getIdcardBack());
        shop.setBizLicenseIdcard(merchantDto.getBizLicenseIdcard());
        shop.setFoodLicensePic(merchantDto.getFoodLicensePic());
        shop.setPoiAddress(merchantDto.getPoiAddress());
        iShopService.save(shop);

        member = new Member();
        member.setMobile(merchantDto.getUserAccount());
        member.setNickname(merchantDto.getUserAccount());
        member.setStatus(Constants.NORMAL);
        member.setAliasId(UUID.fastUUID().toString().replaceAll("-", ""));
        if (StringUtils.isNotBlank(merchantDto.getPassword())) {
            member.setPassword(Md5Utils.hash(merchantDto.getPassword()));
        }
        member.setMerchantId(merchant.getId());
        member.setMemberType(MemberTypeEnum.MERCHANT.type);
        member.setShopId(shop.getId());
        iMemberService.save(member);
        return ResponseResult.success();
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseResult modify(Long loginId, DevelopMerchantDto merchantDto) {

        Merchant merchant = iMerchantService.getById(merchantDto.getMerchantId());
        BeanUtils.copyProperties(merchantDto, merchant);
        merchant.setStatus(MerchantStatusEnum.TO_BE_CERTIFIED.getStatus());
        iMerchantService.updateById(merchant);
        return ResponseResult.success();
    }

    @Override
    public ResponseResult audit(DevelopAuditDto developAuditDto) {
        Merchant merchant = iMerchantService.getById(developAuditDto.getMerchantId());
        Member member = iMemberService.getOne(new QueryWrapper<Member>().eq("member_type", 2).eq("merchant_id", developAuditDto.getMerchantId()));
        if (StatusEnum.SHOW.status.equals(developAuditDto.getStatus())) {
            merchant.setStatus(2);
            try {
                AppInfo appInfo_dev = new AppInfo();
                appInfo_dev.setName(merchant.getMerchantName());
                appInfo_dev.setSandbox(0);
                appInfo_dev.setStartTime(DateUtils.parseDate(developAuditDto.getStartTime()));
                appInfo_dev.setEndTime(DateUtils.parseDate(developAuditDto.getEndTime()));
                appInfo_dev.setEarnestMoney(developAuditDto.getEarnestMoney());
                iAppInfoService.createAppInfo(appInfo_dev);
                AppInfoToken token_dev = new AppInfoToken();
                token_dev.setAppId(appInfo_dev.getAppId());
                token_dev.setToken(Md5Utils.hash(member.getId().toString()));
                token_dev.setMemberId(member.getId());
                token_dev.setRefreshToken(Md5Utils.hash(merchant.getId().toString()));
                token_dev.setExpiresTime(DateUtils.addDays(new Date(), 30));
                iAppInfoTokenService.save(token_dev);

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (StatusEnum.STOP.status.equals(developAuditDto.getStatus())) {
            merchant.setStatus(StatusEnum.STOP.status);
        }
        iMerchantService.updateById(merchant);
        online(developAuditDto,member,merchant);
        return ResponseResult.success();
    }


    public ResponseResult online(DevelopAuditDto developAuditDto, Member member,Merchant merchant ) {

        AppInfo appInfo_pro = new AppInfo();
        appInfo_pro.setName(merchant.getMerchantName());
        appInfo_pro.setSandbox(1);
        appInfo_pro.setStartTime(DateUtils.parseDate(developAuditDto.getStartTime()));
        appInfo_pro.setEndTime(DateUtils.parseDate(developAuditDto.getEndTime()));
        appInfo_pro.setEarnestMoney(developAuditDto.getEarnestMoney());
        appInfo_pro.setMerchantId(merchant.getId());
        try {
            iAppInfoService.createAppInfo(appInfo_pro);
        } catch (Exception e) {

        }
        AppInfoToken token_pro = new AppInfoToken();
        token_pro.setAppId(appInfo_pro.getAppId());
        token_pro.setToken(Md5Utils.hash(member.getId().toString()));
        token_pro.setMemberId(member.getId());
        token_pro.setRefreshToken(Md5Utils.hash(appInfo_pro.getId().toString()));
        token_pro.setExpiresTime(DateUtils.addDays(new Date(), 30));
        iAppInfoTokenService.save(token_pro);

        tokenService.setMemberToken(token_pro.getToken(), member.getId());
        redisCache.setCacheObject(Constants.APP_REFRESH_TOKEN_KEY + token_pro.getRefreshToken(), member.getId(), 30, TimeUnit.DAYS);
        return ResponseResult.success();
    }

    @Override
    public ResponseResult refreshToken(String refreshToken) {
        Long memberId = redisCache.getCacheObject(Constants.APP_REFRESH_TOKEN_KEY + refreshToken);
        if (memberId == null) {
            return ResponseResult.error(ResponseResultCodeEnum.REFRESH_TOKEN_INVALID);
        }
        AppInfoToken token = iAppInfoTokenService.getOne(new QueryWrapper<AppInfoToken>().eq("refresh_token", refreshToken));
        if (token == null) {
            return ResponseResult.error(ResponseResultCodeEnum.REFRESH_TOKEN_INVALID);
        }
        token.setToken(Md5Utils.hash(memberId.toString()));
        token.setRefreshToken(Md5Utils.hash(token.getId().toString()));
        token.setExpiresTime(DateUtils.addDays(new Date(), 30));
        iAppInfoTokenService.updateById(token);
        redisCache.deleteObject(Constants.APP_REFRESH_TOKEN_KEY + token.getRefreshToken());
        redisCache.setCacheObject(Constants.APP_REFRESH_TOKEN_KEY + token.getRefreshToken(), memberId, 30, TimeUnit.DAYS);
        return ResponseResult.success(token);
    }

    @Override
    public ResponseResult memberInfo(Long loginId) {
        Member member = iMemberService.getById(loginId);
        if (Objects.isNull(member)) {
            return ResponseResult.error(ResponseResultCodeEnum.REFRESH_TOKEN_INVALID);
        }

        Merchant merchant = iMerchantService.getById(member.getMerchantId());
        OpenMemberInfoVo vo = new OpenMemberInfoVo();
        vo.setResistMobile(member.getMobile());
        vo.setBusinessName(merchant.getMerchantName());
        vo.setBusinessAddress(merchant.getAddress());
        vo.setContactName(merchant.getContactName());
        vo.setContactMobile(merchant.getMobile());
        return ResponseResult.success(vo);
    }

    @Override
    public ResponseResult editMemberInfo(OpenMemberInfoDto memberInfoDto) {
        Member member = iMemberService.getMemberByMobile(memberInfoDto.getResistMobile());
        ResponseResult result = memberInfoJudge(member, memberInfoDto.getResistMobile(), memberInfoDto.getCode());
        if (result.getCode() != ResponseResultCodeEnum.SUCCESS.getCode()) {
            return result;
        }

        Merchant merchant = iMerchantService.getById(member.getMerchantId());
        merchant.setContactName(memberInfoDto.getContactName());
        merchant.setMobile(memberInfoDto.getContactMobile());
        iMerchantService.updateById(merchant);
        return ResponseResult.success();
    }

    @Override
    public ResponseResult editMemberPassword(OpenMemberPasswordDto memberPasswordDto) {
        Member member = iMemberService.getMemberByMobile(memberPasswordDto.getResistMobile());
        ResponseResult result = memberInfoJudge(member, memberPasswordDto.getResistMobile(), memberPasswordDto.getCode());
        if (result.getCode() != ResponseResultCodeEnum.SUCCESS.getCode()) {
            return result;
        }

        if (!memberPasswordDto.getPassword().equals(memberPasswordDto.getConfirmPassword())) {
            return ResponseResult.error(ResponseResultCodeEnum.INCONSISTENT_CODE);
        }

        member.setPassword(Md5Utils.hash(memberPasswordDto.getPassword()));
        iMemberService.updateById(member);
        return ResponseResult.success();
    }

    @Override
    public ResponseResult appSecretInfo(Long loginId) {
        Member member = iMemberService.getById(loginId);
        if (Objects.isNull(member)) {
            return ResponseResult.error(ResponseResultCodeEnum.REFRESH_TOKEN_INVALID);
        }

        Merchant merchant = iMerchantService.getById(member.getMerchantId());
        List<AppInfo> appInfoList = iAppInfoService.list(new QueryWrapper<AppInfo>().eq("deleted", 0).eq("merchant_id", merchant.getId()));
        return ResponseResult.success(appInfoList);
    }

    @Override
    public ResponseResult setCallbackUrl(Long loginId, AppInfo appInfo) {
        ResponseResult result = appInfoJudge(loginId);
        if (result.getCode() != ResponseResultCodeEnum.SUCCESS.getCode()) {
            return result;
        }

        AppInfo oldAppInfo = (AppInfo) result.getData();

        List<AppInfo> appInfoList = iAppInfoService.list(new QueryWrapper<AppInfo>().eq("deleted", 0).eq("name", oldAppInfo.getName()));

        appInfoList.stream().forEach(appInfo1 -> {
            appInfo1.setStoreStatusNotifyUrl(appInfo.getStoreStatusNotifyUrl());
            appInfo1.setOrderStatusNotifyUrl(appInfo.getOrderStatusNotifyUrl());

            iAppInfoService.updateById(appInfo1);
        });

        return ResponseResult.success();
    }

    @Override
    public ResponseResult selectCustomerList(String cityName, String businessName, String contactName) {
        List<OpenCustomerDto> customerVoList = iMerchantService.selectCustomerList(cityName, businessName, contactName);
        return ResponseResult.success(new PageResult(customerVoList));
    }

    @Override
    public ResponseResult myWallet(Long loginId) {
        Member member = iMemberService.getById(loginId);
        if (Objects.isNull(member)) {
            return ResponseResult.error(ResponseResultCodeEnum.REFRESH_TOKEN_INVALID);
        }

        OpenMyWalletVo vo = new OpenMyWalletVo();
        List<RechargeOption> options = iRechargeOptionService.list(new QueryWrapper<RechargeOption>().eq("status", StatusEnum.SHOW.status).orderByDesc("sort"));
        vo.setRechargeOptionList(options);
        vo.setAmount(member.getAmount());

        Date now = new Date();
        int couponNum = iMemberCouponService.count(new QueryWrapper<MemberCoupon>()
                .eq("member_id", member.getId())
                .eq("status", MemberCouponStatusEnum.NOT_USED.status)
                .le("valid_start_time", now)
                .ge("valid_end_time", now));
        vo.setCouponNum(couponNum);
        return ResponseResult.success(vo);
    }

    @Override
    public ResponseResult rechargeList(Long loginId, String startTime, String endTime) {
        List<Recharge> rechargeList = iRechargeService.selectOpenRechargeList(loginId, startTime, endTime);
        return ResponseResult.success(rechargeList);
    }

    private ResponseResult memberInfoJudge(Member member, String resistMobile, String code) {
        ResponseResult result = ResponseResult.success();

        if (Objects.isNull(member)) {
            return ResponseResult.error(ResponseResultCodeEnum.FAIL);
        }

        String checkCode = redisCache.getCacheObject(SMS_REGISTER_CAPTCHA.key + resistMobile);
        if (StringUtils.isBlank(checkCode) || !code.equals(checkCode)) {
            return ResponseResult.error(ResponseResultCodeEnum.INVALID_SMS_CODE);
        }
        return result;
    }

    private ResponseResult appInfoJudge(Long loginId) {
        ResponseResult result = ResponseResult.success();

        Member member = iMemberService.getById(loginId);
        if (Objects.isNull(member)) {
            return ResponseResult.error(ResponseResultCodeEnum.REFRESH_TOKEN_INVALID);
        }

        Merchant merchant = iMerchantService.getById(member.getMerchantId());
        AppInfo appInfo = iAppInfoService.getByAppId(merchant.getAppId());
        if (Objects.isNull(appInfo)) {
            return ResponseResult.error(ResponseResultCodeEnum.APP_ID_ERR);
        }

        result.setData(appInfo);
        return result;
    }

}