java/DolphinEnglish.git

			@@ -25,6 +25,7 @@
			import org.springframework.transaction.annotation.Transactional;

			import javax.annotation.Resource;
			import java.util.ArrayList;
			import java.util.Date;
			import java.util.List;
			import java.util.concurrent.TimeUnit;
			@@ -49,10 +50,14 @@
			private ITOrderService orderService;
			@Resource
			private TokenService tokenService;

			@Override
			public List<TGoodsVO> goodRecommend(Integer userId) {
			return baseMapper.goodRecommend(userId);
			}

			@Override
			public TGoods getById1(Integer goodsId) {
			return this.baseMapper.getById1(goodsId);
			}

			@Override
			@@ -66,9 +71,13 @@
			if (null != goods.getTotal()) {
			// 库存预热，redisson分布式锁
			String key = String.format(RedisConstants.GOOD_STOCK, goods.getId());
			List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getGoodsId, goodId)
			List<TOrder> orderList = orderService.lambdaQuery()
			.eq(TOrder::getGoodsId, goodId)
			.eq(TOrder::getDisabled, 0).list();
			int sum = orderList.stream().map(TOrder::getCount).mapToInt(Integer::intValue).sum();
			int sum = 0;
			if (!orderList.isEmpty()) {
			sum = orderList.stream().map(TOrder::getCount).mapToInt(Integer::intValue).sum();
			}
			// 计算商品剩余可兑换数量
			int number = goods.getTotal() - sum;
			if (number <= 0) {
			@@ -85,6 +94,7 @@
			@Override
			@Transactional(rollbackFor = Exception.class)
			public R<String> goodExchange(GoodExchangeDTO goodExchange, Recipient recipient) {
			// 用户本次兑换数量
			Integer number = goodExchange.getNumber();
			Integer goodId = goodExchange.getGoodId();
			TGoods good = lambdaQuery().eq(TGoods::getId, goodId).one();
			@@ -102,14 +112,40 @@
			return R.exchangeError("兑换失败，当前剩余积分不足！");
			}
			if (null != good.getTotal()) {
			// 检查库存总数是否足够
			List<TOrder> order = orderService.lambdaQuery().eq(TOrder::getGoodsId, goodId)
			.eq(TOrder::getDisabled, 0).list();
			int item;
			if (!order.isEmpty()) {
			item = order.stream().map(TOrder::getCount).collect(Collectors.toList())
			.stream().mapToInt(Integer::intValue).sum();
			} else {
			item = 0;
			}
			boolean canBuy = good.getTotal() - item >= number;
			if (!canBuy) {
			throw new GlobalException("商品库存不足，兑换失败！");
			}
			// 检查用户兑换数量是否超过单用户最大兑换数量
			List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId())
			.eq(TOrder::getGoodsId, goodId).list();
			// 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
			int totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
			.stream().mapToInt(Integer::intValue).sum();
			boolean canExchange = orderList.isEmpty() \|\| null == good.getUserCount() \|\|
			(totalNumber + number) <= good.getUserCount();
			// 用户已兑换数量
			int totalNumber;
			if (orderList.isEmpty()) {
			totalNumber = 0;
			} else {
			// 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
			totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
			.stream().mapToInt(Integer::intValue).sum();
			}
			boolean canExchange = true;
			if (null != good.getUserCount()) {
			if (number > good.getUserCount()) {
			canExchange = false;
			} else {
			canExchange = (totalNumber + number) <= good.getUserCount();
			}
			}
			if (!canExchange) {
			return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量，剩余兑换数量为: " +
			(good.getUserCount() - totalNumber) + "！");
			@@ -127,14 +163,34 @@
			}
			// 兑换成功，生成订单信息、生成积分明细(积分明细需要远程调用rouyi-study服务)
			boolean result = exchangeGood(goodExchange, recipient, number, goodId, needIntegral);
			// 扣除库存
			result = result && this.lambdaUpdate().set(TGoods::getTotal, good.getTotal() - number)
			.eq(TGoods::getId, good.getId()).update();
			if (!result) {
			semaphore.release(number);
			return R.exchangeError("商品兑换失败！");
			}
			} else {
			if (null != good.getUserCount()) {
			// 检查用户兑换数量是否超过单用户最大兑换数量
			List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId())
			.eq(TOrder::getGoodsId, goodId).list();
			int totalNumber;
			if (orderList.isEmpty()) {
			totalNumber = 0;
			} else {
			// 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
			totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
			.stream().mapToInt(Integer::intValue).sum();
			}
			Integer userCount = good.getUserCount();
			if (userCount > totalNumber) {
			int i = userCount - totalNumber;
			if (number > i) {
			return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量，剩余兑换数量为: " +
			i + "！");
			}
			} else {
			return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量！");
			}
			}
			boolean result = exchangeGood(goodExchange, recipient, number, goodId, needIntegral);
			if (!result) {
			return R.exchangeError("商品兑换失败！");
			@@ -142,30 +198,18 @@
			}
			return R.ok();
			}

			private Boolean exchangeGood(GoodExchangeDTO goodExchange, Recipient recipient, Integer number,
			Integer goodId, int needIntegral) {
			// 兑换成功，生成订单信息、生成积分明细(积分明细需要远程调用rouyi-study服务)
			TOrder order = orderInfo(goodExchange, recipient, number, goodId, needIntegral);
			boolean result = orderService.save(order);
			// 远程调用，生成积分明细
			result = result && studyClient.addIntegralDetail(Constants.BURDEN + needIntegral, Constants.SHOPPING_CONSUME).getData();
			// 扣除用户积分
			result = result && studyClient.exchangeIntegral(needIntegral, Constants.BURDEN).getData();
			return result;
			}

			@Override
			@Transactional(rollbackFor = Exception.class)
			public R goodExchange1(GoodExchangeDTO goodExchange, Recipient recipient) {
			// 用户本次兑换数量
			Integer number = goodExchange.getNumber();
			Integer goodId = goodExchange.getGoodId();
			TGoods good = this.getById(goodId);
			TGoods good = lambdaQuery().eq(TGoods::getId, goodId).one();
			if (null == good) {
			return R.exchangeError("商品不存在，请稍后重试！");
			}
			LoginUserParent loginUser1 = tokenService.getLoginUser1();
			if (null == loginUser1){
			if (null == loginUser1) {
			return R.tokenError("登录失效");
			}
			// 校验用户积分是否足够兑换
			@@ -178,14 +222,41 @@
			return R.exchangeError("兑换失败，当前剩余积分不足！");
			}
			if (null != good.getTotal()) {
			// 检查库存总数是否足够
			List<TOrder> order = orderService.lambdaQuery().eq(TOrder::getGoodsId, goodId)
			.eq(TOrder::getDisabled, 0).list();
			int item;
			if (!order.isEmpty()) {
			item = order.stream().map(TOrder::getCount).collect(Collectors.toList())
			.stream().mapToInt(Integer::intValue).sum();
			} else {
			item = 0;
			}
			boolean canBuy = good.getTotal() - item >= number;
			if (!canBuy) {
			return R.exchangeError("商品库存不足，兑换失败！");
			// throw new GlobalException("商品库存不足，兑换失败！");
			}
			// 检查用户兑换数量是否超过单用户最大兑换数量
			List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId())
			.eq(TOrder::getGoodsId, goodId).list();
			// 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
			int totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
			.stream().mapToInt(Integer::intValue).sum();
			boolean canExchange = orderList.isEmpty() \|\| null == good.getUserCount() \|\|
			(totalNumber + number) <= good.getUserCount();
			// 用户已兑换数量
			int totalNumber;
			if (orderList.isEmpty()) {
			totalNumber = 0;
			} else {
			// 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
			totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
			.stream().mapToInt(Integer::intValue).sum();
			}
			boolean canExchange = true;
			if (null != good.getUserCount()) {
			if (number > good.getUserCount()) {
			canExchange = false;
			} else {
			canExchange = (totalNumber + number) <= good.getUserCount();
			}
			}
			if (!canExchange) {
			return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量，剩余兑换数量为: " +
			(good.getUserCount() - totalNumber) + "！");
			@@ -202,21 +273,75 @@
			return R.exchangeError("当前商品库存不足");
			}
			// 兑换成功，生成订单信息、生成积分明细(积分明细需要远程调用rouyi-study服务)
			boolean result = exchangeGood(goodExchange, recipient, number, goodId, needIntegral);
			// 扣除库存
			result = result && this.lambdaUpdate().set(TGoods::getTotal, good.getTotal() - number)
			.eq(TGoods::getId, good.getId()).update();
			boolean result = exchangeGoodParent(goodExchange, recipient, number, goodId, needIntegral);
			if (!result) {
			semaphore.release(number);
			return R.exchangeError("商品兑换失败！");
			}
			} else {
			boolean result = exchangeGood(goodExchange, recipient, number, goodId, needIntegral);
			if (null != good.getUserCount()) {
			// 检查用户兑换数量是否超过单用户最大兑换数量
			List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId())
			.eq(TOrder::getGoodsId, goodId).list();
			int totalNumber;
			if (orderList.isEmpty()) {
			totalNumber = 0;
			} else {
			// 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
			totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
			.stream().mapToInt(Integer::intValue).sum();
			}
			Integer userCount = good.getUserCount();
			if (userCount > totalNumber) {
			int i = userCount - totalNumber;
			if (number > i) {
			return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量，剩余兑换数量为: " +
			i + "！");
			}
			} else {
			return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量！");
			}
			}
			boolean result = exchangeGoodParent(goodExchange, recipient, number, goodId, needIntegral);
			if (!result) {
			return R.exchangeError("商品兑换失败！");
			}
			}
			return R.ok();
			}
			private Boolean exchangeGood(GoodExchangeDTO goodExchange, Recipient recipient, Integer number,
			Integer goodId, int needIntegral) {
			// 兑换成功，生成订单信息、生成积分明细(积分明细需要远程调用rouyi-study服务)
			TOrder order = orderInfo(goodExchange, recipient, number, goodId, needIntegral);
			order.setProvince(recipient.getProvince());
			order.setCity(recipient.getCity());
			boolean result = orderService.save(order);
			// 远程调用，生成积分明细
			result = result && studyClient.addIntegralDetail(Constants.BURDEN + needIntegral, Constants.SHOPPING_CONSUME).getData();
			// 扣除用户积分
			result = result && studyClient.exchangeIntegral(needIntegral, Constants.BURDEN).getData();
			return result;
			}

			private Boolean exchangeGoodParent(GoodExchangeDTO goodExchange, Recipient recipient, Integer number,
			Integer goodId, int needIntegral) {
			// 兑换成功，生成订单信息、生成积分明细(积分明细需要远程调用rouyi-study服务)
			TOrder order = orderInfoParent(goodExchange, recipient, number, goodId, needIntegral);
			order.setProvince(recipient.getProvince());
			order.setCity(recipient.getCity());
			boolean result = orderService.save(order);
			// 远程调用，生成积分明细
			result = result && studyClient.addIntegralDetailParent(Constants.BURDEN + needIntegral, Constants.SHOPPING_CONSUME).getData();
			// 扣除用户积分
			result = result && studyClient.exchangeIntegralParent(needIntegral, Constants.BURDEN).getData();
			return result;
			}



			@Override
			public void updateOne(TGoods dto) {
			this.baseMapper.updateOne(dto);
			}

			private TOrder orderInfo(GoodExchangeDTO goodExchange, Recipient recipient, Integer number, Integer goodId, int needIntegral) {
			@@ -227,10 +352,28 @@
			order.setGoodsId(goodId);
			order.setCount(number);
			order.setState(1);
			order.setRemark(goodExchange.getRemark());
			order.setIntegral(needIntegral);
			order.setConsigneeName(recipient.getRecipient());
			order.setConsigneePhone(recipient.getRecipientPhone());
			order.setConsigneeAddress(recipient.getAddress());
			order.setConsigneeAddress(recipient.getProvince() + recipient.getCity() + recipient.getAddress());
			order.setDisabled(Boolean.FALSE);
			return order;
			}

			private TOrder orderInfoParent(GoodExchangeDTO goodExchange, Recipient recipient, Integer number, Integer goodId, int needIntegral) {
			TOrder order = new TOrder();
			order.setOrderNumber(goodExchange.getOrderNumber());
			order.setUserId(tokenService.getLoginUser1().getUserid());
			order.setInsertTime(new Date());
			order.setGoodsId(goodId);
			order.setCount(number);
			order.setState(1);
			order.setRemark(goodExchange.getRemark());
			order.setIntegral(needIntegral);
			order.setConsigneeName(recipient.getRecipient());
			order.setConsigneePhone(recipient.getRecipientPhone());
			order.setConsigneeAddress(recipient.getProvince() + recipient.getCity() + recipient.getAddress());
			order.setDisabled(Boolean.FALSE);
			return order;
			}