caimei365-cloud-user/src/main/java/com/caimei365/user/service/impl/RegisterServiceImpl.java

package com.caimei365.user.service.impl;

import com.caimei365.user.components.CommonService;
import com.caimei365.user.components.RedisService;
import com.caimei365.user.components.WeChatService;
import com.caimei365.user.feign.ToolsFeign;
import com.caimei365.user.mapper.*;
import com.caimei365.user.model.ResponseJson;
import com.caimei365.user.model.dto.*;
import com.caimei365.user.model.po.*;
import com.caimei365.user.model.vo.*;
import com.caimei365.user.service.RegisterService;
import com.caimei365.user.service.RemoteCallService;
import com.caimei365.user.utils.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.io.IOException;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Description
 *
 * @author : Charles
 * @date : 2021/3/8
 */
@Slf4j
@Service
public class RegisterServiceImpl implements RegisterService {

    @Value("${spring.cloud.config.profile}")
    private String profile;
    @Resource
    private SuperVipMapper vipMapper;
    @Resource
    private RedisService redisService;
    @Resource
    private CommonService commonService;
    @Resource
    private BaseMapper baseMapper;
    @Resource
    private LoginMapper loginMapper;
    @Resource
    private RegisterMapper registerMapper;
    @Resource
    private SellerMapper sellerMapper;
    @Resource
    private ToolsFeign smsFeign;
    @Resource
    private MessagePushMapper messagePushMapper;
    @Resource
    private MessageCenterMapper messageCenterMapper;
    @Resource
    private RemoteCallService remoteCallService;
    @Resource
    private WeChatService weChatService;
    @Resource
    private ClubMapper clubMapper;

    /**
     * 检查账号可以注册
     *
     * @param mobile 手机号
     * @return sucess
     */
    @Override
    public ResponseJson registerCheck(String mobile) {
        // 手机号验证
        String mobileResult = commonService.mobileAndCodeValidate(mobile, null);
        if (mobileResult != null) {
            return ResponseJson.error(mobileResult);
        }
        return ResponseJson.success("该账号可以注册");
    }

    /**
     * 普通机构入驻(注册)
     *
     * @param clubRegisterDto ClubRegisterDto{
     *                        source            注册来源: 0网站 1小程序
     *                        userName          用户名
     *                        bindMobile        企业绑定手机号
     *                        password          密码
     *                        unionId           微信unionId
     *                        nickName          微信昵称
     *                        avatarUrl         微信头像(旧：headimgurl)
     *                        passWordConfirm   用户确认密码
     *                        smsCode           短信验证码(旧：activationCode)
     *                        isAgreed          是否同意勾选同意协议，1是，其他否
     *                        }
     * @param headers         HttpHeaders
     * @return ClubPo
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseJson clubRegister(ClubRegisterDto clubRegisterDto, HttpHeaders headers) {
        // 打印IP
        String ip = headers.getFirst("X-CLIENT-IP");
        log.info("机构注册 X-CLIENT-IP : " + ip);
        // 参数校验
        if (StringUtils.isBlank(clubRegisterDto.getUserName())) {
            return ResponseJson.error("参数异常：用户名不能为空！");
        }
        if (StringUtils.isBlank(clubRegisterDto.getBindMobile())) {
            return ResponseJson.error("参数异常：企业绑定手机号不能为空！");
        }
        if (StringUtils.isBlank(clubRegisterDto.getPassword())) {
            return ResponseJson.error("参数异常：密码不能为空！");
        }
        if (StringUtils.isBlank(clubRegisterDto.getPassWordConfirm())) {
            return ResponseJson.error("参数异常：确认密码不能为空！");
        }
        if (StringUtils.isBlank(clubRegisterDto.getSmsCode())) {
            return ResponseJson.error("参数异常：短信验证码不能为空！");
        }
        if (null == clubRegisterDto.getIsAgreed() || 1 != clubRegisterDto.getIsAgreed()) {
            return ResponseJson.error("请勾选同意协议");
        }
        if (!clubRegisterDto.getPassword().equals(clubRegisterDto.getPassWordConfirm())) {
            return ResponseJson.error("两次输入的密码不一致");
        }
        // 手机号与验证码校验
        String result = commonService.mobileAndCodeValidate(clubRegisterDto.getBindMobile(), clubRegisterDto.getSmsCode());
        if (result != null) {
            return ResponseJson.error(result);
        }
        // 密码校验
        String passResult = ValidateUtil.validatePassWord(clubRegisterDto.getPassword());
        if (passResult != null) {
            return ResponseJson.error(passResult);
        }
        // 获取ip所在地
        String ipAddress = "";
        Integer provinceId = null;
        Integer cityId = null;
        try {
            ipAddress = IpUtil.recordIp(ip);
            Map<String, String> map = IpUtil.recordAddress(ip);
            // 省
            String regionPro = map.get("regionPro");
            provinceId = registerMapper.selProvince(regionPro);
            // 市
            String regionCity = map.get("regionCity");
            cityId = registerMapper.selCity(regionCity);

        } catch (IOException e) {
            e.printStackTrace();
        }
        log.info("ip所在地====》"+ipAddress);
        /*
            组装用户数据 user
         */
        UserPo user = new UserPo();
        // 设置日期时间格式
        Date date = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String current = dateFormat.format(date);
        // 注册时间
        user.setRegisterTime(current);
        // 注册IP
        user.setRegisterIp(ip);
        // 注册IP所在地
        user.setIpAddress(ipAddress);
        // 注册来源: 0网站 1小程序
        user.setSource(clubRegisterDto.getSource());
        // 用户类型，供应商1，会员机构3,普通机构4
        user.setRegisterUserTypeId(4);
        // 采美默认组织机构0
        user.setOrganizeId(0);
        // 用户名
        user.setName(clubRegisterDto.getUserName());
        user.setUserName(clubRegisterDto.getUserName());
        // 绑定手机号
        user.setBindMobile(clubRegisterDto.getBindMobile());
        // 用户身份: 1协销 2会员机构 3供应商 4普通机构
        user.setUserIdentity(4);
        // 用户权限: 2会员机构 3供应商 4协销 5普通机构
        user.setUserPermission(5);
        // 是否已经引导过(机构升级:0否，1是)
        user.setGuideFlag(0);
        // 设置机构上线
        user.setClubStatus(90);
        // 设置密码
        user.setPassword(Md5Util.md5(clubRegisterDto.getPassword()));
        // 同意协议
        user.setAgreeFlag(1);
        // 用户状态，1正常，0冻结
        user.setValidFlag(1);
        // 协销Id，默认采美官方
        user.setServiceProviderId(1342);
        // 协销状态，已上线
        user.setServiceProviderStatus(90);
        //采美豆
        user.setUserBeans(1000);
        /*
            保存数据库 user
         */
        int insertFlag = registerMapper.insertClubUser(user);
        log.info("插入数据库User表，获得userId:" + user.getUserId());
        if (insertFlag < 1) {
            throw new RuntimeException("插入数据库异常user:" + user.toString());
        }

        /*
          保存用户状态
         */
        List<UserPo> userPos = registerMapper.selUser(current);
        for (UserPo userInfo : userPos) {
            registerMapper.insertOrgan(userInfo.getUserId());
        }
        /*
            组装机构数据
         */
        ClubPo club = new ClubPo();
        // 机构名称
        club.setName(user.getUserName());
        // 联系手机
        club.setContractMobile(user.getBindMobile());
        // 联系人
        club.setLinkMan(user.getUserName());
        // 用户Id
        club.setUserId(user.getUserId());
        // 协销Id(spId)
        club.setServiceProviderId(1342);
        // 注册时间
        club.setAddTime(current);
        // 状态设置上线
        club.setStatus(90);
        if (4 == user.getUserIdentity()) {
            if (null != provinceId) {
                club.setProvinceId(provinceId);
            }
            if (null != cityId) {
                club.setCityId(cityId);
            }
        }
        /*
            保存数据库 club
         */
        int insertClubFlag = registerMapper.insertClub(club);
        log.info("插入数据库club表，获得clubId:" + club.getClubId());
        if (insertClubFlag < 1) {
            throw new RuntimeException("插入数据库异常club:" + club.toString());
        }
        // user更新clubId
        user.setClubId(club.getClubId());
        registerMapper.updateUserClubId(user.getUserId(), club.getClubId());
        // 添加机构协销记录
        if (StringUtils.isNotBlank(club.getLinkMan())) {
            clubMapper.inProvider(1342, club.getClubId(), club.getLinkMan(), 0);
        }
        //推送信息中心-账户通知
        MessageCenter messageCenter = new MessageCenter();
        messageCenter.setShopId(null);
        messageCenter.setClubId(club.getClubId());
        messageCenter.setUserType(1);
        messageCenter.setMessageType(2);
        messageCenter.setAccountType(1);
        messageCenter.setContent(null);
        messageCenter.setTime(current);
        messageCenterMapper.addMessageCenter(messageCenter);

        //    绑定微信，成为机构运营人员
        if (StringUtils.isNotEmpty(clubRegisterDto.getNickName())) {
            MessageCenter messageCente = new MessageCenter();
            messageCente.setShopId(null);
            messageCente.setClubId(club.getClubId());
            messageCente.setUserType(1);
            messageCente.setMessageType(2);
            messageCente.setAccountType(7);
            messageCente.setContent(clubRegisterDto.getNickName());
            messageCente.setTime(current);
            messageCenterMapper.addMessageCenter(messageCente);

            OperationPo operation = new OperationPo();
            // 组织Id,采美默认0
            operation.setOrganizeId(0);
            // 用户Id
            operation.setUserId(user.getUserId());
            // 机构Id
            operation.setClubId(club.getClubId());
            // 微信昵称
            operation.setNickName(clubRegisterDto.getNickName());
            // 微信头像
            operation.setAvatarUrl(clubRegisterDto.getAvatarUrl());
            // 用户类型，1:机构类型，2供应商类型
            operation.setUserType(1);
            // 运营人员手机号
            operation.setMobile(clubRegisterDto.getBindMobile());
            // 联系人
            operation.setLinkName(clubRegisterDto.getUserName());
            // 运营人员状态：1未绑定，2已绑定
            operation.setStatus(2);
            // 微信unionId
            operation.setUnionId(clubRegisterDto.getUnionId());
            Map<Object, Object> infoData = redisService.getEntries("wxInfo:applets:" + clubRegisterDto.getUnionId());
            String openId = (String) infoData.get(WeChatService.Keys.OPEN_ID);
            // 微信openId
            operation.setOpenId(openId);
            // 添加时间
            operation.setAddTime(date);
            // 更新时间
            operation.setUpdateTime(date);
            // 绑定时间
            operation.setBindTime(date);
            // delFlag: 0 有效  其它无效
            operation.setDelFlag(0);
            /*
                保存数据库 operation
             */
            int insertOperationFlag = registerMapper.insertOperation(operation);
            log.info("插入数据库cm_mall_operation_user表，获得id:" + operation.getId());
            if (insertOperationFlag < 1) {
                log.info(operation.getUserId() + " 插入数据库异常operation:" + operation.toString());
            }
            log.info("注册普通机构,默认绑定为机构运营人员");
        }
        log.info("注册普通机构成功,手机号>>>" + clubRegisterDto.getBindMobile());
//        if (!smsFlag) {
//            log.info("短信发送失败，手机号：" + clubRegisterDto.getBindMobile());
//        }
        //新用户自主注册送1000采美豆
        UserBeansHistoryPo beansHistory = new UserBeansHistoryPo();
        beansHistory.setUserId(user.getUserId());
        beansHistory.setBeansType(1);
        beansHistory.setType(1);
        beansHistory.setNum(1000);
        beansHistory.setPushStatus(0);
        beansHistory.setAddTime(date);
        registerMapper.insertBeansHistory(beansHistory);
        return ResponseJson.success("机构注册成功", null);
    }

    /**
     * 普通机构升级会员机构（资质机构）
     *
     * @param upgradeDto ClubUpgradeDto:{
     *                   clubId                 机构ID
     *                   userId                 用户ID
     *                   name                   机构名称
     *                   shortName                  机构简称
     *                   contractEmail          邮箱（contractEmail1）
     *                   contractPhone          固定电话
     *                   linkMan                联系人（linkMan1）
     *                   provinceId             省Id
     *                   cityId                 市Id
     *                   townId                 县区Id
     *                   address                地址
     *                   shopPhoto              门头照(headpic)
     *                   businessLicense        营业执照（businessLicenseImage）
     *                   socialCreditCode       统一社会信用代码（socialCreditCode）
     *                   firstClubType          一级分类：医美=1和生美=2
     *                   secondClubType         医美的二级分类：诊所=1、门诊=2、医院=3。  生美没有二级分类
     *                   department             医美分类下的门诊和医院则需要填写科室
     *                   medicalPracticeLicense 医美分类必须上传医疗执业许可证（medicalPracticeLicenseImg）
     *                   mainProduct            主打项目（mainpro）
     *                   fax                    传真
     *                   profile                公司简介
     *                   }
     * @param headers    HttpHeaders
     * @return ClubPo
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseJson clubUpgrade(ClubUpgradeDto upgradeDto, HttpHeaders headers) {
        // 打印IP
        String ip = headers.getFirst("X-CLIENT-IP");
        log.info("机构升级 X-CLIENT-IP : " + ip);
        // 参数校验
        if (null == upgradeDto.getUserId()) {
            return ResponseJson.error("参数异常：用户Id不能为空！");
        }
        if (null == upgradeDto.getClubId()) {
            return ResponseJson.error("参数异常：机构Id不能为空！");
        }
        if (StringUtils.isBlank(upgradeDto.getContractEmail())) {
            return ResponseJson.error("参数异常：联系邮箱不能为空！");
        }
        if (StringUtils.isBlank(upgradeDto.getName())) {
            return ResponseJson.error("参数异常：机构名称不能为空！");
        }
        if (StringUtils.isBlank(upgradeDto.getBusinessLicense())) {
            return ResponseJson.error("参数异常：营业执照不能为空！");
        }
        if (null == upgradeDto.getTownId()) {
            return ResponseJson.error("参数异常：请选择地址！");
        }
        if (null == upgradeDto.getFirstClubType()) {
            return ResponseJson.error("参数异常：一级分类不能为空！");
        }
        if (upgradeDto.getFirstClubType() == 1) {
            // 医美分类
            if (upgradeDto.getSecondClubType() == null || StringUtils.isBlank(upgradeDto.getMedicalPracticeLicense())) {
                return ResponseJson.error("医美分类下参数异常，医美的二级分类为空或医疗执业许可证为空");
            }
        }
        Integer userIdByEmail = baseMapper.getUserIdByEmail(upgradeDto.getContractEmail());
        if (null != userIdByEmail && userIdByEmail > 0 && !userIdByEmail.equals(upgradeDto.getUserId())) {
            return ResponseJson.error("该邮箱已被使用");
        }
        String nameCheck = ValidateUtil.validateClubName(upgradeDto.getName());
        if (nameCheck != null) {
            return ResponseJson.error(nameCheck);
        }
        String socialCodeResult = ValidateUtil.validateSocialCreditCode(upgradeDto.getSocialCreditCode());
        if (socialCodeResult != null) {
            return ResponseJson.error(socialCodeResult);
        }
        // 更新用户数据 user
        UserPo user = new UserPo();
        user.setUserId(upgradeDto.getUserId());
        // 客户IP
        user.setRegisterIp(ip);
        // 联系邮箱
        user.setEmail(upgradeDto.getContractEmail());
        // 机构名称
        user.setName(upgradeDto.getName());
        // 待审核资料
        user.setClubStatus(1);
        // 更新机构用户
        registerMapper.updateClubUserByUpgrade(user);
        /*
            组装机构数据
         */
        ClubPo club = new ClubPo();
        // 机构Id
        club.setClubId(upgradeDto.getClubId());
        // 用户Id
        club.setUserId(upgradeDto.getUserId());
        // 机构名称
        club.setName(upgradeDto.getName());
        // 机构简称
        club.setShortName(upgradeDto.getShortName());
        // 联系邮箱
        club.setContractEmail(upgradeDto.getContractEmail());
        // 固定电话
        club.setContractPhone(upgradeDto.getContractPhone());
        // 联系人
        club.setLinkMan(upgradeDto.getLinkMan());
        // 联系人身份
        club.setLinkManIdentity(upgradeDto.getLinkManIdentity());
        // 地址
        club.setProvinceId(upgradeDto.getProvinceId());
        club.setCityId(upgradeDto.getCityId());
        club.setTownId(upgradeDto.getTownId());
        club.setAddress(upgradeDto.getAddress());
        // 门头照
        club.setShopPhoto(upgradeDto.getShopPhoto());
        // 营业执照
        club.setBusinessLicense(upgradeDto.getBusinessLicense());
        // 统一社会信用代码
        club.setSocialCreditCode(upgradeDto.getSocialCreditCode());
        // 分类: 1医美, 2生美
        club.setFirstClubType(upgradeDto.getFirstClubType());
        if (upgradeDto.getFirstClubType() == 1) {
            // 医美二级分类: 1诊所、2门诊、3医院
            club.setSecondClubType(upgradeDto.getSecondClubType());
            // 门诊和医院则需要填写科室
            club.setDepartment(upgradeDto.getDepartment());
            // 医美分类必须上传医疗执业许可证
            club.setMedicalPracticeLicense(upgradeDto.getMedicalPracticeLicense());
        }
        // 主打项目(mainpro)
        club.setMainProduct(upgradeDto.getMainProduct());
        // 传真
        club.setFax(upgradeDto.getFax());
        // 公司简介(info)
        club.setProfile(upgradeDto.getProfile());
        /*
         * 待审核资料
         */
        club.setStatus(1);
        registerMapper.updateClubByUpgrade(club);
        return ResponseJson.success("机构升级成功", null);
    }

    /**
     * 协销拉机构上线
     *
     * @param id 暂存机构数据id
     * @return ClubPo
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseJson<Integer> clubOnline(Integer id, HttpHeaders headers) {
        ClubTemporaryVo clubTemporary = registerMapper.getTemporary(id);
        if (clubTemporary == null) {
            return ResponseJson.error("机构数据异常", null);
        }
        Integer isAgreed = clubTemporary.getIsAgreed();
        // 打印IP
        String ip = headers.getFirst("X-CLIENT-IP");
        log.info("协销拉机构上线 X-CLIENT-IP : " + ip);
        // 手机号
        String mobile = clubTemporary.getBindMobile();
        // 参数校验
        if (null == clubTemporary.getUserId()) {
            return ResponseJson.error("参数异常：用户Id不能为空！", null);
        }
        if (StringUtils.isBlank(mobile)) {
            return ResponseJson.error("参数异常：企业绑定手机号不能为空！", null);
        }
        if (StringUtils.isBlank(clubTemporary.getLinkMan())) {
            return ResponseJson.error("参数异常：联系人不能为空！", null);
        }
        if (null == isAgreed || 1 != isAgreed) {
            return ResponseJson.error("请勾选同意协议", null);
        }
        // 是否填写升级资料
        Integer confirmUserId = clubTemporary.getConfirmUserId();
        UserLoginVo userLogin = null;
        if (confirmUserId != null) {
            userLogin = loginMapper.getLoginUserByUserId(confirmUserId);
        }
        String businessLicense = clubTemporary.getBusinessLicense();
        String email = clubTemporary.getContractEmail();
        if (StringUtils.isNotBlank(businessLicense)) {
            if (confirmUserId == null || (userLogin != null && !userLogin.getEmail().equals(email))) {
                // 邮箱验证
                String emailCheck = commonService.emailValidate(email);
                if (emailCheck != null) {
                    return ResponseJson.error(emailCheck, null);
                }
            }
            // 机构名称检查
            String nameCheck = ValidateUtil.validateClubName(clubTemporary.getName());
            if (nameCheck != null) {
                return ResponseJson.error(nameCheck, null);
            }
            if (clubTemporary.getFirstClubType() == 1) {
                // 医美分类
                if (clubTemporary.getSecondClubType() == null || StringUtils.isBlank(clubTemporary.getMedicalPracticeLicense())) {
                    return ResponseJson.error("医美分类下参数异常，医美的二级分类为空或医疗执业许可证为空", null);
                }
            }
        }
        if (confirmUserId == null || (userLogin != null && !userLogin.getBindMobile().equals(mobile))) {
            // 手机号验证
            String result = commonService.mobileAndCodeValidate(mobile, null);
            if (result != null) {
                return ResponseJson.error(result, null);
            }
        }
        // 获取协销信息
        Integer userId = clubTemporary.getUserId();
        ServiceProviderVo serviceProvider = loginMapper.getServiceProviderByUserId(userId);
        // 设置日期时间格式
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String current = dateFormat.format(new Date());
        // 获取ip所在地
        String ipAddress = "";
        Integer provinceId = null;
        Integer cityId = null;
        try {
            ipAddress = IpUtil.recordIp(ip);
            // 获取省市地址
            Map<String, String> map = IpUtil.recordAddress(ip);
            // 省
            String regionPro = map.get("regionPro");
            provinceId = registerMapper.selProvince(regionPro);
            // 市
            String regionCity = map.get("regionCity");
            cityId = registerMapper.selCity(regionCity);
        } catch (IOException e) {
            e.printStackTrace();
        }
        log.info("ip所在地====》"+ipAddress);
        /*
            组装用户数据 user
         */
        UserPo user = new UserPo();
        // 注册时间
        user.setRegisterTime(current);
        // 机构拉上线统称为此IP方便后面直接标记为协销代注册
        user.setRegisterIp("192.168.1.10");
        // 注册IP所在地
        user.setIpAddress(ipAddress);
        // 注册来源: 0网站 1小程序（拉机构上线小程序注册）
        user.setSource(1);
        // 采美默认组织机构0
        user.setOrganizeId(0);
        // 用户类型，供应商1，会员机构3,普通机构4
        user.setRegisterUserTypeId(4);
        // 组织名称
        user.setName(clubTemporary.getLinkMan());
        // 用户名
        user.setUserName(clubTemporary.getLinkMan());
        // 绑定手机号
        user.setBindMobile(mobile);
        // 用户身份: 1协销 2会员机构 3供应商 4普通机构
        user.setUserIdentity(4);
        // 用户权限: 2会员机构 3供应商 4协销 5普通机构
        user.setUserPermission(5);
        // 设置机构上线
        user.setClubStatus(90);
        // 默认密码
        String randomCode = CodeUtil.generateCodeInt(6);
        String initPassword = "cm" + randomCode;
        user.setPassword(Md5Util.md5(initPassword));
        // 同意协议
        user.setAgreeFlag(isAgreed);
        // 用户状态，1正常，0冻结
        user.setValidFlag(1);
        // 协销Id
        user.setServiceProviderId(serviceProvider.getServiceProviderId());
        // 协销状态
        user.setServiceProviderStatus(serviceProvider.getStatus());
        // 会员机构，填写升级资料
        if (StringUtils.isNotBlank(businessLicense)) {
            // 状态：待审查资料
            user.setClubStatus(1);
            // 组织名称
            user.setName(clubTemporary.getName());
            // 邮箱
            user.setEmail(email);
            // 是否已经引导过(机构升级:0否，1是)
            user.setGuideFlag(1);
        } else {
            // 是否已经引导过(机构升级:0否，1是)
            user.setGuideFlag(0);
        }
        /* 保存数据库 user */
        if (confirmUserId == null) {
            int insertUserFlag = registerMapper.insertClubUser(user);
            log.info("插入数据库User表，获得userId:" + user.getUserId());
            if (insertUserFlag < 1) {
                throw new RuntimeException("插入数据库异常user:" + user.toString());
            }
        } else {
            user.setUserId(confirmUserId);
            user.setClubStatus(90);
            registerMapper.updateClubUser(user);
            log.info("客服注册机构注册,更新user表userId>>>>>" + confirmUserId);
        }
        /* 机构列表用户状态默认插入 */

        if(user.getUserId() != null) {
            registerMapper.insertOrgan(user.getUserId());
            log.info("插入数据库用户价值表,cm_organ_value_system表userid=====》" + user.getUserId());
        }
        /*
            组装机构数据
         */
        ClubPo club = new ClubPo();
        int insertClubFlag = 0;
        // 联系手机
        club.setContractMobile(mobile);
        // 联系人
        club.setLinkMan(clubTemporary.getLinkMan());
        // 用户Id
        club.setUserId(user.getUserId());
        // 设置协销ID
        club.setServiceProviderId(serviceProvider.getServiceProviderId());
        // 待扫描
        club.setScanFlag(0);
        // 注册时间
        club.setAddTime(current);
        // 会员机构，填写升级资料
        if (StringUtils.isNotBlank(businessLicense)) {
            // 机构名称
            club.setName(clubTemporary.getName());
            // 机构简称
            club.setShortName(clubTemporary.getShortName());
            // 邮箱
            club.setContractEmail(email);
            // 待审查资料
            club.setStatus(1);
            // 地址
            club.setProvinceId(clubTemporary.getProvinceId());
            club.setCityId(clubTemporary.getCityId());
            club.setTownId(clubTemporary.getTownId());
            club.setAddress(clubTemporary.getAddress());
            // 门头照
            club.setShopPhoto(clubTemporary.getShopPhoto());
            // 营业执照
            club.setBusinessLicense(businessLicense);
            // 统一社会信用代码
            club.setSocialCreditCode(clubTemporary.getSocialCreditCode());
            // 分类: 1医美, 2生美
            club.setFirstClubType(clubTemporary.getFirstClubType());
            if (clubTemporary.getFirstClubType() == 1) {
                // 医美二级分类: 1诊所、2门诊、3医院
                club.setSecondClubType(clubTemporary.getSecondClubType());
                // 门诊和医院则需要填写科室
                club.setDepartment(clubTemporary.getDepartment());
                // 医美分类必须上传医疗执业许可证
                club.setMedicalPracticeLicense(clubTemporary.getMedicalPracticeLicense());
            }
            // 主打项目(mainpro)
            club.setMainProduct(clubTemporary.getMainProduct());
            if (confirmUserId == null) {
                /*
                    保存数据库（会员机构） club
                 */
                insertClubFlag = registerMapper.insertUpgradeClub(club);
            } else {
                club.setStatus(90);
                club.setUserId(confirmUserId);
                registerMapper.updateClub(club);
            }
        } else {
            // 机构名称
            club.setName(clubTemporary.getLinkMan());
            // 机构简称
            club.setShortName(clubTemporary.getLinkMan());
            // 状态设置上线
            club.setStatus(90);
            if (4 == user.getUserIdentity()) {
                club.setProvinceId(provinceId);
                club.setCityId(cityId);
            }
            if (confirmUserId == null) {
                /*
                   保存数据库(普通机构) club
                 */
                insertClubFlag = registerMapper.insertClub(club);
            } else {
                club.setStatus(90);
                club.setUserId(confirmUserId);
                registerMapper.updateClub(club);
            }
        }
        if (confirmUserId == null) {
            log.info("插入数据库club表，获得clubId:" + club.getClubId());
            if (insertClubFlag < 1) {
                throw new RuntimeException("插入数据库异常club:" + club.toString());
            }
            // user更新clubId
            user.setClubId(club.getClubId());
            registerMapper.updateUserClubId(user.getUserId(), club.getClubId());
        }
        // 添加机构协销记录
        if (StringUtils.isNotBlank(club.getLinkMan())) {
            clubMapper.inProvider(serviceProvider.getServiceProviderId(), club.getClubId(), club.getLinkMan(), 1);
        }
        //推送信息中心-账户通知
        MessageCenter messageCenter=new MessageCenter();
        messageCenter.setShopId(null);
        messageCenter.setClubId(club.getClubId());
        messageCenter.setUserType(1);
        messageCenter.setMessageType(2);
        messageCenter.setAccountType(1);
        messageCenter.setContent(null);
        messageCenter.setTime(current);
        messageCenterMapper.addMessageCenter(messageCenter);




        /*
         * 操作成功，推送短信给机构，获取账号密码。
         * 协销去后台审核，机构用账号密码登录绑定微信
         */
        String logTxt = "【协销拉机构上线】短信内容:>>>欢迎成为采美 %s 用户，您的登录账号为：%s，初始密码为：%s";
        int smsType = 6;
        if (StringUtils.isNotBlank(email)) {
            // 会员机构
            logTxt = String.format(logTxt, "会员机构", mobile, initPassword);
        } else {
            // 普通机构
            logTxt = String.format(logTxt, "普通机构", mobile, initPassword);
        }
        // 发送短信
        String content = "欢迎成为采美机构用户，您的登录账号为："+mobile+"，初始密码为：cm"+randomCode+"，您可使用该账号密码登录采美365网和“采美采购商城”小程序。";
        boolean smsFlag = remoteCallService.remoteSendSms(0, 1, mobile, content);
        if (!smsFlag) {
            // 短信发送失败重试一次
            remoteCallService.remoteSendSms(0, 1, mobile, content);
        }
        // 打印短信内容
        log.info(logTxt);
        if (!smsFlag) {
            log.info("短信发送失败，手机号：" + mobile);
        }
        sellerMapper.deleteTemporaryClub(id);
        // 返回状态
        return ResponseJson.success(user.getUserId());
    }

    /**
     * 供应商注册
     *
     * @param shopRegisterDto ShopRegisterDto{
     *                        source                注册来源: 0网站 1小程序
     *                        name                  组织名称
     *                        shortName                 供应商公司简称(shortName)
     *                        bindMobile            企业绑定手机号
     *                        email                 邮箱
     *                        password              密码
     *                        linkMan               联系人
     *                        provinceId            省(provinceID)
     *                        cityId                市(cityID)
     *                        townId                所在县区Id(townID)
     *                        address               地址
     *                        socialCreditCode      统一社会信用代码
     *                        businessLicense       营业执照(businessLicenseImage)
     *                        firstShopType         医疗=1和非医疗=2
     *                        secondShopType        医疗的二级分类 一类器械=1、二类器械 =2、三类器械=3、其他=4 /// 1和非医疗没有二级分类
     *                        mainProduct           主打项目(mainpro)
     *                        }
     * @param passWordConfirm 用户确认密码
     * @param smsCode         短信验证码(旧：activationCode)
     * @param isAgreed        是否同意勾选同意协议，1是，其他否
     * @param whichStep       注册步数: PC(0)，小程序(1,2,3)
     * @param headers         HttpHeaders
     * @return ShopPo
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseJson shopRegister(ShopRegisterDto shopRegisterDto, String passWordConfirm, String smsCode, Integer isAgreed, Integer whichStep, HttpHeaders headers) {
        // 打印IP
        String ip = headers.getFirst("X-CLIENT-IP");
        log.info("供应商注册 X-CLIENT-IP : " + ip);
        // 参数校验
        if (StringUtils.isBlank(shopRegisterDto.getBindMobile())) {
            return ResponseJson.error("参数异常：企业绑定手机号不能为空！");
        }
        if (StringUtils.isBlank(shopRegisterDto.getPassword())) {
            return ResponseJson.error("参数异常：密码不能为空！");
        }
        if (StringUtils.isBlank(passWordConfirm)) {
            return ResponseJson.error("参数异常：确认密码不能为空！");
        }
        if (StringUtils.isBlank(smsCode)) {
            return ResponseJson.error("参数异常：短信验证码不能为空！");
        }
        if (!shopRegisterDto.getPassword().equals(passWordConfirm)) {
            return ResponseJson.error("两次输入的密码不一致");
        }
        // 手机号与验证码校验
        String result = commonService.mobileAndCodeValidate(shopRegisterDto.getBindMobile(), smsCode);
        if (result != null) {
            return ResponseJson.error(result, null);
        }
        // 小程序第一步校验完成
        if (1 == whichStep) {
            return ResponseJson.success(null);
        }
        if (StringUtils.isBlank(shopRegisterDto.getName())) {
            return ResponseJson.error("参数异常：公司名称不能为空！");
        }
        if (StringUtils.isBlank(shopRegisterDto.getLinkMan())) {
            return ResponseJson.error("参数异常：联系人不能为空！");
        }
        if (StringUtils.isNotEmpty(shopRegisterDto.getEmail())) {
            // 查找用户表是否存在相同邮箱
            Integer userIdByEmail = baseMapper.getUserIdByEmail(shopRegisterDto.getEmail());
            if (null != userIdByEmail && userIdByEmail > 0) {
                return ResponseJson.error("该邮箱已被使用");
            }
        }
        // 小程序第二步校验完成
        if (2 == whichStep) {
            return ResponseJson.success(null);
        }
        if (null == isAgreed || 1 != isAgreed) {
            return ResponseJson.error("请勾选同意协议");
        }
        // 获取ip所在地
        String ipAddress = "";
        try {
            ipAddress = IpUtil.recordIp(ip);
        } catch (IOException e) {
            e.printStackTrace();
        }
        log.info("ip所在地====》"+ipAddress);
        /*
            组装用户数据 user
         */
        UserPo user = new UserPo();
        // 设置日期时间格式
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String current = dateFormat.format(new Date());
        // 注册时间
        user.setRegisterTime(current);
        // 注册IP
        user.setRegisterIp(ip);
        // 注册IP所在地
        user.setIpAddress(ipAddress);
        // 注册来源: 0网站 1小程序
        user.setSource(shopRegisterDto.getSource());
        // 采美默认组织机构0
        user.setOrganizeId(0);
        // 密码
        user.setPassword(Md5Util.md5(shopRegisterDto.getPassword()));
        // 用户类型，供应商1，会员机构3,普通机构4
        user.setRegisterUserTypeId(1);
        // 组织名称
        user.setName(shopRegisterDto.getName());
        user.setUserName(shopRegisterDto.getShortName());
        // 绑定手机号
        user.setBindMobile(shopRegisterDto.getBindMobile());
        // 绑定邮箱
        user.setEmail(shopRegisterDto.getEmail());
        // 用户身份: 1协销 2会员机构 3供应商 4普通机构
        user.setUserIdentity(3);
        // 用户权限: 2会员机构 3供应商 4协销 5普通机构
        user.setUserPermission(3);
        // 供应商状态：90:已上线，91:已下线，92:审核不通过，3:待审核
        user.setManufacturerStatus(3);
        // 用户状态，1正常，0冻结
        user.setValidFlag(1);
        // 同意协议
        user.setAgreeFlag(isAgreed);
        registerMapper.insertShopUser(user);
        /*
            组装供应商数据 shop
         */
        ShopPo shop = new ShopPo();
        // 绑定用户ID
        shop.setUserId(user.getUserId());
        // 供应商公司名称
        shop.setName(shopRegisterDto.getName());
        // 供应商公司简称
        shop.setShortName(shopRegisterDto.getShortName());
        // 联系人
        shop.setLinkMan(shopRegisterDto.getLinkMan());
        // 绑定手机号
        shop.setContractMobile(shopRegisterDto.getBindMobile());
        // 绑定邮箱
        shop.setContractEmail(shopRegisterDto.getEmail());
        // 绑定地址
        shop.setProvinceId(shopRegisterDto.getProvinceId());
        shop.setCityId(shopRegisterDto.getCityId());
        shop.setTownId(shopRegisterDto.getTownId());
        shop.setAddress(shopRegisterDto.getAddress());
        // 统一社会信用代码
        shop.setSocialCreditCode(shopRegisterDto.getSocialCreditCode());
        // 营业执照
        shop.setBusinessLicense(shopRegisterDto.getBusinessLicense());
        // 医疗=1和非医疗=2
        shop.setFirstShopType(shopRegisterDto.getFirstShopType());
        // 医疗的二级分类 一类器械=1、二类器械 =2、三类器械=3、其他=4 /// 1和非医疗没有二级分类
        shop.setSecondShopType(shopRegisterDto.getSecondShopType());
        // 主打项目
        shop.setMainProduct(shopRegisterDto.getMainProduct());
        // 主打系列商品说明
        shop.setMainProductDesc(shopRegisterDto.getMainProductDesc());
        // 公司介绍
        shop.setShopDesc(shopRegisterDto.getShopDesc());
        // 官网地址
        shop.setWebsite(shopRegisterDto.getWebsite());
        // 微信公众号
        shop.setWxOfficialAccount(shopRegisterDto.getWxOfficialAccount());
        // 微信小程序
        shop.setWxApplets(shopRegisterDto.getWxApplets());
        // 添加时间
        shop.setAddTime(current);
        // 是否可用，1可用
        shop.setValidFlag("1");
        // 供应商：90:已上线，91:已下线，92:审核不通过，3:待审核
        shop.setStatus(3);
        //如选择为医疗>>三类器械  则必须要上传资质
        shop.setMedicalPracticeLicenseImg1(shopRegisterDto.getMedicalPracticeLicense());
        /*
            保存数据库 shop
         */
        int insertShopFlag = registerMapper.insertShop(shop);
        if (insertShopFlag < 1) {
            log.info(shop.getUserId() + " 插入数据库异常shop:" + shop.toString());
            return ResponseJson.error("插入数据库异常");
        }
        // user更新shopId
        user.setShopId(shop.getShopId());
        registerMapper.updateUserShopId(user.getUserId(), shop.getShopId());
        log.info("注册供应商---------userID:" + user.getUserId());


        return ResponseJson.success();
    }

    /**
     * @param shop    ShopApplyDto
     * @param headers HttpHeaders
     * @return ShopPo
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseJson updateShopApply(ShopApplyDto shop, HttpHeaders headers) {
        if (null == shop || null == shop.getUserId()) {
            return ResponseJson.error("参数异常：用户Id不能为空！");
        }
        if (null == shop.getShopId()) {
            return ResponseJson.error("参数异常：供应商Id不能为空！");
        }
        if (null == shop.getIsAgreed() || 1 != shop.getIsAgreed()) {
            return ResponseJson.error("请勾选同意协议");
        }
        if (StringUtils.isNotBlank(shop.getEmail())) {
            Integer userIdByEmail = baseMapper.getUserIdByEmail(shop.getEmail());
            if (null != userIdByEmail && userIdByEmail > 0 && !userIdByEmail.equals(shop.getUserId())) {
                return ResponseJson.error("该邮箱已被使用");
            }
        }
        // 更新用户数据 user
        UserPo user = new UserPo();
        user.setUserId(shop.getUserId());
        user.setUserName(shop.getShortName());
        user.setName(shop.getLinkMan());
        user.setEmail(shop.getEmail());
        user.setManufacturerStatus(3);
        // 更新供应商用户信息
        registerMapper.updateShopUserByApply(user);
        // 更新机构信息
        shop.setStatus(3);
        registerMapper.updateShopInfoByApply(shop);

        return ResponseJson.success("更新供应商申请信息成功", null);

    }

    /**
     * 引导升级后改变guideFlag状态
     *
     * @param userId
     */
    @Override
    public ResponseJson updateGuideFlag(Integer userId) {
        if (userId == null) {
            return ResponseJson.error("参数错误");
        }
        registerMapper.updateGuideFlagByUserId(userId);
        return ResponseJson.success();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResponseJson<Integer> clubTemporary(ClubOnlineDto onlineDto) {
        if (StringUtils.isNotBlank(onlineDto.getBusinessLicense())) {
            // 邮箱验证
            String emailCheck = commonService.emailValidate(onlineDto.getContractEmail());
            if (emailCheck != null) {
                return ResponseJson.error(emailCheck, null);
            }
            // 机构名称检查
            String nameCheck = ValidateUtil.validateClubName(onlineDto.getName());
            if (nameCheck != null) {
                return ResponseJson.error(nameCheck, null);
            }
            if (onlineDto.getFirstClubType() == 1) {
                // 医美分类
                if (onlineDto.getSecondClubType() == null || StringUtils.isBlank(onlineDto.getMedicalPracticeLicense())) {
                    return ResponseJson.error("医美分类下参数异常，医美的二级分类为空或医疗执业许可证为空", null);
                }
            }
        }
        // 手机号验证
        String result = commonService.mobileAndCodeValidate(onlineDto.getBindMobile(), null);
        if (result != null) {
            return ResponseJson.error(result, null);
        }
        registerMapper.insertClubTemporary(onlineDto);
        return ResponseJson.success(onlineDto.getUserId());
    }

    @Override
    public ResponseJson<ClubTemporaryVo> temporaryData(Integer id) {
        ClubTemporaryVo clubTemporary = registerMapper.getTemporary(id);
        if (clubTemporary == null) {
            return ResponseJson.error("用户资料不存在", null);
        }
        if (null != clubTemporary.getTownId()) {
            TownVo town = baseMapper.getTown(clubTemporary.getTownId());
            CityVo city = baseMapper.getCity(town.getCityId());
            ProvinceVo province = baseMapper.getProvince(city.getProvinceId());
            clubTemporary.setProvincialAddress(province.getName() + "" + city.getName() + "" + town.getName());
        }
        return ResponseJson.success(clubTemporary);
    }


    /**
     * 采美豆买超级会员
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ResponseJson superVipUpByBeans(Integer userId, Integer packageId, HttpHeaders headers) {
        Integer clubId = messageCenterMapper.clubIdCule(userId);
        SuperVipDto endFlag = findEnd(userId);
        Integer userBeans = vipMapper.findUserBeans(userId);
        VipPackage pac = vipMapper.findUserPackage(packageId);
        //过期和没买过都是生效时间重置，到期时间=现在+套餐时间
        if (endFlag.getVipFlag() == 0 || endFlag.getVipFlag() == -1) {
            //1.查用户采美豆，够就用采美豆下单，不够就返回信息
            if (Double.valueOf(userBeans) >= (pac.getPrice() * pac.getProportion())) {
                //用户采美豆>=套餐需要的采美豆，调用采美豆支付方法
                //传空表示新客户
                beanPay(userId, packageId, null, endFlag.getVipFlag());
                //推送站内消息
                if (clubId != null) {
                    //推送信息中心-账户通知
                    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String current = dateFormat.format(new Date());
                    //1.日期格式
                    log.info("输出间隔月份----------->", pac.getDuration());
                    MessageCenter messageCenter = new MessageCenter();
                    messageCenter.setShopId(null);
                    messageCenter.setClubId(clubId);
                    messageCenter.setUserType(1);
                    messageCenter.setMessageType(2);
                    messageCenter.setAccountType(2);
                    messageCenter.setContent(pac.getDuration() + "个月");
                    messageCenter.setTime(current);
                    messageCenterMapper.addMessageCenter(messageCenter);

                    try {
                        log.info("***********会员充值微信公众号推送************");
                        String accessToken = weChatService.getAccessToken();
                        String unionId=messageCenterMapper.UnionIdList(userId);
                        String openid = messageCenterMapper.getOpenidListByPermission(unionId);
                        String title="恭喜您成为采美商城超级会员";
                        String name=pac.getDuration() + "个月";
                        Double price=pac.getPrice();
                        String date="30";
                        String time = current;
                        String remarkText = "如在使用中有任何疑问，请在小程序内联系在线客服";
                        // 跳转到【小程序付款-选择支付方式页面】
                        String pagePath = "/pages/user/member/member";
                        // sendTemplateMsg(openid, 标题, 金额, 收款日期, 备注, 跳转链接
                        log.error("获取openid>>>>>" + openid);
                        weChatService.sendTemplateMsgs(accessToken, openid,title,name,price,date,remarkText, pagePath);
                    } catch (Exception e) {
                        log.error("【会员充值微信通知】获取微信公众号access_token异常！", e);
                    }

                }
                return ResponseJson.success("支付采美豆购买成功");
            }
            return ResponseJson.error("用户采美豆不足", null);
        } else {
            if (Double.valueOf(userBeans) >= (pac.getPrice() * pac.getProportion())) {
                //续费生效时间不变，原到期时间+套餐时间
                beanPay(userId, packageId, endFlag.getEndTime(), endFlag.getVipFlag());
                     //推送站内消息
                if (clubId != null) {
                    //推送信息中心-账户通知
                    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    String current = dateFormat.format(new Date());
                    //1.日期格式
                    log.info("输出间隔月份----------->", pac.getDuration());
                    MessageCenter messageCenter = new MessageCenter();
                    messageCenter.setShopId(null);
                    messageCenter.setClubId(clubId);
                    messageCenter.setUserType(1);
                    messageCenter.setMessageType(2);
                    messageCenter.setAccountType(2);
                    messageCenter.setContent(pac.getDuration() + "个月");
                    messageCenter.setTime(current);
                    messageCenterMapper.addMessageCenter(messageCenter);
                    try {
                        log.info("***********会员续费微信公众号推送************");
                        String accessToken = weChatService.getAccessToken();
                        String unionId = messageCenterMapper.UnionIdList(userId);
                        String openid = messageCenterMapper.getOpenidListByPermission(unionId);
                        String date = current;
                        String remarkText = "如在使用中有任何疑问，请在小程序内联系在线客服";
                        // 跳转到【小程序付款-选择支付方式页面】
                        String pagePath = "/pages/user/member/member";
                        // sendTemplateMsg(openid, 标题, 金额, 收款日期, 备注, 跳转链接
                        log.error("获取openid>>>>>" + openid);
                        weChatService.sendTemplateMsg(accessToken, openid, date, remarkText, pagePath);
                    } catch (Exception e) {
                        log.error("【会员充值微信通知】获取微信公众号access_token异常！", e);
                    }
                }
                return ResponseJson.success("支付采美豆购买成功");
            }
            return ResponseJson.error("用户采美豆不足", null);
        }
    }

    /**
     * 在线支付开通超级会员
     *
     * @param userId
     * @param packageId
     * @param headers
     */
    @Override
    public ResponseJson<Integer> superVipUpByPay(Integer userId, Integer packageId, HttpHeaders headers) {
        SuperVipDto endFlag = findEnd(userId);
        VipPackage pac = vipMapper.findUserPackage(packageId);
        if (null == pac) {
            return ResponseJson.error("超级会员套餐不存在！", null);
        }
        Calendar cal = Calendar.getInstance();
        Date beginTime = new Date();
        if (null != endFlag.getVipFlag() && 1 == endFlag.getVipFlag()) {
            // 有效期内续费
            beginTime = endFlag.getEndTime();
        }
        cal.setTime(beginTime);
        cal.add(Calendar.MONTH, pac.getDuration());
        // 查询未支付的当前超级会员套餐购买记录
        Integer dbHistoryId = vipMapper.getVipHistoryId(userId, packageId);
        //userId, packageId, beginTime, endTime, payStatus, payWay, payType, price, userBeans, payTime
        VipPayHistoryPo payHistory = new VipPayHistoryPo();
        payHistory.setUserBeans(0d);
        payHistory.setUserId(userId);
        payHistory.setPackageId(packageId);
        payHistory.setBeginTime(beginTime);
        payHistory.setEndTime(cal.getTime());
        // 支付状态 0 未付款 1 已付款
        payHistory.setPayStatus(0);
        // 线上支付
        payHistory.setPayWay(1);
        payHistory.setPrice(pac.getPrice());
        if (null != dbHistoryId && dbHistoryId > 0) {
            payHistory.setId(dbHistoryId);
            // 更新未支付的当前超级会员购买记录
            vipMapper.updatePayHistory(payHistory);
        } else {
            // 新增超级会员购买记录
            vipMapper.addPayHistory(payHistory);
        }
        if (payHistory.getId() > 0) {
            return ResponseJson.success(payHistory.getId());
        }
        return ResponseJson.error("支付开通超级会员异常！", null);
    }


    /**
     * 根据userId查是否过期，返回dto对象，flag=0未买过，-1过期，1有效，endTime过期时间
     */
    private SuperVipDto findEnd(Integer userId) {
        SuperVipPo superVip = vipMapper.findSuperVip(userId);
        SuperVipDto superVipDto = new SuperVipDto();
        Integer clubId = messageCenterMapper.clubIdCule(userId);
        if (superVip == null) {
            superVipDto.setVipFlag(0);
        } else {
            SuperVipPo endTime = vipMapper.findEndTime(userId);
            if (endTime == null) {
                superVipDto.setVipFlag(-1);
                superVipDto.setEndTime(superVip.getEndTime());
            } else {
                superVipDto.setVipFlag(1);
                superVipDto.setEndTime(endTime.getEndTime());
            }
        }
        return superVipDto;
    }

    /**
     * 支付采美豆买会员
     * flag=0未买过，-1过期，1有效，endTime过期时间
     *
     * @param
     * @param beginTime
     */
    private void beanPay(Integer userId, Integer packageId, Date beginTime, Integer repayFlag) {
        String message = "";
        //1.user表扣豆子
        VipPackage pac = vipMapper.findUserPackage(packageId);
        Integer userBeans = vipMapper.findUserBeans(userId);
        BigDecimal b1 = BigDecimal.valueOf(pac.getPrice());
        BigDecimal b2 = BigDecimal.valueOf(pac.getProportion());
        BigDecimal b3 = BigDecimal.valueOf(userBeans);
        BigDecimal multiply = b1.multiply(b2);
        BigDecimal subtract = b3.subtract(multiply);
        String strs = strs(subtract.toString());
        String strs1 = strs(multiply.toString());
        //b3已有豆子-b1价格*b2比例
        Integer integer = Integer.valueOf(strs);
        vipMapper.updateUserBeans(userId, integer);
        //采美豆消费表记录消费
        vipMapper.addUserBeansHistory(userId, Integer.valueOf(strs1));
        Calendar cal = Calendar.getInstance();
        if (repayFlag == 0) {
            SuperVipPo superVip = new SuperVipPo();
            //到期时间now
            beginTime = new Date();
            superVip.setPrice(pac.getPrice());
            superVip.setPackageId(packageId);
            superVip.setBeginTime(beginTime);
            superVip.setUpdateTime(beginTime);
            superVip.setDelFlag(0);
            superVip.setUserId(userId);
            //计算存svip表的到期时间
            cal.setTime(beginTime);
            Integer userPackageTime = vipMapper.findUserPackageTime(packageId);
            cal.add(Calendar.MONTH, userPackageTime);
            superVip.setEndTime(cal.getTime());
            //2.超级会员表更改,重买标记是0生效时间就是now
            vipMapper.addVip(superVip);
            //购买记录表加数据
            superVip.setPayStatus(1);
            superVip.setPayWay(4);
            //新会员开通，开始时间作为历史表的本次购买套餐的开始时间
            setHistory(superVip, beginTime);
            //发短信
            String shortLink = getShortLink(8, 2, "https://www.caimei365.com/user/member.html?userId=" + userId);
            message = "恭喜您成功开通采美平台超级会员，为期" + userPackageTime + "个月，快戳采美网站链接 www.caimei365.com/t/" + shortLink + "或微信搜索“采美采购商城”小程序登录采美平台畅享会员特权吧。关注公众号“采美365网”可获取更多优惠和精彩资讯。退订回T";
            String mobile = vipMapper.findMobile(userId);
            if (mobile != null && mobile != "") {
                remoteCallService.remoteSendSms(2, 1, mobile, message);
            }
        } else if (repayFlag == 1) {
            //有效期内续费
            SuperVipPo superVip = vipMapper.findSuperVip(userId);
            superVip.setUpdateTime(new Date());
            superVip.setPackageId(packageId);
            superVip.setPrice(pac.getPrice());
            //续费加时间
            cal.setTime(beginTime);
            Integer userPackageTime = vipMapper.findUserPackageTime(packageId);
            cal.add(Calendar.MONTH, userPackageTime);
            superVip.setEndTime(cal.getTime());
            //vip表改到期时间
            vipMapper.updateVip(superVip);
            //购买记录表加数据
            superVip.setPayStatus(1);
            superVip.setPayWay(4);
            //需费时历史记录开始时间为svipuser改变前的终止时间
            setHistory(superVip, beginTime);
            //发短信
            String shortLink = getShortLink(8, 2, "https://www.caimei365.com/user/member.html?userId=" + userId);
            message = "恭喜您成功续费采美平台超级会员，为期" + userPackageTime + "个月，快戳采美网站链接 www.caimei365.com/t/" + shortLink + "或微信搜索“采美采购商城”小程序登录采美平台畅享会员特权吧。关注公众号“采美365网”可获取更多优惠和精彩资讯。退订回T";
            String mobile = vipMapper.findMobile(userId);
            if (mobile != null && mobile != "") {
                remoteCallService.remoteSendSms(2, 3, mobile, message);
            }
        } else if (repayFlag == -1) {
            //过期续费
            SuperVipPo superVip = vipMapper.findSuperVip(userId);
            superVip.setPackageId(packageId);
            superVip.setPrice(pac.getPrice());
            //重设生效起始时间
            beginTime = new Date();
            superVip.setUpdateTime(beginTime);
            superVip.setBeginTime(beginTime);
            //到期时间现在时间+套餐时间
            cal.setTime(beginTime);
            Integer userPackageTime = vipMapper.findUserPackageTime(packageId);
            cal.add(Calendar.MONTH, userPackageTime);
            superVip.setEndTime(cal.getTime());
            //vip表改到期时间
            vipMapper.updateVip(superVip);
            //购买记录表加数据
            superVip.setPayStatus(1);
            superVip.setPayWay(4);
            //过期再买，历史表开始时间是现在时间/支付时间
            setHistory(superVip, beginTime);
            //发短信 "https://www-b.caimei365.com/user/member.html?userId=" + userId
            String shortLink = getShortLink(8, 2, "https://www.caimei365.com/user/member.html?userId=" + userId);
            message = "恭喜您成功续费采美平台超级会员，为期" + userPackageTime + "个月，快戳采美网站链接 www.caimei365.com/t/" + shortLink + "或微信搜索“采美采购商城”小程序登录采美平台畅享会员特权吧。关注公众号“采美365网”可获取更多优惠和精彩资讯。退订回T";
            String mobile = vipMapper.findMobile(userId);
            if (mobile != null && mobile != "") {
                remoteCallService.remoteSendSms(2, 3, mobile, message);
            }
        }
        log.info(userId + "消费采美豆" + multiply + "会员到期时间至" + cal.getTime());
    }

    /**
     * 增加sviphistory记录
     */
    private void setHistory(SuperVipPo vip, Date beginTime) {
        Calendar cal = Calendar.getInstance();
        VipPayHistoryPo payHistory = new VipPayHistoryPo();
        VipPackage pac = vipMapper.findUserPackage(vip.getPackageId());
        payHistory.setUserId(vip.getUserId());
        payHistory.setUserBeans(vip.getPrice() * pac.getProportion());
        payHistory.setPayTime(vip.getUpdateTime());
        payHistory.setPayStatus(vip.getPayStatus());
        payHistory.setPayWay(vip.getPayWay());
        payHistory.setPackageId(vip.getPackageId());
        payHistory.setPrice(0.00);
        //开始时间是上一次的结束时间，结束时间是cal+这次买的时间
        payHistory.setBeginTime(beginTime);
        cal.setTime(beginTime);
        cal.add(Calendar.MONTH, pac.getDuration());
        payHistory.setEndTime(cal.getTime());
        vipMapper.addPayHistory(payHistory);
    }

//    public boolean sendSms(int markId, String mobile, String message) {
//        AtomicBoolean returnValue = new AtomicBoolean(false);
//        try {
//            //测试环境手机号允许发短信
//            List<String> list = new ArrayList<>();
//            list.add("15917362709");
//            list.add("15814011616");
//            list.add("13100721916");
//            list.add("15113936829");
//            list.add("15827317748");
//            if ("prod".equals(profile) || list.contains(mobile)) {
//                if (StringUtils.isNotBlank(mobile) && mobile.length() == 11) {
//                    String regex = "^(1[3-9]\\d{9}$)";
//                    Pattern pattern = Pattern.compile(regex);
//                    Matcher matcher = pattern.matcher(mobile);
//                    if (matcher.matches()) {
//                        // 调用 ToolsFeign 发送短信
//                        String jsonStr = smsFeign.getSendSms(mobile, message);
//                        JSONObject parseObject = JSONObject.parseObject(jsonStr);
//                        if (0 == parseObject.getInteger("code")) {
//                            // 保存短信发送条数+count
//                            messagePushMapper.updateSmsSendCount(markId, 1);
//                            returnValue.set(true);
//                        }
//                    }
//                }
//            }
//        } catch (Exception e) {
//            log.error("短信推送异常:", e);
//        }
//        return returnValue.get();
//    }

    private static String strs(String str) {
        if (str.indexOf(".") > 0) {
            str = str.replaceAll("0+?$", "");//删掉尾数为0的字符
            str = str.replaceAll("[.]$", "");//结尾如果是小数点，则去掉
        }
        return str;
    }

    public String getShortLink(int length, int markId, String url) {
        String shortLink = RandomCodeGenerator.generateShortLink(length);
        Integer id = vipMapper.findBYShortLink(shortLink);
        if (id != null && id > 0) {
            getShortLink(length, markId, url);
        }
        vipMapper.insertShortLink(markId, shortLink, url);
        return shortLink;
    }

//    public static void main(String[] args) throws ParseException {
//        Date d=new Date();
//        //1.日期格式
//        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//
//        //2.某天的日期
//        Date da1=sdf.parse("2022-01-01 03:30:16");
//        Long s=(d.getTime()-da1.getTime())/24/60/60/30/1000;
//        //3.输出间隔天数         getTime获取的是毫秒
//        System.out.println(s);
//    }


}