淘宝商品ID字符串化

admin

2022-08-25 c9db68e33f90231b064b8864fc69ccf7d25f5e0b

 service-lijin/src/main/java/com/ks/lijin/service/remote/LijinCreateServiceImpl.java

@@ -1,11 +1,14 @@
package com.ks.lijin.service.remote;


import com.ks.lijin.exception.*;
import com.ks.lijin.mapper.LiJinExpendRecordMapper;
import com.ks.lijin.pojo.DO.LiJinExpendRecord;
import com.ks.lijin.pojo.DO.LiJinProviderAccount;
import com.ks.lijin.pojo.DO.LiJinProviderNotice;
import com.ks.lijin.pojo.DO.LiJinProviderTaoKeAccount;
import com.ks.lijin.pojo.DTO.LiJinCreateParam;
import com.ks.lijin.pojo.DTO.MoneyInfo;
import com.ks.lijin.pojo.DTO.TaoLijinCreateResultDTO;
import com.ks.lijin.pojo.DTO.taobao.TaoKeAppInfo;
import com.ks.lijin.pojo.DTO.taobao.TaoLiJinDTO;
import com.ks.lijin.pojo.Enums.NoticeTypeEnum;
@@ -13,27 +16,45 @@
import com.ks.lijin.service.LiJinProviderAccountService;
import com.ks.lijin.service.LiJinProviderNoticeService;
import com.ks.lijin.service.LijinCreateService;
import com.ks.lijin.service.manager.*;
import com.ks.lijin.util.Constant;
import com.ks.lijin.utils.taobao.TaoBaoUtil;
import com.ks.lijin.utils.taobao.TaoKeApiUtil;
import com.ks.vip.exception.LijinBalanceException;
import com.ks.vip.pojo.DO.UserLijinRecord;
import com.ks.vip.pojo.DO.VipGradePotence;
import com.ks.vip.pojo.Enums.VIPEnum;
import com.ks.vip.service.LijinBalanceService;
import com.ks.vip.service.VipCenterService;
import com.ks.vip.service.VipGradePotenceService;
import com.ks.vip.service.VipGradeService;
import com.yeshi.goods.facade.entity.taobao.TaoBaoGoodsBrief;
import org.apache.dubbo.config.annotation.Reference;
import org.apache.dubbo.config.annotation.Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.task.TaskExecutor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.transaction.annotation.Transactional;
import org.yeshi.utils.MoneyBigDecimalUtil;
import org.yeshi.utils.StringUtil;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;


@Service(version = "1.0")
public class LijinCreateServiceImpl implements LijinCreateService {

    Logger logger = LoggerFactory.getLogger(LijinCreateService.class);

    @Resource(name = "taskExecutor")
    private TaskExecutor executor;
@@ -47,18 +68,84 @@
    @Resource
    private LiJinProviderAccountService liJinProviderAccountService;

    @Resource
    @Reference(version = "1.0", check = false)
    private VipCenterService vipCenterService;

    @Resource
    @Reference(version = "1.0", check = false)
    private VipGradePotenceService vipGradePotenceService;

    @Reference(version = "1.0", check = false)
    private VipGradeService vipGradeService;

    @Reference(version = "1.0", check = false)
    private LijinBalanceService lijinBalanceService;

    @Resource
    private LiJinExpendRecordService liJinExpendRecordService;

    @Resource
    private LiJinProviderTaoKeAccountManager liJinProviderTaoKeAccountManager;

    @Resource
    private RedisTemplate redisTemplate;

    @Resource
    private LijinGoodsManager lijinGoodsManager;

    @Resource
    private LijinDangerGoodsManager lijinDangerGoodsManager;

    @Resource
    private LijinDangerSellerManager lijinDangerSellerManager;

    @Resource
    private LijinConfigManager lijinConfigManager;

    @Resource
    private JedisPool jedisPool;

    @Override
    public BigDecimal getTBLijinAmount(Long actionId, String uid) throws LiJinGoodsException, LiJinUserException, LiJinAmountException {
    public List<MoneyInfo> getMoneyInfo(String uid, List<TaoBaoGoodsBrief> goodsBriefList) {
        VIPEnum vipRank = null;
        if (!StringUtil.isNullOrEmpty(uid)) {
            vipRank = vipCenterService.getVIPEnumByUid(uid);
        }
        if (vipRank == null) {
            vipRank = vipGradeService.getDefaultGrade().getIdentity();
        }
        VipGradePotence potence = vipGradePotenceService.getPotenceByVipEnum(vipRank);
        List<MoneyInfo> list = new ArrayList<>();
        for (TaoBaoGoodsBrief goods : goodsBriefList) {
            MoneyInfo moneyInfo = new MoneyInfo();
            moneyInfo.setGoodsId(goods.getAuctionId() + "");
            moneyInfo.setGoodsType(1);
            try {
                moneyInfo.setLijinAmount(getTBLijinAmount(goods, vipRank));
            } catch (LiJinGoodsException e) {
                e.printStackTrace();
            } catch (LiJinAmountException e) {
                e.printStackTrace();
            }
            //计算返利比例
            BigDecimal rebateRate = potence.getRebatePercent();
            BigDecimal fanliMoney = TaoBaoUtil.getGoodsHongBaoMoney(goods, rebateRate, false);
            moneyInfo.setFanliAmount(fanliMoney);
            moneyInfo.setFirstOrderAmount(null);
            list.add(moneyInfo);
        }

        //获取
        return list;
    }

    @Override
    public BigDecimal getTBLijinAmount(String actionId, String uid) throws LiJinGoodsException, LiJinUserException, LiJinAmountException {

        if (!lijinGoodsManager.todayCanCreate(actionId)) {
            throw new LiJinGoodsException(LiJinGoodsException.CODE_GOODS_CREATED_FULL, "今日礼金创建次数已达上限");
        }


        // 获取用户等级
        VIPEnum vipRank = vipCenterService.getVIPEnumByUid(uid);
        if (vipRank == null) {
@@ -67,6 +154,10 @@

        // 1、判断商品 并计算金额
        BigDecimal money = getTBLijinAmount(actionId, vipRank);

        if (!lijinGoodsManager.isLijinMoneyAvaiable(money)) {
            throw new LiJinAmountException(LiJinAmountException.CODE_LIJIN_AMOUNT_OUTOFRANGE, "礼金未在规定范围内");
        }

        // 2、判断用户
        boolean result = userCanCreateTBLijin(uid, money);
@@ -78,11 +169,15 @@


    @Override
    public BigDecimal getTBLijinAmount(Long actionId, VIPEnum vipRank) throws LiJinGoodsException,LiJinAmountException {
    public BigDecimal getTBLijinAmount(String actionId, VIPEnum vipRank) throws LiJinGoodsException, LiJinAmountException {
        if (!lijinGoodsManager.todayCanCreate(actionId)) {
            throw new LiJinGoodsException(LiJinGoodsException.CODE_GOODS_CREATED_FULL, "今日礼金创建次数已达上限");
        }

        //获取商品可创建的淘礼金面额，若不能创建需要抛出相关的异常（1.商品不支持礼金创建）
        BigDecimal money = null;
        // 1、判断商品
        try{
        try {
            TaoBaoGoodsBrief goods = TaoKeApiUtil.searchGoodsDetail(actionId);
            if (goods == null) {
                throw new LiJinGoodsException(LiJinGoodsException.CODE_GOODS_OFFLINE, "商品下线");
@@ -95,32 +190,66 @@

            //券后价 * 商品佣金比例 * 返利比例
            VipGradePotence potence = vipGradePotenceService.getPotenceByVipEnum(vipRank);
            if (potence != null && potence.getRebatePercent()!= null) {
                money = TaoBaoUtil.getGoodsHongBaoMoney(goods,potence.getRebatePercent(),false);
            if (potence != null && potence.getTaolijinPercent() != null) {
                money = TaoBaoUtil.getGoodsHongBaoMoney(goods, potence.getTaolijinPercent(), false);
            }
        } catch (TaoBaoGoodsDownException e){
        } catch (TaoBaoGoodsDownException e) {
            throw new LiJinGoodsException(LiJinGoodsException.CODE_GOODS_OFFLINE, "商品下线");
        }

        // 金额为空 或者小于零 则抛出异常
        if (money == null || money.compareTo(BigDecimal.valueOf(0)) <= 0) {
            throw new LiJinAmountException(LiJinAmountException.CODE_LIJIN_AMOUNT_OUTOFRANGE,"礼金创建的金额超出规定范围");
        if (!lijinGoodsManager.isLijinMoneyAvaiable(money)) {
            throw new LiJinAmountException(LiJinAmountException.CODE_LIJIN_AMOUNT_OUTOFRANGE, "礼金未在规定范围内");
        }


        return money;
    }

    @Override
    public boolean userCanCreateTBLijin(String uid) throws LiJinUserException {
    public int getTodayLeftCount(String uid, Date registerDate) {
        VipGradePotence potence = vipCenterService.getVipPotence(uid);
        if (potence == null) {
            return 0;
        }
        // 每日最大次数判断
        Integer numMax = potence.getTaolijinMaxNumber();
        if (numMax == null || numMax.intValue() <= 0) {
            return 0;
        }
        // 使用次数已经超过最大次数
        int numExpend = liJinExpendRecordService.countTodayNumByExpend(uid);
        if (registerDate != null) {
            //判断新用户
            String newerHour = lijinConfigManager.getConfigValue("newer-hour");
            String dayPlusCount = lijinConfigManager.getConfigValue("newer-everyday-plus-lijin-count");
            if (!StringUtil.isNullOrEmpty(newerHour) && !StringUtil.isNullOrEmpty(dayPlusCount)) {
                //新用户每日附加次数
                if (System.currentTimeMillis() - registerDate.getTime() < 1000 * 60 * 60L * Integer.parseInt(dayPlusCount)) {
                    numMax += Integer.parseInt(dayPlusCount);
                }
            }
        }

        if (numMax.intValue() > numExpend) {
            return numMax.intValue() - numExpend;
        } else {
            return 0;
        }
    }


    @Override
    public boolean userCanCreateTBLijin(String uid, Date registerDate) throws LiJinUserException {
        VipGradePotence potence = vipCenterService.getVipPotence(uid);
        if (potence == null) {
            return false;
        }


        // 每日最大次数判断
        Integer numMax = potence.getTaolijinMaxNumber();
        if(numMax == null || numMax.intValue() <= 0) {
           throw new LiJinUserException(LiJinUserException.CODE_USER_CREATE_NUM_LIMIT, "用户创建淘礼金的次数超限");
        if (numMax == null || numMax.intValue() <= 0) {
            throw new LiJinUserException(LiJinUserException.CODE_USER_CREATE_NUM_LIMIT, "用户创建淘礼金的次数超限");
        }

        // 每日最大金额判断
@@ -131,13 +260,25 @@

        // 使用次数已经超过最大次数
        int numExpend = liJinExpendRecordService.countTodayNumByExpend(uid);
        if (numMax.intValue() < numExpend){
        if (registerDate != null) {
            //判断新用户
            String newerHour = lijinConfigManager.getConfigValue("newer-hour");
            String dayPlusCount = lijinConfigManager.getConfigValue("newer-everyday-plus-lijin-count");
            if (!StringUtil.isNullOrEmpty(newerHour) && !StringUtil.isNullOrEmpty(dayPlusCount)) {
                //新用户每日附加次数
                if (System.currentTimeMillis() - registerDate.getTime() < 1000 * 60 * 60L * Integer.parseInt(dayPlusCount)) {
                    numMax += Integer.parseInt(dayPlusCount);
                }
            }
        }

        if (numMax.intValue() <= numExpend) {
            throw new LiJinUserException(LiJinUserException.CODE_USER_CREATE_NUM_LIMIT, "用户创建淘礼金的次数超限");
        }

        // 统计已使用金额
        BigDecimal moneyExpend = liJinExpendRecordService.countTodayMoneyByExpend(uid);
        if(moneyExpend != null) {
        if (moneyExpend != null) {
            moneyExpend = BigDecimal.valueOf(0);
        }
        // 消耗金额已经超过最大金额
@@ -148,35 +289,42 @@
    }



    @Override
    public boolean userCanCreateTBLijin(String uid, BigDecimal money) throws LiJinUserException {
        VipGradePotence potence = vipCenterService.getVipPotence(uid);
        if (potence == null) {
            return false;
        }
        //查询礼金余额
        BigDecimal balance = lijinBalanceService.getBalance(uid);
        if (balance != null) {
            if (money.compareTo(balance) > 0) {
                throw new LiJinUserException(LiJinUserException.CODE_USER_BALANCE_NOT_ENOUGH, "礼金余额不足");
            }
        }


        // 每日最大次数判断
        Integer numMax = potence.getTaolijinMaxNumber();
        if(numMax == null || numMax.intValue() <= 0) {
        if (numMax == null || numMax.intValue() <= 0) {
            throw new LiJinUserException(LiJinUserException.CODE_USER_CREATE_NUM_LIMIT, "用户创建淘礼金的次数超限");
        }

        // 每日最大金额判断
        BigDecimal moneyMax = potence.getTaolijinMaxMoney();
        if (moneyMax == null || moneyMax.compareTo(BigDecimal.valueOf(0)) <= 0 || moneyMax.compareTo(money) <= 0 ) {
        if (moneyMax == null || moneyMax.compareTo(BigDecimal.valueOf(0)) <= 0 || moneyMax.compareTo(money) <= 0) {
            throw new LiJinUserException(LiJinUserException.CODE_USER_CREATE_MONEY_LIMIT, "用户创建淘礼金的金额超限");
        }

        // 使用次数已经超过最大次数
        int numExpend = liJinExpendRecordService.countTodayNumByExpend(uid);
        if (numMax.intValue() < numExpend){
        if (numMax.intValue() < numExpend) {
            throw new LiJinUserException(LiJinUserException.CODE_USER_CREATE_NUM_LIMIT, "用户创建淘礼金的次数超限");
        }

        // 统计已使用金额
        BigDecimal moneyExpend = liJinExpendRecordService.countTodayMoneyByExpend(uid);
        if(moneyExpend != null) {
        if (moneyExpend != null) {
            moneyExpend = BigDecimal.valueOf(0);
        }
        // 加上本次需要使用金额
@@ -190,102 +338,233 @@
    }



    @Override
    @Transactional(rollbackFor = Exception.class)
    public LiJinExpendRecord createTBLijin(String uid, Long goodsId) throws LiJinException, LiJinGoodsException, LiJinUserException, LiJinAmountException {
    public LiJinExpendRecord createTBLijin(String uid, String goodsId) throws LiJinException, LiJinGoodsException, LiJinUserException, LiJinAmountException {
        return createTBLijin(uid, null, goodsId);
    }

    @Override
    public LiJinExpendRecord createTBLijin(String uid, Date registerDate, String auctionId) throws LiJinException, LiJinGoodsException, LiJinUserException, LiJinAmountException {

        //用户是否有创建权限
        userCanCreateTBLijin(uid, registerDate);
        //商品是否在危险商品中
        boolean dangerous = lijinDangerGoodsManager.isDangerous(auctionId + "", 1);
        if (dangerous) {
            throw new LiJinGoodsException(LiJinGoodsException.CODE_GOODS_NOT_SUPPORT, "该商品暂无法创建礼金");
        }

        // 获取用户等级
        VIPEnum vipRank = vipCenterService.getVIPEnumByUid(uid);
        if (vipRank == null) {
            vipRank = vipGradeService.getDefaultGrade().getIdentity();
        }

        if (vipRank == null) {
            throw new LiJinUserException(LiJinUserException.CODE_USER_CREATE_NUM_LIMIT, "用户创建淘礼金的次数超限");
        }

        //淘礼金创建
        TaoBaoGoodsBrief goods = null;
        try{
            goods = TaoKeApiUtil.searchGoodsDetail(goodsId);
        } catch (TaoBaoGoodsDownException e){
        try {
            goods = TaoKeApiUtil.searchGoodsDetail(auctionId);
        } catch (TaoBaoGoodsDownException e) {
            throw new LiJinGoodsException(LiJinGoodsException.CODE_GOODS_OFFLINE, "商品下线");
        }
        if (goods == null) {
            throw new LiJinGoodsException(LiJinGoodsException.CODE_GOODS_OFFLINE, "商品下线");
        }

        dangerous = lijinDangerSellerManager.isDangerous(goods.getSellerId() + "", 1);
        if (dangerous) {
            throw new LiJinGoodsException(LiJinGoodsException.CODE_GOODS_NOT_SUPPORT, "该店铺商品暂无法创建礼金");
        }

        // 创建的淘礼金-金额
        BigDecimal lijinAmount = getTBLijinAmount(goods, vipRank);

        // 执行创建淘礼金
        LiJinCreateParam params = getLiJinCreateParam();

        // TODO
       // params.setAppkey();
       //  params.setAppsecret();


        TaoLiJinDTO taoLiJinDTO = executeTaoLiJinAPI(uid, goodsId, lijinAmount, params);
        if (taoLiJinDTO == null) {
            throw new LiJinException(1, "淘宝API推广红包创建失败");
        //查询礼金余额
        BigDecimal balance = lijinBalanceService.getBalance(uid);
        if (balance != null && lijinAmount != null) {
            if (lijinAmount.compareTo(balance) > 0) {
                throw new LiJinUserException(LiJinUserException.CODE_USER_BALANCE_NOT_ENOUGH, "礼金余额不足");
            }
        }

        // 执行创建淘礼金
        LiJinCreateParam params = getLiJinCreateBaseParam();

        //用户创建淘礼金为单线程操作
        String key = "createtblijin-" + uid;

        Jedis jedis = jedisPool.getResource();
        try {
            if (jedis.setnx(key, "1") > 0) {
                jedis.expire(key, 120);
                logger.error("淘礼金创建，用户锁定成功 key:{}", key);
                Date now = new Date();
                try {
                    TaoLijinCreateResultDTO taoLiJinDTO = executeTaoLiJin(auctionId, lijinAmount, params);
                    if (taoLiJinDTO == null) {
                        throw new LiJinException(1, "淘宝API推广红包创建失败");
                    }
                    logger.info("淘礼金创建成功");
                    //添加账号的
                    return addCreateSuccessRecord(uid, auctionId, lijinAmount, params.getTitle(), params.getNum(), taoLiJinDTO);
                } catch (LiJinGoodsException e) {
                    if (e.getCode() == LiJinGoodsException.CODE_GOODS_CREATED_FULL) {
                        lijinGoodsManager.createdFullToday(auctionId, now);
                    }
                    jedis.del(key);
                    logger.info("淘礼金创建，删除锁定成功1 key:{}", key);
                    throw e;
                } finally {
                    jedis.del(key);
                    logger.info("淘礼金创建，删除锁定成功2 key:{}", key);
                }
            } else {
                logger.error("淘礼金创建，用户锁定失败 key:{}", key);
                throw new LiJinException(LiJinException.CODE_SERVER_BUSY, "服务器繁忙，请稍后再试");
            }
        } finally {
            jedis.close();
        }
    }


    /**
     * 添加创建记录
     *
     * @param uid
     * @param goodsId
     * @param lijinAmount
     * @param title
     * @param num
     * @param taoLiJinDTO
     */
    private LiJinExpendRecord addCreateSuccessRecord(String uid, String goodsId, BigDecimal lijinAmount, String title, int num, TaoLijinCreateResultDTO taoLiJinDTO) {
        Date now = new Date();
        // 保存记录
        LiJinExpendRecord record = new LiJinExpendRecord();
        record.setUid(uid);
        record.setGoodsId(goodsId + "");
        record.setTitle(params.getTitle());
        record.setNum(params.getNum());
        record.setTitle(title);
        record.setNum(num);
        record.setMoney(lijinAmount);
        record.setRightsId(taoLiJinDTO.getRightsId());
        record.setSendUrl(taoLiJinDTO.getSendUrl());
        record.setAccountId(taoLiJinDTO.getAccount().getId());
        record.setRightsId(taoLiJinDTO.getTaoLiJin().getRightsId());
        record.setSendUrl(taoLiJinDTO.getTaoLiJin().getSendUrl());
        record.setCreateTime(new Date());
        liJinExpendRecordMapper.insertSelective(record);
        logger.info("添加到创建记录成功");

        //添加
        liJinProviderTaoKeAccountManager.createLijinSuccess(taoLiJinDTO.getAccount().getId(), goodsId, lijinAmount.multiply(new BigDecimal(num)), now);
        logger.info("执行淘礼金创建成功事件成功");
        //礼金余额扣除
        try {
            lijinBalanceService.consumeLijin(uid, lijinAmount, "购物抵现", UserLijinRecord.Category.createGoodsLijin.name(), record.getId() + "");
            logger.info("扣除账户余额成功");
        } catch (LijinBalanceException e) {
            e.printStackTrace();
            logger.info("扣除账户余额失败：{}", e.getMessage());
        }

        return record;
    }


    // 创建淘礼金
    private TaoLiJinDTO executeTaoLiJinAPI(String uid, Long goodsId, BigDecimal lijinAmount, LiJinCreateParam params) throws LiJinGoodsException {
        String appkey =params.getAppkey();
        String appsecret = params.getAppsecret();

        // 创建淘礼金红包
        TaoLiJinDTO taoLiJinDTO = null;
        try {
            taoLiJinDTO = TaoKeApiUtil.createTaoLiJin(goodsId, params.getTitle(), lijinAmount,
                    params.getNum(), params.getSendStartTime(), params.getSendEndTime(),
                    params.getUseStartTime(), params.getUseEndTime(), new TaoKeAppInfo(appkey, appsecret, params.getPid()));
        } catch (LiJinException e) {
            // 通知相应供应商  TODO
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    LiJinProviderAccount account  = liJinProviderAccountService.getByAppInfo(appkey, appsecret);
                    if (account == null) {
                        return;
                    }
                    LiJinProviderNotice notice = new LiJinProviderNotice();
                    notice.setRead(false);
                    notice.setProviderId(account.getProviderId());

                    if (e.getCode() == LiJinException.CODE_TLJ_FORBIDDEN) {
                        // 该商品不支持创建淘礼金红包
                    } else if (e.getCode() == LiJinException.CODE_TLJ_NO_MONEY) {
                        // 官方玩法钱包余额不足
                        notice.setTitle("玩法钱包余额不足");
                        notice.setContent("账号："+ appkey +"官方玩法钱包余额不足");
                        notice.setType(NoticeTypeEnum.noMoney.name());
                        liJinProviderNoticeService.save(notice);
                    } else if (e.getCode() == LiJinException.CODE_TLJ_UN_PAID) {
                        // 未创建账户
                    }
                }
            });
    /**
     * 调用账号以及淘宝API
     *
     * @param goodsId
     * @param lijinAmount
     * @param params
     * @return
     * @throws LiJinGoodsException
     * @throws LiJinException
     */
    private TaoLijinCreateResultDTO executeTaoLiJin(String goodsId, BigDecimal lijinAmount, LiJinCreateParam params) throws LiJinGoodsException, LiJinException, LiJinAmountException {
        // 查询供应商账号信息
        List<LiJinProviderTaoKeAccount> listAccount = liJinProviderAccountService.listValidByProviderId(Constant.PROVIDER_DEFAULT_ID, LiJinProviderTaoKeAccount.ERROR_CODE_NORMAL);
        if (listAccount == null || listAccount.size() == 0) {
            throw new LiJinException(1, "没有可用的供应商账号");
        }
        return taoLiJinDTO;
        logger.info("获取供应商淘礼金账号成功");

        // 遍历账号 用可使用账号
        for (LiJinProviderTaoKeAccount account : listAccount) {
            params.setAppkey(account.getAppKey());
            params.setAppsecret(account.getAppSecret());
            params.setPid(account.getPid());
            try {
                //创建礼金
                return new TaoLijinCreateResultDTO(account, executeTaoLiJinAPI(goodsId, lijinAmount, params));
            } catch (LiJinAccountException e) {// 账号问题
                logger.info("获取供应商淘礼账号出错：{}", e.getMessage());
                //更新账号的错误信息
                LiJinProviderTaoKeAccount update = new LiJinProviderTaoKeAccount();
                update.setId(account.getId());
                if (e.getCode() == LiJinAccountException.CODE_TLJ_NO_MONEY) {
                    //资金不足
                    update.setErrorCode(LiJinProviderTaoKeAccount.ERROR_CODE_MONEY_NOT_ENOUGH);
                } else if (e.getCode() == LiJinAccountException.CODE_TLJ_NO_GOODS) {
                    //商品数量不足
                    update.setErrorCode(LiJinProviderTaoKeAccount.ERROR_CODE_GOODS_NOT_ENOUGH);
                } else {
                    //账号异常
                    update.setErrorCode(LiJinProviderTaoKeAccount.ERROR_CODE_OTHER);
                }
                update.setErrorMsg(e.getMsg());
                update.setUpdateTime(new Date());
                liJinProviderAccountService.updateByPrimaryKeySelective(update);

                // 通知相应供应商  TODO
                executor.execute(new Runnable() {
                    @Override
                    public void run() {
                        LiJinProviderNotice notice = new LiJinProviderNotice();
                        notice.setRead(false);
                        notice.setProviderId(account.getProviderId());
                        if (e.getCode() == LiJinAccountException.CODE_TLJ_NO_MONEY) {
                            // 官方玩法钱包余额不足
                            notice.setTitle("玩法钱包余额不足");
                            notice.setContent("账号：" + account.getAccountName() + "官方玩法钱包余额不足");
                            notice.setType(NoticeTypeEnum.noMoney.name());
                            liJinProviderNoticeService.save(notice);
                        } else if (e.getCode() == LiJinAccountException.CODE_TLJ_UN_PAID) {
                            // 未创建账户
                        }
                    }
                });
            }
        }
        throw new LiJinException(1, "没有可用的供应商账号");
    }


    private BigDecimal getTBLijinAmount(TaoBaoGoodsBrief goods, VIPEnum vipRank) throws LiJinGoodsException,LiJinAmountException {
    private TaoLiJinDTO executeTaoLiJinAPI(String goodsId, BigDecimal lijinAmount, LiJinCreateParam params) throws LiJinException, LiJinGoodsException, LiJinAccountException, LiJinAmountException {
        return TaoKeApiUtil.createTaoLiJin(goodsId, params.getTitle(), lijinAmount,
                params.getNum(), params.getSendStartTime(), params.getSendEndTime(),
                params.getUseStartTime(), params.getUseEndTime(), new TaoKeAppInfo(params.getAppkey(), params.getAppsecret(), params.getPid()));
    }


    /**
     * 获取商品可创建的礼金金额
     *
     * @param goods   商品
     * @param vipRank 会员等级
     * @return
     * @throws LiJinGoodsException
     * @throws LiJinAmountException
     */
    private BigDecimal getTBLijinAmount(TaoBaoGoodsBrief goods, VIPEnum vipRank) throws
            LiJinGoodsException, LiJinAmountException {
        if (!lijinGoodsManager.todayCanCreate(goods.getAuctionId())) {
            throw new LiJinGoodsException(LiJinGoodsException.CODE_GOODS_CREATED_FULL, "今日礼金创建次数已达上限");
        }
        //获取商品可创建的淘礼金面额，若不能创建需要抛出相关的异常（1.商品不支持礼金创建）
        BigDecimal money = null;

@@ -296,22 +575,23 @@

        //券后价 * 商品佣金比例 * 返利比例
        VipGradePotence potence = vipGradePotenceService.getPotenceByVipEnum(vipRank);
        if (potence != null && potence.getRebatePercent()!= null) {
            money = TaoBaoUtil.getGoodsHongBaoMoney(goods,potence.getRebatePercent(),false);
        if (potence != null && potence.getTaolijinPercent() != null) {
            money = TaoBaoUtil.getGoodsHongBaoMoney(goods, potence.getTaolijinPercent(), false);
        }

        // 金额为空 或者小于零 则抛出异常
        if (money == null || money.compareTo(BigDecimal.valueOf(0)) <= 0) {
            throw new LiJinAmountException(LiJinAmountException.CODE_LIJIN_AMOUNT_OUTOFRANGE,"礼金创建的金额超出规定范围");
        if (!lijinGoodsManager.isLijinMoneyAvaiable(money)) {
            throw new LiJinAmountException(LiJinAmountException.CODE_LIJIN_AMOUNT_OUTOFRANGE, "礼金未在规定范围内");
        }

        return money;
    }

    /**
     * 创建淘礼金基本参数
     *
     * @return
     */
    private LiJinCreateParam getLiJinCreateParam() {
    private LiJinCreateParam getLiJinCreateBaseParam() {
        Date date = new Date();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat formatStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");