exchange.git - Gitblit

			@@ -1,21 +1,36 @@
			package com.xcong.excoin.modules.coin.service.impl;

			import java.math.BigDecimal;
			import java.text.ParseException;
			import java.text.SimpleDateFormat;
			import java.util.ArrayList;
			import java.util.Calendar;
			import java.util.Date;
			import java.util.GregorianCalendar;
			import java.util.HashMap;
			import java.util.List;
			import java.util.Map;
			import java.util.*;

			import javax.annotation.Resource;

			import com.alibaba.fastjson.JSON;
			import com.alibaba.fastjson.JSONObject;
			import com.xcong.excoin.common.contants.AppContants;
			import com.xcong.excoin.common.enumerates.CoinTypeEnum;
			import com.xcong.excoin.modules.blackchain.service.RocService;
			import com.xcong.excoin.modules.coin.mapper.OrderCoinsDealMapper;
			import com.xcong.excoin.modules.coin.service.CoinService;
			import com.xcong.excoin.modules.member.dao.MemberDao;
			import com.xcong.excoin.modules.member.entity.MemberEntity;
			import com.xcong.excoin.modules.platform.entity.PlatformCnyUsdtExchangeEntity;
			import com.xcong.excoin.modules.platform.entity.PlatformSymbolsCoinEntity;

			import com.xcong.excoin.modules.symbols.constants.SymbolsConstats;
			import com.xcong.excoin.rabbit.producer.OrderSubmitProducer;
			import com.xcong.excoin.trade.CoinTrader;
			import com.xcong.excoin.trade.CoinTraderFactory;
			import com.xcong.excoin.trade.ExchangeTrade;
			import org.apache.commons.collections.CollectionUtils;
			import org.apache.commons.lang3.StringUtils;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;

			import com.baomidou.mybatisplus.core.metadata.IPage;
			import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
			import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
			import com.xcong.excoin.common.LoginUserUtils;
			import com.xcong.excoin.common.enumerates.MemberWalletCoinEnum;
			@@ -29,9 +44,9 @@
			import com.xcong.excoin.modules.coin.entity.OrderCoinsEntity;
			import com.xcong.excoin.modules.coin.mapper.OrderWalletCoinDealMapper;
			import com.xcong.excoin.modules.coin.mapper.OrderWalletCoinMapper;
			import com.xcong.excoin.modules.coin.parameter.dto.FindAllWalletCoinOrderDto;
			import com.xcong.excoin.modules.coin.parameter.vo.FindCollectListVo;
			import com.xcong.excoin.modules.coin.parameter.vo.MemberSelectSymbolsVo;
			import com.xcong.excoin.modules.coin.parameter.vo.OrderWalletCoinDealListVo;
			import com.xcong.excoin.modules.coin.parameter.vo.OrderWalletCoinDealVo;
			import com.xcong.excoin.modules.coin.parameter.vo.OrderWalletCoinListVo;
			import com.xcong.excoin.modules.coin.parameter.vo.OrderWalletCoinVo;
			@@ -41,9 +56,12 @@
			import com.xcong.excoin.modules.member.entity.MemberSelectSymbolsEntity;
			import com.xcong.excoin.modules.member.entity.MemberWalletCoinEntity;
			import com.xcong.excoin.modules.platform.dao.PlatformCnyUsdtExchangeDao;
			import com.xcong.excoin.modules.platform.dao.PlatformSymbolsCoinDao;
			import com.xcong.excoin.modules.platform.dao.TradeSettingDao;
			import com.xcong.excoin.modules.platform.entity.PlatformTradeSettingEntity;
			import com.xcong.excoin.utils.CoinTypeConvert;
			import com.xcong.excoin.utils.MessageSourceUtils;
			import com.xcong.excoin.utils.RedisUtils;

			import cn.hutool.core.collection.CollUtil;
			import cn.hutool.core.util.ObjectUtil;
			@@ -51,437 +69,1082 @@
			import cn.hutool.core.util.StrUtil;

			@Service
			public class OrderCoinServiceImpl extends ServiceImpl<OrderCoinsDao, OrderCoinsEntity> implements OrderCoinService{

			@Resource
			TradeSettingDao platformTradeSettingDao;
			@Resource
			MemberWalletCoinDao memberWalletCoinDao;
			@Resource
			MemberSelectSymbolsDao memberSelectSymbolsDao;
			@Resource
			public class OrderCoinServiceImpl extends ServiceImpl<OrderCoinsDao, OrderCoinsEntity> implements OrderCoinService {

			@Resource
			TradeSettingDao platformTradeSettingDao;
			@Resource
			MemberWalletCoinDao memberWalletCoinDao;
			@Resource
			MemberSelectSymbolsDao memberSelectSymbolsDao;
			@Resource
			PlatformCnyUsdtExchangeDao cnyUsdtExchangeDao;
			@Resource
			OrderCoinsDao orderCoinsDao;
			@Resource
			OrderCoinDealDao orderCoinDealDao;
			@Resource
			MemberAccountFlowEntityDao memberAccountFlowEntityDao;

			@Override
			public String generateSimpleSerialno(String userId) {
			StringBuilder sb = new StringBuilder();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			SimpleDateFormat sd = new SimpleDateFormat("yyyyMMdd");
			Date now = new Date();
			sb.append(sd.format(now));
			Calendar calendar = new GregorianCalendar();
			calendar.setTime(now);
			calendar.add(calendar.DATE, 1);
			Date nextDate = calendar.getTime();
			if (StrUtil.isNotEmpty(userId)) {
			sb.append(userId);
			}
			sb.append(RandomUtil.randomInt(2));
			long count = orderCoinsDao.getOrderCountByToday(sdf.format(now), sdf.format(nextDate));
			count++;
			int size = 4;
			for (int i = 0; i < size - String.valueOf(count).length(); i++) {
			sb.append("0");
			}
			sb.append(count);
			return sb.toString();
			}
			@Resource
			OrderCoinsDao orderCoinsDao;
			@Resource
			OrderCoinDealDao orderCoinDealDao;
			@Resource
			MemberAccountFlowEntityDao memberAccountFlowEntityDao;
			@Resource
			RedisUtils redisUtils;
			@Resource
			PlatformSymbolsCoinDao platformSymbolsCoinDao;

			@Override
			public Result enterTransactionPageOfWalletCoin(String symbol, String type) {
			if (StrUtil.isBlank(symbol)) {
			return Result.fail(MessageSourceUtils.getString("order_service_0001"));
			}
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			//获取该币种的币币账户信息
			MemberWalletCoinEntity walletCoin = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, symbol);

			PlatformTradeSettingEntity tradeSetting = platformTradeSettingDao.findTradeSetting();
			if (ObjectUtil.isEmpty(tradeSetting)) {
			return Result.fail(MessageSourceUtils.getString("order_service_0003"));
			}
			//获取USDT的币币账户信息
			MemberWalletCoinEntity walletCoinUsdt = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId,
			MemberWalletCoinEnum.WALLETCOINCODE.getValue());
			/**
			* todo
			*/
			//获取某个币种的收盘价
			//Double closePrice = symbolsService.getCloseSymbolsBySymbolsName(symbol+"/USDT");
			BigDecimal closePrice = new BigDecimal("100.0000");

			List<MemberSelectSymbolsEntity> memSymbols = memberSelectSymbolsDao.selectSymbolByMemIdAndSymbol(memberId, symbol);
			@Resource
			private CoinTraderFactory factory;

			PlatformCnyUsdtExchangeEntity cnyUsdtExchange = cnyUsdtExchangeDao.getCNYAndUSDTOne();
			BigDecimal cnyUsdt = cnyUsdtExchange.getValue();
			TransactionPageOfWalletCoinVo transactionPageOfWalletCoinVo = new TransactionPageOfWalletCoinVo();
			//是否自选
			if(CollUtil.isEmpty(memSymbols)) {
			transactionPageOfWalletCoinVo.setIsCollect(TransactionPageOfWalletCoinVo.ISCOLLECT_NO);
			}else {
			transactionPageOfWalletCoinVo.setIsCollect(TransactionPageOfWalletCoinVo.ISCOLLECT_YES);
			}
			if (ObjectUtil.isEmpty(walletCoin))
			return Result.fail(MessageSourceUtils.getString("order_service_0003"));
			// 点差
			transactionPageOfWalletCoinVo.setSpread(tradeSetting.getSpread().setScale(4, BigDecimal.ROUND_DOWN));
			// 手续费用率
			transactionPageOfWalletCoinVo.setFeeRatio(tradeSetting.getFeeRatio().setScale(4, BigDecimal.ROUND_DOWN));
			// 用户可用金额
			if(MemberWalletCoinEnum.ENTERTRANSACTIONPAGEOFWALLETCOIN_BUY.getValue().equals(type)) {//买入
			transactionPageOfWalletCoinVo.setAvailableBalance(walletCoinUsdt.getAvailableBalance().setScale(4, BigDecimal.ROUND_DOWN));
			}else {
			transactionPageOfWalletCoinVo.setAvailableBalance(walletCoin.getAvailableBalance().setScale(4, BigDecimal.ROUND_DOWN));
			}
			//当前价
			transactionPageOfWalletCoinVo.setCurrentPrice(closePrice.setScale(4, BigDecimal.ROUND_DOWN));
			//比例
			transactionPageOfWalletCoinVo.setCnyUsdt(cnyUsdt.setScale(4, BigDecimal.ROUND_DOWN));
			//换算成人民币的币种价格
			transactionPageOfWalletCoinVo.setCurrentPriceCny(cnyUsdt.multiply(closePrice).setScale(4, BigDecimal.ROUND_DOWN));

			transactionPageOfWalletCoinVo.setSymbol(symbol);
			transactionPageOfWalletCoinVo.setType(type);
			return Result.ok(transactionPageOfWalletCoinVo);
			}
			@Resource
			private MemberDao memberDao;

			@Override
			@Transactional
			public Result submitSalesWalletCoinOrder(String symbol, Integer type, Integer tradeType, BigDecimal price,
			BigDecimal amount) {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();

			/**
			* todo
			*/
			//查询当前价
			//BigDecimal nowPrice = new BigDecimal(redisUtil.getString(CoinTypeConConvert.convertToKey(symbol+"/USDT")));

			BigDecimal nowPrice = new BigDecimal("10.0000");
			// 获取交易管理的杠杠倍率，手续费率等信息，由平台进行设置
			symbol = symbol.toUpperCase();
			MemberWalletCoinEntity walletCoin = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, symbol);
			if (ObjectUtil.isEmpty(walletCoin)) {
			return Result.fail(MessageSourceUtils.getString("order_service_0003"));
			}
			// 查询交易设置
			PlatformTradeSettingEntity tradeSetting = platformTradeSettingDao.findTradeSetting();
			if(ObjectUtil.isEmpty(tradeSetting)) {
			return Result.fail(MessageSourceUtils.getString("order_service_0009"));
			}
			// 手续费用(手续费=建仓价X数量X手续费率)
			BigDecimal closingPrice = price.multiply(amount).multiply(new BigDecimal(MemberWalletCoinEnum.SUBMITSALESWALLETCOINORDER_SERVICERATE.getValue()));
			//总费用 = 成交价*数量+手续费
			BigDecimal totalPayPrice = price.multiply(amount).add(closingPrice);

			String walletCode = MemberWalletCoinEnum.WALLETCOINCODE.getValue();
			MemberWalletCoinEntity walletCoinUsdt = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId,walletCode);
			if(OrderCoinsEntity.ORDERTYPE_BUY.equals(type)) {
			//买入，所需总费用跟用户USDT金额进行比较
			BigDecimal availableBalance = walletCoinUsdt.getAvailableBalance();
			if (totalPayPrice.compareTo(availableBalance) > 0) {
			return Result.fail(MessageSourceUtils.getString("order_service_0010"));
			}
			}else {
			//卖出，所需总费用跟用户所对应的币种金额进行比较
			BigDecimal availableBalance = walletCoin.getAvailableBalance();
			if (amount.compareTo(availableBalance) > 0) {
			return Result.fail(MessageSourceUtils.getString("order_service_0010"));
			}
			}

			// 创建订单
			OrderCoinsEntity order = new OrderCoinsEntity();
			if (OrderCoinsEntity.TRADETYPE_FIXEDPRICE.equals(tradeType)) {
			// 如果是限价交易直接插入主表数据
			order.setMemberId(memberId);
			order.setOrderNo(generateSimpleSerialno(memberId.toString()));
			order.setOrderType(type);
			order.setSymbol(symbol);
			order.setMarkPrice(nowPrice.setScale(4, BigDecimal.ROUND_DOWN));
			order.setEntrustCnt(amount.setScale(4, BigDecimal.ROUND_DOWN));
			order.setEntrustPrice(price.setScale(4, BigDecimal.ROUND_DOWN));
			order.setDealCnt(amount.setScale(4, BigDecimal.ROUND_DOWN));
			order.setDealPrice(price.setScale(4, BigDecimal.ROUND_DOWN));
			order.setDealAmount(totalPayPrice.setScale(4, BigDecimal.ROUND_DOWN));
			order.setOrderStatus(OrderCoinsEntity.ORDERSTATUS_DODING);
			order.setTradeType(tradeType);
			order.setFeeAmount(closingPrice.setScale(4, BigDecimal.ROUND_DOWN));
			orderCoinsDao.insert(order);

			//更新用户钱包信息
			//冻结相应的资产
			if(OrderCoinsEntity.ORDERTYPE_BUY.equals(type)) {
			//如果是买入，所对应的币种增加，USDT账户减少金额
			BigDecimal availableBalance = walletCoinUsdt.getAvailableBalance().subtract(totalPayPrice);
			BigDecimal frozenBalance = walletCoinUsdt.getFrozenBalance().add(totalPayPrice);
			walletCoinUsdt.setAvailableBalance(availableBalance.setScale(4, BigDecimal.ROUND_DOWN));
			walletCoinUsdt.setFrozenBalance(frozenBalance.setScale(4, BigDecimal.ROUND_DOWN));
			memberWalletCoinDao.updateById(walletCoinUsdt);
			}else {
			//如果是卖出，币种减少，USDT增加
			BigDecimal availableBalance = walletCoin.getAvailableBalance().subtract(amount);
			BigDecimal frozenBalance = walletCoin.getFrozenBalance().add(amount);
			walletCoin.setAvailableBalance(availableBalance.setScale(4, BigDecimal.ROUND_DOWN));
			walletCoin.setFrozenBalance(frozenBalance.setScale(4, BigDecimal.ROUND_DOWN));
			memberWalletCoinDao.updateById(walletCoin);
			}
			} else {
			//如果是市价交易,主表和附表都需要插入数据
			order.setMemberId(memberId);
			order.setOrderNo(generateSimpleSerialno(memberId.toString()));
			order.setOrderType(type);
			order.setSymbol(symbol);
			order.setMarkPrice(nowPrice.setScale(4, BigDecimal.ROUND_DOWN));
			order.setEntrustCnt(amount.setScale(4, BigDecimal.ROUND_DOWN));
			order.setEntrustPrice(price.setScale(4, BigDecimal.ROUND_DOWN));
			order.setDealCnt(amount.setScale(4, BigDecimal.ROUND_DOWN));
			order.setDealPrice(price.setScale(4, BigDecimal.ROUND_DOWN));
			order.setDealAmount(totalPayPrice.setScale(4, BigDecimal.ROUND_DOWN));
			order.setOrderStatus(OrderCoinsEntity.ORDERSTATUS_DONE);
			order.setTradeType(tradeType);
			order.setFeeAmount(closingPrice.setScale(4, BigDecimal.ROUND_DOWN));
			orderCoinsDao.insert(order);

			OrderCoinsDealEntity detail = new OrderCoinsDealEntity();
			detail.setMemberId(memberId);
			detail.setOrderId(order.getId());
			detail.setOrderNo(order.getOrderNo());
			detail.setOrderType(type);
			detail.setTradeType(tradeType);
			detail.setSymbol(symbol);
			detail.setSymbolCnt(amount.setScale(4, BigDecimal.ROUND_DOWN));
			detail.setEntrustPrice(price.setScale(4, BigDecimal.ROUND_DOWN));
			detail.setDealPrice(price.setScale(4, BigDecimal.ROUND_DOWN));
			detail.setDealAmount(totalPayPrice.setScale(4, BigDecimal.ROUND_DOWN));
			detail.setFeeAmount(closingPrice.setScale(4, BigDecimal.ROUND_DOWN));
			orderCoinDealDao.insert(detail);

			if(OrderCoinsEntity.ORDERTYPE_BUY.equals(type)) {
			//如果是买入，所对应的币种增加，USDT账户减少金额
			// 更新用户的可用金额
			walletCoin.setAvailableBalance(walletCoin.getAvailableBalance().add(amount).setScale(4, BigDecimal.ROUND_DOWN));
			memberWalletCoinDao.updateById(walletCoin);

			walletCoinUsdt.setAvailableBalance(walletCoinUsdt.getAvailableBalance().subtract(totalPayPrice).setScale(4, BigDecimal.ROUND_DOWN));
			memberWalletCoinDao.updateById(walletCoinUsdt);
			}else {
			//如果是卖出，币种减少，USDT增加
			walletCoin.setAvailableBalance(walletCoin.getAvailableBalance().subtract(amount).setScale(4, BigDecimal.ROUND_DOWN));
			memberWalletCoinDao.updateById(walletCoin);

			walletCoinUsdt.setAvailableBalance(walletCoinUsdt.getAvailableBalance().add(totalPayPrice).setScale(4, BigDecimal.ROUND_DOWN));
			memberWalletCoinDao.updateById(walletCoinUsdt);
			}
			}
			// 流水记录
			MemberAccountFlowEntity record = new MemberAccountFlowEntity();
			record.setMemberId(memberId);
			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(type)) {
			record.setPrice(totalPayPrice.setScale(4, BigDecimal.ROUND_DOWN));
			record.setSource(MemberAccountFlowEntity.SOURCE_BUY+symbol);
			record.setRemark(MemberAccountFlowEntity.REMARK_BUY+symbol+":"+amount.setScale(4, BigDecimal.ROUND_DOWN));
			} else {
			record.setPrice(totalPayPrice.negate().setScale(4, BigDecimal.ROUND_DOWN));
			record.setSource(MemberAccountFlowEntity.SOURCE_SALE+symbol);
			record.setRemark(MemberAccountFlowEntity.REMARK_SALE+symbol+":"+amount.setScale(4, BigDecimal.ROUND_DOWN));
			}
			record.setSymbol(symbol);
			record.setBalance(walletCoinUsdt.getAvailableBalance().setScale(4, BigDecimal.ROUND_DOWN));

			memberAccountFlowEntityDao.insert(record);

			return Result.ok(MessageSourceUtils.getString("order_service_0011"));
			}
			@Resource
			private OrderSubmitProducer orderSubmitProducer;

			@Override
			public Result getEntrustWalletCoinOrder(String symbol, Integer status) {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			OrderWalletCoinListVo orderWalletCoinListVo = new OrderWalletCoinListVo();

			List<OrderWalletCoinVo> arrayList = new ArrayList<>();
			List<OrderCoinsEntity> findCoinOrderListByMemberIdAndSysmbol = orderCoinsDao.findCoinOrderListByMemberIdAndSysmbol(memberId, symbol, status);
			if(CollUtil.isNotEmpty(findCoinOrderListByMemberIdAndSysmbol)) {
			for(OrderCoinsEntity orderCoinsEntity : findCoinOrderListByMemberIdAndSysmbol) {
			OrderWalletCoinVo entityToVo = OrderWalletCoinMapper.INSTANCE.entityToVo(orderCoinsEntity);
			arrayList.add(entityToVo);
			}
			}
			orderWalletCoinListVo.setOrderWalletCoinVo(arrayList);
			return Result.ok(arrayList);
			}
			@Resource
			private CoinService coinService;

			@Override
			@Transactional
			public Result cancelEntrustWalletCoinOrder(String orderId) {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			OrderCoinsEntity orderCoinsEntity = orderCoinsDao.selectById(orderId);
			if(ObjectUtil.isNotEmpty(orderCoinsEntity) && orderCoinsEntity.getMemberId() == memberId) {
			if(orderCoinsEntity.getOrderStatus() == OrderCoinsEntity.ORDERSTATUS_CANCEL){
			return Result.fail(MessageSourceUtils.getString("order_service_0012"));
			}
			orderCoinsEntity.setOrderStatus(OrderCoinsEntity.ORDERSTATUS_CANCEL);
			orderCoinsDao.updateById(orderCoinsEntity);

			String symbol = orderCoinsEntity.getSymbol();

			if(orderCoinsEntity.getOrderType() == OrderCoinsEntity.TRADETYPE_FIXEDPRICE) {
			//如果是限价买入，撤单将USDT账户冻结金额返回
			String walletCode = MemberWalletCoinEnum.WALLETCOINCODE.getValue();
			MemberWalletCoinEntity walletCoin = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, walletCode);

			if (ObjectUtil.isNotEmpty(walletCoin)) {
			//手续费 = 开仓价数量手续费率
			//返还金额=开仓价*未成交数量+手续费
			BigDecimal returnBalance = orderCoinsEntity.getDealAmount().add(orderCoinsEntity.getFeeAmount());

			walletCoin.setAvailableBalance(walletCoin.getAvailableBalance().add(returnBalance).setScale(4, BigDecimal.ROUND_DOWN));
			walletCoin.setFrozenBalance(walletCoin.getFrozenBalance().subtract(returnBalance).setScale(4, BigDecimal.ROUND_DOWN));
			memberWalletCoinDao.updateById(walletCoin);
			// 流水记录
			MemberAccountFlowEntity record = new MemberAccountFlowEntity();
			record.setSource(MemberAccountFlowEntity.SOURCE_CANCEL);
			record.setRemark(MemberAccountFlowEntity.REMARK_CANCEL+symbol+MemberAccountFlowEntity.REMARK_RETURNBALANCE+returnBalance);
			record.setBalance(walletCoin.getAvailableBalance().setScale(4, BigDecimal.ROUND_DOWN));
			record.setMemberId(memberId);
			record.setSymbol(symbol);
			record.setPrice(returnBalance);
			memberAccountFlowEntityDao.insert(record);
			return Result.ok(MessageSourceUtils.getString("order_service_0013"));
			}
			}else {
			//如果是限价卖出，撤单将对应的钱包冻结金额返回
			MemberWalletCoinEntity walletCoin = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, symbol);
			if (ObjectUtil.isNotEmpty(walletCoin)) {
			//返还金额=开仓价*未成交数量
			BigDecimal returnBalance = walletCoin.getAvailableBalance().add(walletCoin.getFrozenBalance());
			walletCoin.setAvailableBalance(returnBalance.setScale(4, BigDecimal.ROUND_DOWN));
			walletCoin.setFrozenBalance(walletCoin.getFrozenBalance().subtract(returnBalance).setScale(4, BigDecimal.ROUND_DOWN));
			memberWalletCoinDao.updateById(walletCoin);
			// 流水记录
			MemberAccountFlowEntity record = new MemberAccountFlowEntity();
			record.setSource(MemberAccountFlowEntity.SOURCE_CANCEL);
			record.setRemark(MemberAccountFlowEntity.REMARK_CANCEL+symbol+MemberAccountFlowEntity.REMARK_RETURNBALANCE+returnBalance);
			record.setBalance(walletCoin.getAvailableBalance().setScale(4, BigDecimal.ROUND_DOWN));
			record.setMemberId(memberId);
			record.setSymbol(symbol);
			record.setPrice(walletCoin.getFrozenBalance().setScale(4, BigDecimal.ROUND_DOWN));
			memberAccountFlowEntityDao.insert(record);
			return Result.ok(MessageSourceUtils.getString("order_service_0013"));
			}
			}
			OrderCoinsDealEntity detail = new OrderCoinsDealEntity();
			detail.setMemberId(memberId);
			detail.setOrderId(orderCoinsEntity.getId());
			detail.setOrderNo(generateSimpleSerialno(memberId.toString()));
			detail.setOrderType(orderCoinsEntity.getOrderType());
			detail.setTradeType(orderCoinsEntity.getTradeType());
			detail.setSymbol(symbol);
			detail.setOrderStatus(OrderCoinsDealEntity.ORDERSTATUS_CANCEL);
			detail.setSymbolCnt(orderCoinsEntity.getEntrustCnt());
			detail.setEntrustPrice(orderCoinsEntity.getEntrustPrice().setScale(4, BigDecimal.ROUND_DOWN));
			detail.setDealPrice(orderCoinsEntity.getDealPrice().setScale(4, BigDecimal.ROUND_DOWN));
			detail.setDealAmount(orderCoinsEntity.getDealAmount().setScale(4, BigDecimal.ROUND_DOWN));
			detail.setFeeAmount(orderCoinsEntity.getFeeAmount().setScale(4, BigDecimal.ROUND_DOWN));
			orderCoinDealDao.insert(detail);
			}
			return Result.fail(MessageSourceUtils.getString("order_service_0043"));
			}

			@Override
			public Result findAllWalletCoinOrder() {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();

			OrderWalletCoinDealListVo orderWalletCoinDealListVo = new OrderWalletCoinDealListVo();
			List<OrderWalletCoinDealVo> arrayList = new ArrayList<OrderWalletCoinDealVo>();

			List<OrderCoinsDealEntity> selectAllWalletCoinOrder = orderCoinDealDao.selectAllWalletCoinOrder(memberId);
			if(CollUtil.isNotEmpty(selectAllWalletCoinOrder)) {
			for(OrderCoinsDealEntity orderCoinsDealEntity: selectAllWalletCoinOrder) {
			OrderWalletCoinDealVo entityToVo = OrderWalletCoinDealMapper.INSTANCE.entityToVoOrder(orderCoinsDealEntity);
			arrayList.add(entityToVo);
			}
			}
			orderWalletCoinDealListVo.setOrderWalletCoinDealVo(arrayList);
			return Result.ok(orderWalletCoinDealListVo);
			}
			@Override
			public String generateSimpleSerialno(String userId) {
			StringBuilder sb = new StringBuilder();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			SimpleDateFormat sd = new SimpleDateFormat("yyyyMMdd");
			Date now = new Date();
			sb.append(sd.format(now));
			Calendar calendar = new GregorianCalendar();
			calendar.setTime(now);
			calendar.add(calendar.DATE, 1);
			Date nextDate = calendar.getTime();
			if (StrUtil.isNotEmpty(userId)) {
			sb.append(userId);
			}
			sb.append(RandomUtil.randomInt(2));
			long count = orderCoinsDao.getOrderCountByToday(sdf.format(now), sdf.format(nextDate));
			count++;
			int size = 4;
			for (int i = 0; i < size - String.valueOf(count).length(); i++) {
			sb.append("0");
			}
			sb.append(count);
			return sb.toString();
			}

			@Override
			public Result findWalletCoinOrder(Long orderId) {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			OrderCoinsDealEntity selectWalletCoinOrder = orderCoinDealDao.selectWalletCoinOrder(orderId,memberId);
			OrderWalletCoinDealVo entityToVo = OrderWalletCoinDealMapper.INSTANCE.entityToVoOrder(selectWalletCoinOrder);
			return Result.ok(entityToVo);
			}
			@Override
			public Result enterTransactionPageOfWalletCoin(String symbol) {
			if (StrUtil.isBlank(symbol)) {
			return Result.fail(MessageSourceUtils.getString("order_service_0001"));
			}
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			//获取该币种的币币账户信息
			MemberWalletCoinEntity walletCoin = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, symbol);

			@Override
			public Result findCollect(String symbol, Integer type) {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			if(type==1) {
			//添加自选
			MemberSelectSymbolsEntity symbols = new MemberSelectSymbolsEntity();
			symbols.setMemberId(memberId);
			symbols.setSymbol(symbol);
			memberSelectSymbolsDao.insert(symbols);
			return Result.ok(MessageSourceUtils.getString("order_service_0015"));
			}else {
			Map<String, Object> columnMap = new HashMap<>();
			columnMap.put("symbol", symbol);
			columnMap.put("member_id", memberId);
			memberSelectSymbolsDao.deleteByMap(columnMap);;
			return Result.ok(MessageSourceUtils.getString("order_service_0016"));
			}
			}
			PlatformTradeSettingEntity tradeSetting = platformTradeSettingDao.findTradeSetting();
			if (ObjectUtil.isEmpty(tradeSetting)) {
			return Result.fail(MessageSourceUtils.getString("order_service_0003"));
			}
			//获取USDT的币币账户信息
			MemberWalletCoinEntity walletCoinUsdt = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId,
			MemberWalletCoinEnum.WALLETCOINCODE.getValue());

			@Override
			public Result checkIsCollect(String symbol) {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			MemberSelectSymbolsVo memberSelectSymbolsVo = new MemberSelectSymbolsVo();
			List<MemberSelectSymbolsEntity> selectSymbolByMemIdAndSymbol = memberSelectSymbolsDao.selectSymbolByMemIdAndSymbol(memberId, symbol);

			if(CollUtil.isNotEmpty(selectSymbolByMemIdAndSymbol)) {
			memberSelectSymbolsVo.setIsCollect(MemberSelectSymbolsVo.ISCOLLECT_YES);
			}else {
			memberSelectSymbolsVo.setIsCollect(MemberSelectSymbolsVo.ISCOLLECT_NO);
			}
			memberSelectSymbolsVo.setSymbol(symbol);
			return Result.ok(memberSelectSymbolsVo);
			}
			BigDecimal closePrice = new BigDecimal(redisUtils.getString(CoinTypeConvert.convertToKey(symbol + "/USDT")));

			@Override
			public Result findCollectList() {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			Map<String, Object> columnMap = new HashMap<>();
			columnMap.put("member_id", memberId);
			List<MemberSelectSymbolsEntity> selectByMap = memberSelectSymbolsDao.selectByMap(columnMap);

			FindCollectListVo findCollectListVo = new FindCollectListVo();
			List<MemberSelectSymbolsVo> arrayList = new ArrayList<>();
			if(CollUtil.isNotEmpty(selectByMap)) {
			for(MemberSelectSymbolsEntity memberSelectSymbolsEntity : selectByMap) {
			MemberSelectSymbolsVo memberSelectSymbolsVo = new MemberSelectSymbolsVo();
			memberSelectSymbolsVo.setSymbol(memberSelectSymbolsEntity.getSymbol());
			arrayList.add(memberSelectSymbolsVo);
			}
			}
			findCollectListVo.setMemberSelectSymbolsVo(arrayList);

			return Result.ok(findCollectListVo);
			}
			List<MemberSelectSymbolsEntity> memSymbols = memberSelectSymbolsDao.selectSymbolByMemIdAndSymbol(memberId, symbol);

			PlatformCnyUsdtExchangeEntity cnyUsdtExchange = cnyUsdtExchangeDao.getCNYAndUSDTOne();
			BigDecimal cnyUsdt = cnyUsdtExchange.getValue();
			TransactionPageOfWalletCoinVo transactionPageOfWalletCoinVo = new TransactionPageOfWalletCoinVo();
			//是否自选
			if (CollUtil.isEmpty(memSymbols)) {
			transactionPageOfWalletCoinVo.setIsCollect(TransactionPageOfWalletCoinVo.ISCOLLECT_NO);
			} else {
			transactionPageOfWalletCoinVo.setIsCollect(TransactionPageOfWalletCoinVo.ISCOLLECT_YES);
			}
			if (ObjectUtil.isEmpty(walletCoin))
			return Result.fail(MessageSourceUtils.getString("order_service_0003"));
			// 点差
			transactionPageOfWalletCoinVo.setSpread(tradeSetting.getSpread().setScale(4, BigDecimal.ROUND_DOWN));
			// 手续费用率
			transactionPageOfWalletCoinVo.setFeeRatio(tradeSetting.getCoinFeeRatio().setScale(4, BigDecimal.ROUND_DOWN));
			// 用户可用金额
			transactionPageOfWalletCoinVo.setAvailableBalanceBuy(walletCoinUsdt.getAvailableBalance().setScale(4, BigDecimal.ROUND_DOWN));
			transactionPageOfWalletCoinVo.setAvailableBalanceSell(walletCoin.getAvailableBalance().setScale(4, BigDecimal.ROUND_DOWN));
			//当前价
			transactionPageOfWalletCoinVo.setCurrentPrice(closePrice.setScale(4, BigDecimal.ROUND_DOWN));
			//比例
			transactionPageOfWalletCoinVo.setCnyUsdt(cnyUsdt.setScale(4, BigDecimal.ROUND_DOWN));
			//换算成人民币的币种价格
			transactionPageOfWalletCoinVo.setCurrentPriceCny(cnyUsdt.multiply(closePrice).setScale(4, BigDecimal.ROUND_DOWN));

			transactionPageOfWalletCoinVo.setSymbol(symbol);
			return Result.ok(transactionPageOfWalletCoinVo);
			}

			@Override
			@Transactional
			public Result submitSalesWalletCoinOrder(String symbol, Integer type, Integer tradeType, BigDecimal price, BigDecimal amount, BigDecimal entrustAmount) {


			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			BigDecimal nowPriceinBigDecimal = price;
			//查询当前价
			BigDecimal nowPrice = new BigDecimal(redisUtils.getString(CoinTypeConvert.convertToKey(symbol + "/USDT")));
			System.out.println(symbol + "当前价：" + nowPrice);
			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(type) && OrderCoinsEntity.TRADETYPE_MARKETPRICE.equals(tradeType)) {
			amount = entrustAmount.divide(nowPrice, 8, BigDecimal.ROUND_DOWN);
			System.out.println(symbol + "市价量：" + amount);
			}
			// 处理市价
			// 获取交易管理的杠杠倍率，手续费率等信息，由平台进行设置
			symbol = symbol.toUpperCase();
			MemberWalletCoinEntity walletCoin = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, symbol);
			if (ObjectUtil.isEmpty(walletCoin)) {
			return Result.fail(MessageSourceUtils.getString("order_service_0003"));
			}
			// 查询交易设置
			PlatformTradeSettingEntity tradeSetting = platformTradeSettingDao.findTradeSetting();
			if (ObjectUtil.isEmpty(tradeSetting)) {
			return Result.fail(MessageSourceUtils.getString("order_service_0009"));
			}
			// 手续费用(手续费=建仓价X数量X手续费率)
			BigDecimal closingPrice = price.multiply(amount).multiply(tradeSetting.getCoinFeeRatio());
			//总费用 = 成交价*数量+手续费
			BigDecimal totalPayPrice = price.multiply(amount).add(closingPrice);
			BigDecimal totalPayPricCoin = nowPrice.multiply(amount).add(closingPrice);

			String walletCode = MemberWalletCoinEnum.WALLETCOINCODE.getValue();
			MemberWalletCoinEntity walletCoinUsdt = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, walletCode);
			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(type)) {
			//买入，所需总费用跟用户USDT金额进行比较
			BigDecimal availableBalance = walletCoinUsdt.getAvailableBalance();
			if (totalPayPrice.compareTo(availableBalance) > 0 \|\| totalPayPricCoin.compareTo(availableBalance) > 0) {
			return Result.fail(MessageSourceUtils.getString("order_service_0010"));
			}
			} else {
			//卖出，所需总费用跟用户所对应的币种金额进行比较
			BigDecimal availableBalance = walletCoin.getAvailableBalance();
			if (amount.compareTo(availableBalance) > 0) {
			return Result.fail(MessageSourceUtils.getString("order_service_0010"));
			}
			}

			// 创建订单
			OrderCoinsEntity order = new OrderCoinsEntity();
			if ((OrderCoinsEntity.TRADETYPE_FIXEDPRICE.equals(tradeType) && type.equals(1) && price.compareTo(nowPrice) < 0)
			\|\| (OrderCoinsEntity.TRADETYPE_FIXEDPRICE.equals(tradeType) && type.equals(2) && price.compareTo(nowPrice) > 0)) {
			// 如果是限价交易直接插入主表数据
			order.setMemberId(memberId);
			order.setOrderNo(generateSimpleSerialno(memberId.toString()));
			order.setOrderType(type);
			order.setSymbol(symbol);
			order.setMarkPrice(nowPrice);
			order.setEntrustCnt(amount);
			order.setEntrustPrice(price);
			order.setDealCnt(amount);
			order.setDealPrice(price);
			order.setDealAmount(totalPayPrice);
			order.setOrderStatus(OrderCoinsEntity.ORDERSTATUS_DODING);
			order.setTradeType(tradeType);
			order.setFeeAmount(closingPrice);
			orderCoinsDao.insert(order);

			//更新用户钱包信息
			//冻结相应的资产
			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(type)) {
			//如果是买入，所对应的币种增加，USDT账户减少金额
			BigDecimal availableBalance = walletCoinUsdt.getAvailableBalance().subtract(totalPayPrice);
			BigDecimal frozenBalance = walletCoinUsdt.getFrozenBalance().add(totalPayPrice);
			walletCoinUsdt.setAvailableBalance(availableBalance);
			walletCoinUsdt.setFrozenBalance(frozenBalance);
			memberWalletCoinDao.updateById(walletCoinUsdt);
			} else {
			//如果是卖出，币种减少，USDT增加
			BigDecimal availableBalance = walletCoin.getAvailableBalance().subtract(amount);
			BigDecimal frozenBalance = walletCoin.getFrozenBalance().add(amount);
			walletCoin.setAvailableBalance(availableBalance);
			walletCoin.setFrozenBalance(frozenBalance);
			memberWalletCoinDao.updateById(walletCoin);
			}
			} else {
			//如果是市价交易,主表和附表都需要插入数据
			order.setMemberId(memberId);
			order.setOrderNo(generateSimpleSerialno(memberId.toString()));
			order.setOrderType(type);
			order.setSymbol(symbol);
			order.setMarkPrice(nowPrice);
			order.setEntrustCnt(amount);
			order.setEntrustPrice(price);
			order.setDealCnt(amount);
			order.setEntrustAmount(entrustAmount);
			if ((OrderCoinsEntity.TRADETYPE_FIXEDPRICE.equals(tradeType) && type.equals(1) && price.compareTo(nowPrice) >= 0)
			\|\| (OrderCoinsEntity.TRADETYPE_FIXEDPRICE.equals(tradeType) && type.equals(2) && price.compareTo(nowPrice) <= 0)) {
			// 手续费用(手续费=建仓价X数量X手续费率)
			closingPrice = nowPrice.multiply(amount).multiply(tradeSetting.getCoinFeeRatio());
			//总费用 = 成交价*数量+手续费
			totalPayPrice = nowPrice.multiply(amount).add(closingPrice);
			price = nowPrice;
			}
			order.setDealPrice(nowPrice);
			order.setDealAmount(totalPayPrice);
			order.setOrderStatus(OrderCoinsEntity.ORDERSTATUS_DONE);
			order.setTradeType(tradeType);
			order.setFeeAmount(closingPrice);
			orderCoinsDao.insert(order);

			OrderCoinsDealEntity detail = new OrderCoinsDealEntity();
			detail.setMemberId(memberId);
			detail.setOrderId(order.getId());
			detail.setOrderNo(order.getOrderNo());
			detail.setOrderType(type);
			detail.setTradeType(tradeType);
			detail.setSymbol(symbol);
			detail.setSymbolCnt(amount);
			detail.setEntrustPrice(nowPriceinBigDecimal);
			detail.setDealPrice(nowPrice);
			detail.setDealAmount(totalPayPrice);
			detail.setFeeAmount(closingPrice);
			detail.setOrderStatus(OrderCoinsDealEntity.ORDERSTATUS_DONE);
			orderCoinDealDao.insert(detail);

			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(type)) {
			//如果是买入，所对应的币种增加，USDT账户减少金额
			// 更新用户的可用金额
			walletCoin.setAvailableBalance(walletCoin.getAvailableBalance().add(amount));
			memberWalletCoinDao.updateById(walletCoin);

			walletCoinUsdt.setAvailableBalance(walletCoinUsdt.getAvailableBalance().subtract(totalPayPrice));
			memberWalletCoinDao.updateById(walletCoinUsdt);
			} else {
			//如果是卖出，币种减少，USDT增加
			walletCoin.setAvailableBalance(walletCoin.getAvailableBalance().subtract(amount));
			memberWalletCoinDao.updateById(walletCoin);

			BigDecimal subtract = totalPayPrice.subtract(closingPrice).subtract(closingPrice);
			walletCoinUsdt.setAvailableBalance(walletCoinUsdt.getAvailableBalance().add(subtract));
			memberWalletCoinDao.updateById(walletCoinUsdt);
			}
			}
			// 流水记录
			MemberAccountFlowEntity record = new MemberAccountFlowEntity();
			record.setMemberId(memberId);
			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(type)) {
			record.setPrice(totalPayPrice.setScale(4, BigDecimal.ROUND_DOWN));
			record.setSource(MemberAccountFlowEntity.SOURCE_BUY + symbol);
			record.setRemark(MemberAccountFlowEntity.REMARK_BUY + symbol + ":" + amount);
			} else {
			record.setPrice(totalPayPrice.negate().setScale(4, BigDecimal.ROUND_DOWN));
			record.setSource(MemberAccountFlowEntity.SOURCE_SALE + symbol);
			record.setRemark(MemberAccountFlowEntity.REMARK_SALE + symbol + ":" + amount);
			}
			record.setSymbol(symbol);
			record.setBalance(walletCoinUsdt.getAvailableBalance());

			memberAccountFlowEntityDao.insert(record);

			return Result.ok(MessageSourceUtils.getString("order_service_0011"));
			}

			@Override
			public Result submitSalesWalletCoinOrderWithMatch(String symbol, Integer type, Integer tradeType, BigDecimal price, BigDecimal amount, BigDecimal entrustAmount) {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			// 需要实名
			MemberEntity memberEntity = memberDao.selectById(memberId);
			if (!MemberEntity.CERTIFY_STATUS_Y.equals(memberEntity.getCertifyStatus())) {
			return Result.fail(MessageSourceUtils.getString("member_controller_0001"));
			}
			// 需要先
			String phone = memberEntity.getPhone();
			if (!"13632989240".equals(phone) && !"15158130575".equals(phone)) {
			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(type)) {
			// 禁止挂卖
			String string = redisUtils.getString("BUY_LIMIT_KEY_PHONE");
			if (StringUtils.isNotBlank(string) && StringUtils.isNotBlank(phone) && string.contains(phone)) {
			return Result.fail("买入受限");
			}

			if (StringUtils.isNotBlank(string) && StringUtils.isNotBlank(memberEntity.getEmail()) && string.contains(memberEntity.getEmail())) {
			return Result.fail("买入受限");
			}
			// 不能超过800个

			// if (amount != null && amount.compareTo(new BigDecimal("800")) > 0) {
			// return Result.fail("买入额度受限");
			// }
			// BigDecimal bigDecimal = orderCoinDealDao.sumTodayBuyAmount(memberId, symbol);
			// if (bigDecimal == null) {
			// bigDecimal = BigDecimal.ZERO;
			// }
			// amount = amount == null ? BigDecimal.ZERO : amount;
			// bigDecimal = bigDecimal.add(amount);
			// if (bigDecimal != null && bigDecimal.compareTo(new BigDecimal("800")) > 0) {
			// return Result.fail("买入额度受限");
			// }
			// // 挂单不能超过800
			// BigDecimal bigDecimal1 = orderCoinDealDao.sumTodayEntrustCntBuyAmount(memberId, symbol);
			// if (bigDecimal1 == null) {
			// bigDecimal1 = BigDecimal.ZERO;
			// }
			// bigDecimal1 = bigDecimal1.add(amount);
			// if (bigDecimal1 != null && bigDecimal1.compareTo(new BigDecimal("800")) > 0) {
			// return Result.fail("买入额度受限");
			// }
			} else {
			// 判断redis开关
			//String string = redisUtils.getString("SELL_LIMIT_KEY");
			String string = redisUtils.getString("SELL_LIMIT_KEY_PHONE");
			if (StringUtils.isNotBlank(string) && StringUtils.isNotBlank(phone) && string.contains(phone)) {
			return Result.fail("卖出受限");
			}

			if (StringUtils.isNotBlank(string) && StringUtils.isNotBlank(memberEntity.getEmail()) && string.contains(memberEntity.getEmail())) {
			return Result.fail("卖出受限");
			}
			}
			}

			BigDecimal nowPriceinBigDecimal = price;
			//查询当前价
			BigDecimal nowPrice = new BigDecimal(redisUtils.getString(CoinTypeConvert.convertToKey(symbol + "/USDT")));

			// 获取交易管理的杠杠倍率，手续费率等信息，由平台进行设置
			symbol = symbol.toUpperCase();
			MemberWalletCoinEntity walletCoin = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, symbol);
			if (ObjectUtil.isEmpty(walletCoin)) {
			// 创建这个钱包
			walletCoin = new MemberWalletCoinEntity();
			walletCoin.setAvailableBalance(BigDecimal.ZERO);
			walletCoin.setFrozenBalance(BigDecimal.ZERO);
			walletCoin.setTotalBalance(BigDecimal.ZERO);
			walletCoin.setBorrowedFund(BigDecimal.ZERO);
			walletCoin.setMemberId(memberId);
			walletCoin.setWalletCode(symbol);
			memberWalletCoinDao.insert(walletCoin);
			}
			// 查询交易设置
			PlatformTradeSettingEntity tradeSetting = platformTradeSettingDao.findTradeSetting();
			if (ObjectUtil.isEmpty(tradeSetting)) {
			return Result.fail(MessageSourceUtils.getString("order_service_0009"));
			}
			// 手续费用(手续费=建仓价X数量X手续费率)
			BigDecimal closingPrice = BigDecimal.ZERO;
			// 总费用分两种 1，限价交易是价格*数量+手续费 2，市价交易用户输入的金额+手续费
			//总费用 = 成交价*数量+手续费
			BigDecimal totalPayPrice = BigDecimal.ZERO;
			if (OrderCoinsEntity.TRADETYPE_FIXEDPRICE.equals(tradeType)) {
			// 限价
			closingPrice = price.multiply(amount).multiply(tradeSetting.getCoinFeeRatio());
			totalPayPrice = price.multiply(amount).add(closingPrice);
			entrustAmount = price.multiply(amount);
			// 限价买不能高于当前10%
			BigDecimal multiply = nowPrice.multiply(new BigDecimal("1.2"));
			if (price.compareTo(multiply) > 0) {
			return Result.fail("不能高于当前价的120%");
			}
			multiply= nowPrice.multiply(new BigDecimal("0.8"));
			if (price.compareTo(multiply) < 0) {
			return Result.fail("不能低于当前价的80%");
			}

			} else {
			// 市价
			if (OrderCoinsEntity.ORDERTYPE_BUY == type) {
			closingPrice = entrustAmount.multiply(tradeSetting.getCoinFeeRatio());
			totalPayPrice = entrustAmount.add(closingPrice);
			}
			}
			String walletCode = MemberWalletCoinEnum.WALLETCOINCODE.getValue();
			MemberWalletCoinEntity walletCoinUsdt = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, walletCode);
			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(type)) {
			//买入，所需总费用跟用户USDT金额进行比较
			BigDecimal availableBalance = walletCoinUsdt.getAvailableBalance();
			if (totalPayPrice.compareTo(availableBalance) > 0) {
			return Result.fail(MessageSourceUtils.getString("order_service_0010"));
			}
			} else {
			//卖出，用户币是否足够
			BigDecimal availableBalance = walletCoin.getAvailableBalance();
			if (amount.compareTo(availableBalance) > 0) {
			return Result.fail(MessageSourceUtils.getString("order_service_0010"));
			}
			}

			// 首先将单插入到数据库主表（委托表）
			// 创建订单
			OrderCoinsEntity order = new OrderCoinsEntity();
			//根据委托类型生成不同数据
			// 如果是限价交易直接插入主表数据
			order.setMemberId(memberId);
			order.setOrderNo(generateSimpleSerialno(memberId.toString()));
			order.setOrderType(type);
			order.setSymbol(symbol);
			//order.setMarkPrice(nowPrice);

			// 成交量先设置为0
			order.setDealCnt(BigDecimal.ZERO);
			order.setEntrustCnt(BigDecimal.ZERO);
			order.setEntrustPrice(BigDecimal.ZERO);
			// 成交价
			//order.setDealPrice(price);
			// 成交金额
			order.setDealAmount(BigDecimal.ZERO);
			order.setOrderStatus(OrderCoinsEntity.ORDERSTATUS_DODING);
			order.setTradeType(tradeType);
			// 手续费
			order.setFeeAmount(closingPrice);
			if (OrderCoinsEntity.TRADETYPE_FIXEDPRICE.equals(tradeType)) {
			// 限价是需要价格和数量可以得到成交金额
			// 下单量
			order.setEntrustCnt(amount);
			// 下单价格
			order.setEntrustPrice(price);
			order.setEntrustAmount(amount.multiply(price));
			} else {
			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(type)) {
			// 市价只有金额
			order.setEntrustAmount(entrustAmount);
			} else {
			// 市价卖单
			// 下单量
			order.setEntrustCnt(amount);
			// 下单价格
			order.setEntrustPrice(BigDecimal.ZERO);
			order.setEntrustAmount(BigDecimal.ZERO);
			}
			}
			orderCoinsDao.insert(order);

			//更新用户钱包信息
			//冻结相应的资产
			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(type)) {
			//如果是买入，所对应的币种增加，USDT账户减少金额
			coinService.updateWalletBalance(walletCoinUsdt.getId(), totalPayPrice.negate(), totalPayPrice.negate(), entrustAmount);
			} else {
			//如果是卖出，币种减少，USDT增加
			coinService.updateWalletBalance(walletCoin.getId(), amount.negate(), amount.negate(), amount);
			}
			// 加入到撮合
			order.setSymbol(symbol);
			orderSubmitProducer.sendMsg(JSONObject.toJSONString(order));
			return Result.ok(MessageSourceUtils.getString("order_service_0011"));
			}

			@Override
			public Result getEntrustWalletCoinOrder(String symbol, Integer status) {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			OrderWalletCoinListVo orderWalletCoinListVo = new OrderWalletCoinListVo();

			List<OrderWalletCoinVo> arrayList = new ArrayList<>();
			List<OrderCoinsEntity> findCoinOrderListByMemberIdAndSysmbol = orderCoinsDao.findCoinOrderListByMemberIdAndSysmbol(memberId, symbol, status);
			if (CollUtil.isNotEmpty(findCoinOrderListByMemberIdAndSysmbol)) {
			for (OrderCoinsEntity orderCoinsEntity : findCoinOrderListByMemberIdAndSysmbol) {
			OrderWalletCoinVo entityToVo = OrderWalletCoinMapper.INSTANCE.entityToVo(orderCoinsEntity);
			entityToVo.setFeeAmount(entityToVo.getFeeAmount() == null
			? BigDecimal.ZERO : entityToVo.getFeeAmount().setScale(4, BigDecimal.ROUND_DOWN));
			entityToVo.setMarkPrice(entityToVo.getMarkPrice() == null
			? BigDecimal.ZERO : entityToVo.getMarkPrice().setScale(4, BigDecimal.ROUND_DOWN));
			entityToVo.setEntrustCnt(entityToVo.getEntrustCnt() == null
			? BigDecimal.ZERO : entityToVo.getEntrustCnt().setScale(4, BigDecimal.ROUND_DOWN));
			entityToVo.setEntrustPrice(entityToVo.getEntrustPrice() == null
			? BigDecimal.ZERO : entityToVo.getEntrustPrice().setScale(4, BigDecimal.ROUND_DOWN));
			entityToVo.setDealCnt(entityToVo.getDealCnt() == null
			? BigDecimal.ZERO : entityToVo.getDealCnt().setScale(4, BigDecimal.ROUND_DOWN));
			entityToVo.setDealPrice(entityToVo.getDealPrice() == null
			? BigDecimal.ZERO : entityToVo.getDealPrice().setScale(4, BigDecimal.ROUND_DOWN));
			entityToVo.setDealAmount(entityToVo.getDealAmount() == null
			? BigDecimal.ZERO : entityToVo.getDealAmount().setScale(4, BigDecimal.ROUND_DOWN));
			arrayList.add(entityToVo);
			}
			}
			orderWalletCoinListVo.setOrderWalletCoinVo(arrayList);
			return Result.ok(arrayList);
			}

			@Override
			@Transactional
			public Result cancelEntrustWalletCoinOrder(String orderId) {
			// 将这个取消放入redis
			boolean b = redisUtils.setNotExist(AppContants.ORDER_CANCEL_KEY + orderId, orderId, 10);
			if (!b) {
			return Result.ok(MessageSourceUtils.getString("order_service_0012"));
			}
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			OrderCoinsEntity orderCoinsEntity = orderCoinsDao.selectById(orderId);
			if (ObjectUtil.isNotEmpty(orderCoinsEntity) && orderCoinsEntity.getMemberId().equals(memberId)) {
			// 如果是撮合交易单
			if (SymbolsConstats.EXCHANGE_SYMBOLS.contains(orderCoinsEntity.getSymbol())) {
			// 这里先更新状态判断状态防止消息发送过程中的二次提交
			if (!orderCoinsEntity.getOrderStatus().equals(OrderCoinsEntity.ORDERSTATUS_DODING)) {
			// 不是持仓中返回
			return Result.ok(MessageSourceUtils.getString("order_service_0013"));
			}

			// 更新为已取消(可能在这个过程中这个单已经成交)
			orderSubmitProducer.sendCancelMsg(orderId);
			return Result.ok(MessageSourceUtils.getString("order_service_0013"));
			}
			if (orderCoinsEntity.getOrderStatus() == OrderCoinsEntity.ORDERSTATUS_CANCEL \|\| orderCoinsEntity.getOrderStatus() == OrderCoinsEntity.ORDERSTATUS_DONE) {
			return Result.fail(MessageSourceUtils.getString("order_service_0012"));
			}
			orderCoinsEntity.setOrderStatus(OrderCoinsEntity.ORDERSTATUS_CANCEL);
			orderCoinsDao.updateById(orderCoinsEntity);

			String symbol = orderCoinsEntity.getSymbol();

			OrderCoinsDealEntity detail = new OrderCoinsDealEntity();
			detail.setMemberId(memberId);
			detail.setOrderId(orderCoinsEntity.getId());
			detail.setOrderNo(generateSimpleSerialno(memberId.toString()));
			detail.setOrderType(orderCoinsEntity.getOrderType());
			detail.setTradeType(orderCoinsEntity.getTradeType());
			detail.setSymbol(symbol);
			detail.setOrderStatus(OrderCoinsDealEntity.ORDERSTATUS_CANCEL);
			detail.setSymbolCnt(orderCoinsEntity.getEntrustCnt());
			detail.setEntrustPrice(orderCoinsEntity.getEntrustPrice());
			detail.setDealPrice(orderCoinsEntity.getDealPrice());
			detail.setDealAmount(orderCoinsEntity.getDealAmount());
			detail.setFeeAmount(orderCoinsEntity.getFeeAmount());
			orderCoinDealDao.insert(detail);

			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(orderCoinsEntity.getOrderType())) {
			//如果是限价买入，撤单将USDT账户冻结金额返回
			String walletCode = MemberWalletCoinEnum.WALLETCOINCODE.getValue();
			MemberWalletCoinEntity walletCoin = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, walletCode);

			if (ObjectUtil.isNotEmpty(walletCoin)) {
			//手续费 = 开仓价数量手续费率
			//返还金额=开仓价*未成交数量+手续费
			BigDecimal returnBalance = orderCoinsEntity.getDealAmount();

			walletCoin.setAvailableBalance(walletCoin.getAvailableBalance().add(returnBalance));
			walletCoin.setFrozenBalance(walletCoin.getFrozenBalance().subtract(returnBalance));
			memberWalletCoinDao.updateById(walletCoin);
			// 流水记录
			MemberAccountFlowEntity record = new MemberAccountFlowEntity();
			record.setSource(MemberAccountFlowEntity.SOURCE_CANCEL);
			record.setRemark(MemberAccountFlowEntity.REMARK_CANCEL + symbol + MemberAccountFlowEntity.REMARK_RETURNBALANCE + returnBalance);
			record.setBalance(walletCoin.getAvailableBalance());
			record.setMemberId(memberId);
			record.setSymbol(symbol);
			record.setPrice(returnBalance);
			memberAccountFlowEntityDao.insert(record);
			return Result.ok(MessageSourceUtils.getString("order_service_0013"));
			}
			} else {
			//如果是限价卖出，撤单将对应的钱包冻结金额返回
			MemberWalletCoinEntity walletCoin = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, symbol);
			if (ObjectUtil.isNotEmpty(walletCoin)) {

			BigDecimal returnBalance = orderCoinsEntity.getEntrustCnt();
			walletCoin.setAvailableBalance(walletCoin.getAvailableBalance().add(returnBalance));
			walletCoin.setFrozenBalance(walletCoin.getFrozenBalance().subtract(returnBalance));
			memberWalletCoinDao.updateById(walletCoin);
			// 流水记录
			MemberAccountFlowEntity record = new MemberAccountFlowEntity();
			record.setSource(MemberAccountFlowEntity.SOURCE_CANCEL);
			record.setRemark(MemberAccountFlowEntity.REMARK_CANCEL + symbol + MemberAccountFlowEntity.REMARK_RETURNBALANCE + returnBalance);
			record.setBalance(walletCoin.getAvailableBalance());
			record.setMemberId(memberId);
			record.setSymbol(symbol);
			record.setPrice(walletCoin.getFrozenBalance());
			memberAccountFlowEntityDao.insert(record);
			return Result.ok(MessageSourceUtils.getString("order_service_0013"));
			}
			}
			}
			return Result.fail(MessageSourceUtils.getString("order_service_0043"));
			}

			@Override
			@Transactional
			public Result cancelEntrustWalletCoinOrderForMatch(String orderId) {
			//如果redis中没有这个单则不再往下走
			OrderCoinsEntity orderCoinsEntity = orderCoinsDao.selectById(orderId);
			if (orderCoinsEntity == null) {
			return Result.ok("");
			}
			Long memberId = orderCoinsEntity.getMemberId();
			// 取消撮合订单的单
			CoinTrader trader = factory.getTrader(orderCoinsEntity.getSymbol());
			// 从撮合交易系统得到的已成交的数据
			OrderCoinsEntity coinsEntityCancel = trader.cancelOrder(orderCoinsEntity);
			if (coinsEntityCancel == null) {
			// 此时说明撮合系统已经没这个单了不需要继续处理
			// 直接更新状态先
			OrderCoinsEntity update = new OrderCoinsEntity();
			update.setId(Long.valueOf(orderId));
			update.setOrderStatus(OrderCoinsEntity.ORDERSTATUS_CANCEL);
			//orderCoinsEntity.setOrderStatus(OrderCoinsEntity.ORDERSTATUS_CANCEL);
			orderCoinsDao.updateById(update);
			return null;
			}

			if (ObjectUtil.isNotEmpty(orderCoinsEntity)) {
			if (orderCoinsEntity.getOrderStatus() == OrderCoinsEntity.ORDERSTATUS_DONE) {
			// 已完成的直接返回
			return Result.fail(MessageSourceUtils.getString("order_service_0012"));
			}
			OrderCoinsEntity update = new OrderCoinsEntity();
			update.setId(Long.valueOf(orderId));
			update.setOrderStatus(OrderCoinsEntity.ORDERSTATUS_CANCEL);
			//orderCoinsEntity.setOrderStatus(OrderCoinsEntity.ORDERSTATUS_CANCEL);
			orderCoinsDao.updateById(update);

			String symbol = orderCoinsEntity.getSymbol();

			OrderCoinsDealEntity detail = new OrderCoinsDealEntity();
			detail.setMemberId(memberId);
			detail.setOrderId(orderCoinsEntity.getId());
			detail.setOrderNo(generateSimpleSerialno(memberId.toString()));
			detail.setOrderType(orderCoinsEntity.getOrderType());
			detail.setTradeType(orderCoinsEntity.getTradeType());
			detail.setSymbol(symbol);
			detail.setOrderStatus(OrderCoinsDealEntity.ORDERSTATUS_CANCEL);
			detail.setSymbolCnt(BigDecimal.ZERO);
			detail.setEntrustPrice(orderCoinsEntity.getEntrustPrice());
			detail.setDealPrice(BigDecimal.ZERO);
			detail.setDealAmount(BigDecimal.ZERO);
			detail.setFeeAmount(orderCoinsEntity.getFeeAmount());
			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(orderCoinsEntity.getOrderType())) {
			//如果是限价买入，撤单将USDT账户冻结金额返回
			String walletCode = MemberWalletCoinEnum.WALLETCOINCODE.getValue();
			MemberWalletCoinEntity walletCoin = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, walletCode);

			if (ObjectUtil.isNotEmpty(walletCoin)) {
			//手续费 = 开仓价数量手续费率
			//返还金额=开仓价*未成交数量+手续费
			// 这里根据成交的单计算
			BigDecimal dealAmount = coinsEntityCancel.getDealAmount();
			// 市价的按成交额退款
			BigDecimal returnBalance = orderCoinsEntity.getEntrustAmount().subtract(dealAmount);

			// 需要退回的手续费
			BigDecimal returnFee = BigDecimal.ZERO;
			if (returnBalance.compareTo(orderCoinsEntity.getEntrustAmount()) == 0) {
			returnFee = orderCoinsEntity.getFeeAmount();
			} else {
			// 按比例退回
			BigDecimal needFee = orderCoinsEntity.getFeeAmount().multiply(dealAmount.divide(orderCoinsEntity.getEntrustAmount(), 8, BigDecimal.ROUND_DOWN));
			returnFee = orderCoinsEntity.getFeeAmount().subtract(needFee);
			}
			BigDecimal avi = returnBalance.add(returnFee);
			coinService.updateWalletBalance(walletCoin.getId(), avi, null, returnBalance.negate());
			walletCoin.setAvailableBalance(walletCoin.getAvailableBalance().add(returnBalance).add(returnFee));
			walletCoin.setFrozenBalance(walletCoin.getFrozenBalance().subtract(returnBalance));
			//memberWalletCoinDao.updateById(walletCoin);
			// 流水记录
			MemberAccountFlowEntity record = new MemberAccountFlowEntity();
			record.setSource(MemberAccountFlowEntity.SOURCE_CANCEL);
			record.setRemark(MemberAccountFlowEntity.REMARK_CANCEL + symbol + MemberAccountFlowEntity.REMARK_RETURNBALANCE + returnBalance.add(returnFee));
			record.setBalance(walletCoin.getAvailableBalance());
			record.setMemberId(memberId);
			record.setSymbol(symbol);
			record.setPrice(returnBalance);
			memberAccountFlowEntityDao.insert(record);
			return Result.ok(MessageSourceUtils.getString("order_service_0013"));
			}
			} else {
			//如果是限价卖出，撤单将对应的钱包冻结金额返回
			MemberWalletCoinEntity walletCoin = memberWalletCoinDao.selectWalletCoinBymIdAndCode(memberId, symbol);
			if (ObjectUtil.isNotEmpty(walletCoin)) {
			// 卖出按卖出的数量计算手续费
			BigDecimal returnBalance = orderCoinsEntity.getEntrustCnt().subtract(coinsEntityCancel.getDealCnt());
			walletCoin.setAvailableBalance(walletCoin.getAvailableBalance().add(returnBalance));
			walletCoin.setFrozenBalance(walletCoin.getFrozenBalance().subtract(returnBalance));
			//memberWalletCoinDao.updateById(walletCoin);
			coinService.updateWalletBalance(walletCoin.getId(), returnBalance, null, returnBalance.negate());
			// 流水记录
			MemberAccountFlowEntity record = new MemberAccountFlowEntity();
			record.setSource(MemberAccountFlowEntity.SOURCE_CANCEL);
			record.setRemark(MemberAccountFlowEntity.REMARK_CANCEL + symbol + MemberAccountFlowEntity.REMARK_RETURNBALANCE + returnBalance);
			record.setBalance(walletCoin.getAvailableBalance());
			record.setMemberId(memberId);
			record.setSymbol(symbol);
			record.setPrice(walletCoin.getFrozenBalance());
			memberAccountFlowEntityDao.insert(record);
			return Result.ok(MessageSourceUtils.getString("order_service_0013"));
			}
			}
			orderCoinDealDao.insert(detail);
			}
			return Result.fail(MessageSourceUtils.getString("order_service_0043"));
			}

			@Override
			public Result findAllWalletCoinOrder(FindAllWalletCoinOrderDto findAllWalletCoinOrderDto) {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();

			Page<OrderCoinsDealEntity> page = new Page<>(findAllWalletCoinOrderDto.getPageNum(), findAllWalletCoinOrderDto.getPageSize());
			OrderCoinsDealEntity orderCoinsDealEntity = new OrderCoinsDealEntity();
			orderCoinsDealEntity.setMemberId(memberId);
			orderCoinsDealEntity.setSymbol(findAllWalletCoinOrderDto.getSymbol());
			IPage<OrderCoinsDealEntity> list = orderCoinDealDao.findAllWalletCoinOrderInPage(page, orderCoinsDealEntity);
			Page<OrderWalletCoinDealVo> pageEntityToPageVo = OrderWalletCoinDealMapper.INSTANCE.pageEntityToPageVo(list);
			List<OrderWalletCoinDealVo> records = pageEntityToPageVo.getRecords();
			if (CollUtil.isNotEmpty(records)) {
			for (OrderWalletCoinDealVo orderWalletCoinDealVo : records) {
			orderWalletCoinDealVo.setFeeAmount(orderWalletCoinDealVo.getFeeAmount() == null
			? BigDecimal.ZERO : orderWalletCoinDealVo.getFeeAmount().setScale(4, BigDecimal.ROUND_DOWN));

			orderWalletCoinDealVo.setDealAmount(orderWalletCoinDealVo.getDealAmount() == null
			? BigDecimal.ZERO : orderWalletCoinDealVo.getDealAmount().setScale(4, BigDecimal.ROUND_DOWN));

			orderWalletCoinDealVo.setSymbolCnt(orderWalletCoinDealVo.getSymbolCnt() == null
			? BigDecimal.ZERO : orderWalletCoinDealVo.getSymbolCnt().setScale(4, BigDecimal.ROUND_DOWN));

			orderWalletCoinDealVo.setEntrustPrice(orderWalletCoinDealVo.getEntrustPrice() == null
			? BigDecimal.ZERO : orderWalletCoinDealVo.getEntrustPrice().setScale(4, BigDecimal.ROUND_DOWN));

			orderWalletCoinDealVo.setDealPrice(orderWalletCoinDealVo.getDealPrice() == null
			? BigDecimal.ZERO : orderWalletCoinDealVo.getDealPrice().setScale(4, BigDecimal.ROUND_DOWN));
			}
			}


			return Result.ok(pageEntityToPageVo);
			}

			@Override
			public Result findAllWalletCoinOrder() {
			List<OrderCoinsDealEntity> orderCoinsDealEntities = orderCoinDealDao.selectAllCoinDealsOrderBySymbol(CoinTypeEnum.BZZ.toString());
			return Result.ok(orderCoinsDealEntities);
			}

			@Override
			public Result findWalletCoinOrder(Long orderId) {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			OrderCoinsDealEntity selectWalletCoinOrder = orderCoinDealDao.selectWalletCoinOrder(orderId, memberId);
			OrderWalletCoinDealVo entityToVo = OrderWalletCoinDealMapper.INSTANCE.entityToVoOrder(selectWalletCoinOrder);
			if (ObjectUtil.isNotEmpty(entityToVo)) {
			entityToVo.setFeeAmount(entityToVo.getFeeAmount() == null
			? BigDecimal.ZERO : entityToVo.getFeeAmount().setScale(4, BigDecimal.ROUND_DOWN));

			entityToVo.setDealAmount(entityToVo.getDealAmount() == null
			? BigDecimal.ZERO : entityToVo.getDealAmount().setScale(4, BigDecimal.ROUND_DOWN));

			entityToVo.setSymbolCnt(entityToVo.getSymbolCnt() == null
			? BigDecimal.ZERO : entityToVo.getSymbolCnt().setScale(4, BigDecimal.ROUND_DOWN));

			entityToVo.setEntrustPrice(entityToVo.getEntrustPrice() == null
			? BigDecimal.ZERO : entityToVo.getEntrustPrice().setScale(4, BigDecimal.ROUND_DOWN));

			entityToVo.setDealPrice(entityToVo.getDealPrice() == null
			? BigDecimal.ZERO : entityToVo.getDealPrice().setScale(4, BigDecimal.ROUND_DOWN));
			}
			return Result.ok(entityToVo);
			}

			@Override
			public Result findCollect(String symbol, Integer type) {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			if (type == 1) {
			//添加自选
			MemberSelectSymbolsEntity symbols = new MemberSelectSymbolsEntity();
			symbols.setMemberId(memberId);
			symbols.setSymbol(symbol);
			memberSelectSymbolsDao.insert(symbols);
			return Result.ok(MessageSourceUtils.getString("order_service_0015"));
			} else {
			Map<String, Object> columnMap = new HashMap<>();
			columnMap.put("symbol", symbol);
			columnMap.put("member_id", memberId);
			memberSelectSymbolsDao.deleteByMap(columnMap);
			;
			return Result.ok(MessageSourceUtils.getString("order_service_0016"));
			}
			}

			@Override
			public Result checkIsCollect(String symbol) {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			MemberSelectSymbolsVo memberSelectSymbolsVo = new MemberSelectSymbolsVo();
			List<MemberSelectSymbolsEntity> selectSymbolByMemIdAndSymbol = memberSelectSymbolsDao.selectSymbolByMemIdAndSymbol(memberId, symbol);

			if (CollUtil.isNotEmpty(selectSymbolByMemIdAndSymbol)) {
			memberSelectSymbolsVo.setIsCollect(MemberSelectSymbolsVo.ISCOLLECT_YES);
			} else {
			memberSelectSymbolsVo.setIsCollect(MemberSelectSymbolsVo.ISCOLLECT_NO);
			}
			memberSelectSymbolsVo.setSymbol(symbol);
			return Result.ok(memberSelectSymbolsVo);
			}

			@Override
			public Result findCollectList() {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			List<MemberSelectSymbolsEntity> selectByMap = memberSelectSymbolsDao.selectSymbolByMemId(memberId);

			FindCollectListVo findCollectListVo = new FindCollectListVo();
			List<MemberSelectSymbolsVo> arrayList = new ArrayList<>();
			if (CollUtil.isNotEmpty(selectByMap)) {
			for (MemberSelectSymbolsEntity memberSelectSymbolsEntity : selectByMap) {
			MemberSelectSymbolsVo memberSelectSymbolsVo = new MemberSelectSymbolsVo();
			memberSelectSymbolsVo.setSymbol(memberSelectSymbolsEntity.getSymbol());
			arrayList.add(memberSelectSymbolsVo);
			}
			}
			findCollectListVo.setMemberSelectSymbolsVo(arrayList);

			return Result.ok(findCollectListVo);
			}

			@Override
			public Result searchSymbolResultList() {
			//获取用户ID
			Long memberId = LoginUserUtils.getAppLoginUser().getId();
			FindCollectListVo findCollectListVo = new FindCollectListVo();
			List<MemberSelectSymbolsVo> list = new ArrayList<>();

			Map<String, Object> columnMap = new HashMap<>();
			List<PlatformSymbolsCoinEntity> selectByMap = platformSymbolsCoinDao.selectByMap(columnMap);

			List<MemberSelectSymbolsEntity> selectSymbolByMemIdAndSymbol = memberSelectSymbolsDao.selectSymbolByMemId(memberId);
			for (PlatformSymbolsCoinEntity platformSymbolsCoinEntity : selectByMap) {
			MemberSelectSymbolsVo memberSelectSymbolsVo = new MemberSelectSymbolsVo();
			memberSelectSymbolsVo.setSymbol(platformSymbolsCoinEntity.getName());
			if (CollUtil.isNotEmpty(selectSymbolByMemIdAndSymbol)) {
			for (MemberSelectSymbolsEntity memberSelectSymbolsEntity : selectSymbolByMemIdAndSymbol) {
			if (platformSymbolsCoinEntity.getName().equals(memberSelectSymbolsEntity.getSymbol())) {
			memberSelectSymbolsVo.setIsCollect(MemberSelectSymbolsVo.ISCOLLECT_YES);
			}
			}
			} else {
			memberSelectSymbolsVo.setIsCollect(MemberSelectSymbolsVo.ISCOLLECT_NO);
			}
			list.add(memberSelectSymbolsVo);
			}
			findCollectListVo.setMemberSelectSymbolsVo(list);
			return Result.ok(findCollectListVo);
			}

			@Override
			@Transactional(rollbackFor = Exception.class)
			public void dealEntrustCoinOrder() {
			List<String> ignoreTypes = new ArrayList<>();
			ignoreTypes.add(SymbolsConstats.ROC);
			List<OrderCoinsEntity> list = orderCoinsDao.selectAllEntrustingCoinOrderList(ignoreTypes);
			if (CollUtil.isNotEmpty(list)) {
			for (OrderCoinsEntity orderCoinsEntity : list) {
			BigDecimal nowPrice = new BigDecimal(redisUtils.getString(CoinTypeConvert.convertToKey(orderCoinsEntity.getSymbol() + "/USDT")));
			// 下单时市场价
			BigDecimal markPrice = orderCoinsEntity.getMarkPrice();
			// 委托价
			BigDecimal entrustPrice = orderCoinsEntity.getEntrustPrice();

			//如果当时委托价小于市价
			if (entrustPrice.compareTo(markPrice) < 0) {
			if (nowPrice.compareTo(entrustPrice) > 0) {
			continue;
			}
			} else {
			//委托价大于市价
			if (nowPrice.compareTo(entrustPrice) < 0) {
			continue;
			}
			}

			BigDecimal fee = entrustPrice.multiply(orderCoinsEntity.getEntrustCnt()).multiply(new BigDecimal("0.002")).setScale(8, BigDecimal.ROUND_HALF_UP);

			BigDecimal dealAmount = entrustPrice.multiply(orderCoinsEntity.getEntrustCnt());

			OrderCoinsDealEntity orderCoinsDealEntity = OrderCoinsDealMapper.INSTANCE.orderToOrderDeal(orderCoinsEntity);
			orderCoinsDealEntity.setDealAmount(dealAmount);
			orderCoinsDealEntity.setDealPrice(entrustPrice);
			orderCoinsDealEntity.setFeeAmount(fee);
			orderCoinsDealEntity.setOrderStatus(OrderCoinsDealEntity.ORDERSTATUS_DONE);
			orderCoinsDealEntity.setId(null);
			orderCoinDealDao.insert(orderCoinsDealEntity);

			orderCoinsDao.deleteById(orderCoinsEntity.getId());

			MemberWalletCoinEntity walletCoinEntity = memberWalletCoinDao.selectWalletCoinBymIdAndCode(orderCoinsEntity.getMemberId(), orderCoinsEntity.getSymbol());
			MemberWalletCoinEntity usdt = memberWalletCoinDao.selectWalletCoinBymIdAndCode(orderCoinsEntity.getMemberId(), "USDT");

			BigDecimal frozen = BigDecimal.ZERO;
			BigDecimal total = BigDecimal.ZERO;
			// 买入
			if (OrderCoinsEntity.ORDERTYPE_BUY.equals(orderCoinsEntity.getOrderType())) {
			BigDecimal newCoins = walletCoinEntity.getAvailableBalance().add(orderCoinsEntity.getEntrustCnt());
			BigDecimal newCoinTotal = walletCoinEntity.getTotalBalance().add(orderCoinsEntity.getEntrustCnt());
			walletCoinEntity.setAvailableBalance(newCoins);
			walletCoinEntity.setTotalBalance(newCoinTotal);
			memberWalletCoinDao.updateById(walletCoinEntity);

			frozen = usdt.getFrozenBalance().subtract(dealAmount.add(fee));
			total = usdt.getTotalBalance().subtract(dealAmount.add(fee));
			usdt.setFrozenBalance(frozen);
			usdt.setTotalBalance(total);
			memberWalletCoinDao.updateById(usdt);
			} else {
			walletCoinEntity.setFrozenBalance(walletCoinEntity.getFrozenBalance().subtract(orderCoinsEntity.getEntrustCnt()));
			walletCoinEntity.setTotalBalance(walletCoinEntity.getTotalBalance().subtract(orderCoinsEntity.getEntrustCnt()));
			memberWalletCoinDao.updateById(walletCoinEntity);

			usdt.setAvailableBalance(usdt.getAvailableBalance().add(dealAmount.add(fee)));
			usdt.setTotalBalance(usdt.getTotalBalance().add(dealAmount.add(fee)));
			memberWalletCoinDao.updateById(usdt);
			}
			}
			}
			}

			@Transactional
			public void handleOrder(List<ExchangeTrade> trades) {

			// 处理撮合交易的订单
			for (ExchangeTrade exchangeTrade : trades) {
			if (exchangeTrade == null) {
			continue;
			}
			// 量
			BigDecimal amount = exchangeTrade.getAmount();
			// 买单ID
			Long buyOrderId = exchangeTrade.getBuyOrderId();
			// 成交金额（usdt）
			BigDecimal buyTurnover = exchangeTrade.getBuyTurnover();
			int direction = exchangeTrade.getDirection();
			// 成交价
			BigDecimal price = exchangeTrade.getPrice();
			// 卖单
			Long sellOrderId = exchangeTrade.getSellOrderId();

			// 买卖单都需要处理
			// 买单
			OrderCoinsEntity buyOrderCoinsEntity = orderCoinsDao.selectById(buyOrderId);
			if (buyOrderCoinsEntity != null) {
			// 单的总金额
			BigDecimal closingPrice = buyTurnover.multiply(new BigDecimal("0.002"));
			//成交总量
			// 创建一个完成的单
			OrderCoinsDealEntity detail = new OrderCoinsDealEntity();
			detail.setMemberId(buyOrderCoinsEntity.getMemberId());
			detail.setOrderId(buyOrderCoinsEntity.getId());
			detail.setOrderNo(buyOrderCoinsEntity.getOrderNo());
			detail.setOrderType(buyOrderCoinsEntity.getOrderType());
			detail.setTradeType(buyOrderCoinsEntity.getTradeType());
			detail.setSymbol(buyOrderCoinsEntity.getSymbol());
			detail.setSymbolCnt(amount);
			detail.setEntrustPrice(buyOrderCoinsEntity.getEntrustPrice());
			detail.setDealPrice(price);
			detail.setDealAmount(buyTurnover);
			detail.setFeeAmount(closingPrice);
			detail.setOrderStatus(OrderCoinsDealEntity.ORDERSTATUS_DONE);
			// 如果这个单在取消状态则不执行
			orderCoinDealDao.insert(detail);
			// 更新买单
			//orderCoinsDao.updateDeal(buyOrderId, amount, buyTurnover);
			// 买币扣除冻结usdt 增加币种的可用
			MemberWalletCoinEntity usdtWallet = memberWalletCoinDao.selectWalletCoinBymIdAndCode(buyOrderCoinsEntity.getMemberId(), MemberWalletCoinEnum.WALLETCOINCODE.getValue());
			if (usdtWallet != null) {
			// 减少usdt冻结
			coinService.updateWalletBalance(usdtWallet.getId(), null, null, buyTurnover.negate());
			}
			// 增加买的币
			MemberWalletCoinEntity buySymbolWallet = memberWalletCoinDao.selectWalletCoinBymIdAndCode(buyOrderCoinsEntity.getMemberId(), buyOrderCoinsEntity.getSymbol());
			if (buySymbolWallet != null) {
			coinService.updateWalletBalance(buySymbolWallet.getId(), amount, amount, null);
			}
			// 流水记录
			MemberAccountFlowEntity record = new MemberAccountFlowEntity();
			record.setMemberId(buyOrderCoinsEntity.getMemberId());
			record.setPrice(buyTurnover.setScale(4, BigDecimal.ROUND_DOWN).negate());
			record.setSource(MemberAccountFlowEntity.SOURCE_BUY + buyOrderCoinsEntity.getSymbol());
			record.setRemark(MemberAccountFlowEntity.REMARK_BUY + buyOrderCoinsEntity.getSymbol() + ":" + amount);
			record.setSymbol(buyOrderCoinsEntity.getSymbol());
			record.setBalance(usdtWallet.getAvailableBalance().subtract(buyTurnover));
			memberAccountFlowEntityDao.insert(record);
			}

			// 卖单
			OrderCoinsEntity sellOrderCoinsEntity = orderCoinsDao.selectById(sellOrderId);
			if (sellOrderCoinsEntity != null) {
			// 比较剩余的量
			BigDecimal dealAmount = sellOrderCoinsEntity.getDealCnt();
			// 创建一个完成的单
			OrderCoinsDealEntity detail = new OrderCoinsDealEntity();
			detail.setMemberId(sellOrderCoinsEntity.getMemberId());
			detail.setOrderId(sellOrderCoinsEntity.getId());
			detail.setOrderNo(sellOrderCoinsEntity.getOrderNo());
			detail.setOrderType(sellOrderCoinsEntity.getOrderType());
			detail.setTradeType(sellOrderCoinsEntity.getTradeType());
			detail.setSymbol(sellOrderCoinsEntity.getSymbol());
			detail.setSymbolCnt(amount);
			detail.setEntrustPrice(sellOrderCoinsEntity.getEntrustPrice());
			detail.setDealPrice(price);
			detail.setDealAmount(buyTurnover);
			//detail.setFeeAmount(closingPrice);
			detail.setOrderStatus(OrderCoinsDealEntity.ORDERSTATUS_DONE);
			orderCoinDealDao.insert(detail);
			// 如果这个单成交完更改状态
			//orderCoinsDao.updateDeal(sellOrderId, amount, buyTurnover);
			// 卖家需要减少冻结的币种增加usdt
			MemberWalletCoinEntity memberWalletCoinEntity = memberWalletCoinDao.selectWalletCoinBymIdAndCode(sellOrderCoinsEntity.getMemberId(), sellOrderCoinsEntity.getSymbol());
			if (memberWalletCoinEntity != null) {
			// 更新卖币减少的币种
			coinService.updateWalletBalance(memberWalletCoinEntity.getId(), null, null, amount.negate());
			}
			// 更新卖币得到的usdt
			MemberWalletCoinEntity sellWalletCoinEntity = memberWalletCoinDao.selectWalletCoinBymIdAndCode(sellOrderCoinsEntity.getMemberId(), MemberWalletCoinEnum.WALLETCOINCODE.getValue());
			if (sellOrderCoinsEntity != null) {
			coinService.updateWalletBalance(sellWalletCoinEntity.getId(), buyTurnover, buyTurnover, null);
			}
			// 流水记录
			MemberAccountFlowEntity recordSell = new MemberAccountFlowEntity();
			recordSell.setMemberId(sellOrderCoinsEntity.getMemberId());
			recordSell.setPrice(buyTurnover.setScale(4, BigDecimal.ROUND_DOWN));
			recordSell.setSource(MemberAccountFlowEntity.SOURCE_SALE + sellOrderCoinsEntity.getSymbol());
			recordSell.setRemark(MemberAccountFlowEntity.REMARK_SALE + sellOrderCoinsEntity.getSymbol() + ":" + amount.toPlainString());
			recordSell.setSymbol(sellOrderCoinsEntity.getSymbol());
			recordSell.setBalance(sellWalletCoinEntity.getAvailableBalance().add(buyTurnover));
			memberAccountFlowEntityDao.insert(recordSell);
			}
			}
			}

			@Override
			@Transactional
			public void completeOrder(List<OrderCoinsEntity> trades) {
			// 订单完成更新他们的状态
			List<Long> ids = new ArrayList<>();
			if (CollectionUtils.isNotEmpty(trades)) {
			for (OrderCoinsEntity trade : trades) {
			if (trade != null) {
			if (trade.getOrderType() == 2 && trade.getEntrustCnt().compareTo(trade.getDealCnt()) != 0) {
			System.out.println("问题卖单：" + JSON.toJSONString(trade));
			}
			//orderCoinsDao.updateStatus(trade.getId(),OrderCoinsEntity.ORDERSTATUS_DONE);
			ids.add(trade.getId());
			// 买单实际成交金额小于委托的这一部分从冻结扣除
			if (OrderCoinsEntity.ORDERTYPE_BUY == trade.getOrderType()) {
			if (trade.getEntrustAmount().compareTo(trade.getDealAmount()) > 0) {
			// 此时退回这部分的差额
			BigDecimal subtract = trade.getEntrustAmount().subtract(trade.getDealAmount());
			MemberWalletCoinEntity memberWalletCoinEntity = memberWalletCoinDao.selectWalletCoinBymIdAndCode(trade.getMemberId(), CoinTypeEnum.USDT.name());
			if (memberWalletCoinEntity != null) {
			coinService.updateWalletBalance(memberWalletCoinEntity.getId(), subtract, null, subtract.negate());
			}
			}
			}
			}
			}
			}
			if (CollectionUtils.isNotEmpty(ids)) {
			orderCoinsDao.batchUpdateStatus(ids, OrderCoinsEntity.ORDERSTATUS_DONE);
			}
			}

			@Override
			public void initOrders(String symbol, Integer type, Integer tradeType, BigDecimal price,
			BigDecimal amount, BigDecimal entrustAmount) {

			}


			}