package com.xcong.excoin.modules.documentary.service.impl;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.validation.Valid;

import com.xcong.excoin.modules.documentary.common.NoticeConstant;
import com.xcong.excoin.modules.member.entity.MemberSettingEntity;
import com.xcong.excoin.modules.member.parameter.vo.MemberMessageReminderVo;
import com.xcong.excoin.utils.*;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestBody;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.taobao.api.internal.toplink.embedded.websocket.util.StringUtil;
import com.xcong.excoin.common.LoginUserUtils;
import com.xcong.excoin.common.response.Result;
import com.xcong.excoin.modules.coin.dao.OrderCoinsDao;
import com.xcong.excoin.modules.coin.parameter.dto.RecordsPageDto;
import com.xcong.excoin.modules.contract.dao.ContractHoldOrderDao;
import com.xcong.excoin.modules.contract.dao.ContractOrderDao;
import com.xcong.excoin.modules.contract.entity.ContractEntrustOrderEntity;
import com.xcong.excoin.modules.contract.entity.ContractHoldOrderEntity;
import com.xcong.excoin.modules.contract.entity.ContractOrderEntity;
import com.xcong.excoin.modules.documentary.dao.FollowFollowerNoticeDao;
import com.xcong.excoin.modules.documentary.dao.FollowFollowerOrderRelationDao;
import com.xcong.excoin.modules.documentary.dao.FollowFollowerProfitDao;
import com.xcong.excoin.modules.documentary.dao.FollowFollowerSettingDao;
import com.xcong.excoin.modules.documentary.dao.FollowTraderInfoDao;
import com.xcong.excoin.modules.documentary.dao.FollowTraderLabelDao;
import com.xcong.excoin.modules.documentary.dao.FollowTraderProfitDetailDao;
import com.xcong.excoin.modules.documentary.dao.FollowTraderProfitInfoDao;
import com.xcong.excoin.modules.documentary.dto.BeTraderDto;
import com.xcong.excoin.modules.documentary.dto.CancelDocumentaryOrderSetDto;
import com.xcong.excoin.modules.documentary.dto.DocumentaryOrderSetDto;
import com.xcong.excoin.modules.documentary.dto.FollowFollowerNoticeDto;
import com.xcong.excoin.modules.documentary.dto.FollowRecordsDto;
import com.xcong.excoin.modules.documentary.dto.FollowTraderProfitInfoDto;
import com.xcong.excoin.modules.documentary.dto.HistoryOrderRecordsDto;
import com.xcong.excoin.modules.documentary.dto.MyFollowOrderDto;
import com.xcong.excoin.modules.documentary.dto.MyFollowTraderInfoDto;
import com.xcong.excoin.modules.documentary.dto.OutFollowInfoDto;
import com.xcong.excoin.modules.documentary.dto.TradeFollowInfoDto;
import com.xcong.excoin.modules.documentary.dto.TradeOrderInfoDto;
import com.xcong.excoin.modules.documentary.dto.UpdateDocumentaryOrderSetDto;
import com.xcong.excoin.modules.documentary.dto.UpdateTradeSetInfoDto;
import com.xcong.excoin.modules.documentary.entity.FollowFollowerNoticeEntity;
import com.xcong.excoin.modules.documentary.entity.FollowFollowerOrderRelationEntity;
import com.xcong.excoin.modules.documentary.entity.FollowFollowerProfitEntity;
import com.xcong.excoin.modules.documentary.entity.FollowFollowerSettingEntity;
import com.xcong.excoin.modules.documentary.entity.FollowTraderInfoEntity;
import com.xcong.excoin.modules.documentary.entity.FollowTraderLabelEntity;
import com.xcong.excoin.modules.documentary.entity.FollowTraderProfitInfoEntity;
import com.xcong.excoin.modules.documentary.service.DocumentaryService;
import com.xcong.excoin.modules.documentary.vo.BeTraderConditionVo;
import com.xcong.excoin.modules.documentary.vo.DocumentaryOrderInfoVo;
import com.xcong.excoin.modules.documentary.vo.DocumentaryOrderSetInfoVo;
import com.xcong.excoin.modules.documentary.vo.DocumentaryOrderSetStateVo;
import com.xcong.excoin.modules.documentary.vo.FollowFollowerNoticeVo;
import com.xcong.excoin.modules.documentary.vo.FollowInfoVo;
import com.xcong.excoin.modules.documentary.vo.FollowRecordsVo;
import com.xcong.excoin.modules.documentary.vo.FollowTraderProfitInfoVo;
import com.xcong.excoin.modules.documentary.vo.HistoryOrderRecordsVo;
import com.xcong.excoin.modules.documentary.vo.MemberIsTradeVo;
import com.xcong.excoin.modules.documentary.vo.MyFollowOrderVo;
import com.xcong.excoin.modules.documentary.vo.MyFollowTraderInfoVo;
import com.xcong.excoin.modules.documentary.vo.TradeFollowInfoVo;
import com.xcong.excoin.modules.documentary.vo.TradeHistoryOrderInfoVo;
import com.xcong.excoin.modules.documentary.vo.TradeOrderInfoVo;
import com.xcong.excoin.modules.documentary.vo.TradeProfitInfoVo;
import com.xcong.excoin.modules.documentary.vo.TradeSetInfoVo;
import com.xcong.excoin.modules.documentary.vo.TradeSetLabelInfoVo;
import com.xcong.excoin.modules.documentary.vo.TraderStatusVo;
import com.xcong.excoin.modules.member.dao.MemberDao;
import com.xcong.excoin.modules.member.dao.MemberLevelRateDao;
import com.xcong.excoin.modules.member.dao.MemberSettingDao;
import com.xcong.excoin.modules.member.dao.MemberWalletContractDao;
import com.xcong.excoin.modules.member.entity.MemberEntity;
import com.xcong.excoin.modules.member.entity.MemberLevelRateEntity;
import com.xcong.excoin.modules.member.entity.MemberWalletContractEntity;
import com.xcong.excoin.modules.platform.entity.PlatformTradeSettingEntity;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import jnr.ffi.Struct.int16_t;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class DocumentaryServiceImpl extends ServiceImpl<FollowTraderProfitInfoDao, FollowTraderProfitInfoEntity> implements DocumentaryService {

	@Resource
    private MemberDao memberDao;
	@Resource
	private FollowTraderInfoDao followTraderInfoDao;
	@Resource
	private FollowTraderProfitDetailDao followTraderProfitDetailDao;
	@Resource
	private FollowTraderProfitInfoDao followTraderProfitInfoDao;
	@Resource
	private FollowFollowerProfitDao followFollowerProfitDao;
	@Resource
	private OrderCoinsDao orderCoinsDao;
	@Resource
	private RedisUtils redisUtils;
    @Resource
    private CacheSettingUtils cacheSettingUtils;
    @Resource
    private ContractHoldOrderDao contractHoldOrderDao;
    @Resource
    private ContractOrderDao contractOrderDao;
    @Resource
    private MemberLevelRateDao memberLevelRateDao;
    @Resource
    private MemberWalletContractDao memberWalletContractDao;
    @Resource
    private FollowFollowerSettingDao followFollowerSettingDao;
    @Resource
    private FollowFollowerOrderRelationDao followFollowerOrderRelationDao;
    @Resource
    private FollowFollowerNoticeDao followFollowerNoticeDao;
    @Resource
    private FollowTraderLabelDao followTraderLabelDao;
    @Resource
    private MemberSettingDao memberSettingDao;
    
	
	@Override
	public Result getMemberIsTradeInfo() {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        MemberEntity member = memberDao.selectById(memberId);
        
        Integer isTrader = member.getIsTrader();
        MemberIsTradeVo memberIsTradeVo = new MemberIsTradeVo();
        if(MemberEntity.IS_TRADER_Y.equals(isTrader)) {
        	memberIsTradeVo.setIsTrade(MemberEntity.IS_TRADER_Y);
        }else {
        	memberIsTradeVo.setIsTrade(MemberEntity.IS_TRADER_N);
        }
        return Result.ok(memberIsTradeVo);
	}

	@Override
	public Result getFollowTraderProfitInfo(@Valid FollowTraderProfitInfoDto recordsPageDto) {

		int type = recordsPageDto.getType();
        Page<FollowTraderProfitInfoVo> page = new Page<>(recordsPageDto.getPageNum(), recordsPageDto.getPageSize());
        FollowTraderProfitInfoEntity followTraderProfitInfoEntity = new FollowTraderProfitInfoEntity();
        if(FollowTraderInfoEntity.IS_SETFRIST_Y.equals(type)) {
        	followTraderProfitInfoEntity.setType(type);
			followTraderProfitInfoEntity.setTotalProfitRatioSc(2);
        }else {
	        String nicknameDto = recordsPageDto.getNickname();
	        followTraderProfitInfoEntity.setNickname(nicknameDto);
	        int totalProfitRatioSc = recordsPageDto.getTotalProfitRatioSc();
	        followTraderProfitInfoEntity.setTotalProfitRatioSc(totalProfitRatioSc);
	        int totalFollowerCntSc = recordsPageDto.getTotalFollowerCntSc();
	        followTraderProfitInfoEntity.setTotalFollowerCntSc(totalFollowerCntSc);
	        int winRateSc = recordsPageDto.getWinRateSc();
	        followTraderProfitInfoEntity.setWinRateSc(winRateSc);
        }
        
        IPage<FollowTraderProfitInfoVo> followTraderProfitInfoList = followTraderProfitInfoDao.selectFollowTraderProfitInfoEntity(page, followTraderProfitInfoEntity);
        
        List<FollowTraderProfitInfoVo> followTraderProfitInfoVoList = followTraderProfitInfoList.getRecords();
        if(CollUtil.isNotEmpty(followTraderProfitInfoVoList)) {
        	for(FollowTraderProfitInfoVo FollowTraderProfitInfoVo : followTraderProfitInfoVoList) {
        		MemberEntity user = LoginUserUtils.getUser();
        		if(ObjectUtil.isNotEmpty(user)) {
        			Long traderId = FollowTraderProfitInfoVo.getTraderId();
        			Long memberId = user.getId();
        			FollowFollowerProfitEntity followFollowerProfitEntity = followFollowerProfitDao.selectDocumentaryOrderSetInfoBymemberIdAndTradeId(memberId, traderId);
        			if(ObjectUtil.isNotEmpty(followFollowerProfitEntity)) {
        				FollowTraderProfitInfoVo.setDocumentaryType(followFollowerProfitEntity.getIsFollow());
        			}else {
            			FollowTraderProfitInfoVo.setDocumentaryType(2);
            		}
        			
        		}
        		Long traderId = FollowTraderProfitInfoVo.getTraderId();
        		FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectFollowTraderInfoEntityBytreaderId(traderId);
        		
        		//获取当前跟单人数
    			Map<String, Object> columnMap = new HashMap<>();
    			columnMap.put("trader_id", traderId);
    			List<FollowFollowerSettingEntity> selectByMap = followFollowerSettingDao.selectByMap(columnMap);
    			if(CollUtil.isNotEmpty(selectByMap)) {
    				Integer followNum = followTraderInfoEntity.getFollowNum();
    				int size = selectByMap.size();
    				if(followNum > size) {
    					FollowTraderProfitInfoVo.setIsActualAll(2);
    				}else {
    					FollowTraderProfitInfoVo.setIsActualAll(1);
    				}
    			}else {
    				FollowTraderProfitInfoVo.setIsActualAll(2);
    			}
    			
        		String avatar = followTraderInfoEntity.getAvatar();
        		FollowTraderProfitInfoVo.setAvatar(avatar);
        		String nickname = followTraderInfoEntity.getNickname();
        		FollowTraderProfitInfoVo.setNickname(nickname);
        		String declaration = followTraderInfoEntity.getDeclaration();
        		FollowTraderProfitInfoVo.setDeclaration(declaration);
        		Integer isAll = followTraderInfoEntity.getIsAll();
        		FollowTraderProfitInfoVo.setIsAll(isAll);

				Date entryTime = followTraderInfoEntity.getEntryTime();
				int datePoor = getDatePoor(entryTime, new Date());
				FollowTraderProfitInfoVo.setEntryDays(datePoor);
        		
        		String labels = followTraderInfoEntity.getLabels();
        		if(StrUtil.isNotEmpty(labels)) {
        			ArrayList<FollowTraderLabelEntity> arrayList = new ArrayList<>();
        			String[] split = labels.split(",");
        			int length = split.length;
        			for(int i = 0;i < length;i++) {
        				String string = split[i];
        				FollowTraderLabelEntity selectById = followTraderLabelDao.selectById(Long.parseLong(string));
        				arrayList.add(selectById);
        			}
        			FollowTraderProfitInfoVo.setLabels(arrayList);
        		}
        		
        	}
        }
		return Result.ok(followTraderProfitInfoVoList);
	}
	
	public static void main(String[] args) {
		String labels = "1,2,3";
		if(StrUtil.isNotEmpty(labels)) {
			String labelsName = "";
			String[] split = labels.split(",");
			int length = split.length;
			for(int i = 0;i < length;i++) {
				String string = split[i];
				labelsName += (string + ",");
			}
			System.out.println(labelsName);
		}
	}

	@Override
	public Result getHistoryOrderRecords(@Valid HistoryOrderRecordsDto historyOrderRecordsDto) {
		
		FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectById(historyOrderRecordsDto.getTradeId());
		Long memberId = followTraderInfoEntity.getMemberId();
		
		Page<HistoryOrderRecordsVo> page = new Page<>(historyOrderRecordsDto.getPageNum(), historyOrderRecordsDto.getPageSize());
        IPage<HistoryOrderRecordsVo> historyOrderRecordsVoList = followTraderProfitInfoDao.selectHistoryOrderRecords(page, memberId);
        List<HistoryOrderRecordsVo> records = historyOrderRecordsVoList.getRecords();
        if(CollUtil.isNotEmpty(records)) {
        	for(HistoryOrderRecordsVo historyOrderRecordsVo : records) {
        		BigDecimal closingPrice = historyOrderRecordsVo.getClosingPrice().setScale(2, BigDecimal.ROUND_DOWN);
        		historyOrderRecordsVo.setClosingPrice(closingPrice);
        		BigDecimal openingPrice = historyOrderRecordsVo.getOpeningPrice().setScale(2, BigDecimal.ROUND_DOWN);
        		historyOrderRecordsVo.setOpeningPrice(openingPrice);
				historyOrderRecordsVo.setClosingTimeStamp(historyOrderRecordsVo.getClosingTime().getTime());
			}
        }
		return Result.ok(historyOrderRecordsVoList);
	}

	@Override
	public Result getFollowRecords(@Valid FollowRecordsDto followRecordsDto) {
		
		FollowTraderInfoEntity followTraderInfoEn = followTraderInfoDao.selectById(followRecordsDto.getTradeId());
		Long memberId = followTraderInfoEn.getMemberId();
		
		Page<FollowRecordsVo> page = new Page<>(followRecordsDto.getPageNum(), followRecordsDto.getPageSize());
		IPage<FollowRecordsVo> historyOrderRecordsVoList = followFollowerProfitDao.selectFollowRecords(page, memberId);
		
		List<FollowRecordsVo> records = historyOrderRecordsVoList.getRecords();
		if(CollUtil.isNotEmpty(records)) {
			for(FollowRecordsVo followRecordsVo : records) {
				Long memberIdFollow = followRecordsVo.getMemberId();
				Long tradeId = followRecordsVo.getTradeId();
				//获取当前跟随者最后一个历史跟单的保证金
				BigDecimal bondAmount = BigDecimal.ZERO;
				List<BigDecimal> bondamounts = followFollowerProfitDao.selectBondAmountByTradeIdAndMemberId(memberIdFollow,tradeId);
				if(CollUtil.isNotEmpty(bondamounts)){
					bondAmount = bondamounts.get(0).setScale(2, BigDecimal.ROUND_DOWN);

				}
				followRecordsVo.setTotalPrincipal(bondAmount);

//				BigDecimal totalPrincipal = followRecordsVo.getTotalPrincipal().setScale(2, BigDecimal.ROUND_DOWN);
//				followRecordsVo.setTotalPrincipal(totalPrincipal);
				BigDecimal totalProfit = followRecordsVo.getTotalProfit().setScale(2, BigDecimal.ROUND_DOWN);
				followRecordsVo.setTotalProfit(totalProfit);
				
				Long memberIds = followRecordsVo.getMemberId();
				MemberEntity MemberEntity = memberDao.selectById(memberIds);
				String phone = MemberEntity.getPhone();
				String email = MemberEntity.getEmail();
				if(StrUtil.isNotEmpty(phone)) {
					followRecordsVo.setNickname(phone);
				}else {
					followRecordsVo.setNickname(email);
				}
			}
		}
		return Result.ok(historyOrderRecordsVoList);
	}

	@Override
	public Result getFollowInfo() {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        MemberEntity member = memberDao.selectById(memberId);
        
        FollowInfoVo followInfoVo = new FollowInfoVo();
        followInfoVo.setMemberId(memberId);
        String email = member.getEmail();
		String phone = member.getPhone();
		if(StrUtil.isNotEmpty(email)) {
			followInfoVo.setNickname(email);
		}else {
			followInfoVo.setNickname(phone);
		}

		List<ContractHoldOrderEntity> myFollowOrder = followFollowerProfitDao.getFollowOrderNowRecords(memberId);

		BigDecimal totalBondAmount = BigDecimal.ZERO;
		BigDecimal profitOrLess = BigDecimal.ZERO;
		if (CollUtil.isNotEmpty(myFollowOrder)) {
			for(ContractHoldOrderEntity contractHoldOrderEntity : myFollowOrder) {
				BigDecimal newPrice = new BigDecimal(redisUtils.getString(CoinTypeConvert.convertToKey(contractHoldOrderEntity.getSymbol())));
				BigDecimal lotNumber = cacheSettingUtils.getSymbolSku(contractHoldOrderEntity.getSymbol());

				// 盈亏
				BigDecimal rewardRatio = BigDecimal.ZERO;
				// 开多
				if (contractHoldOrderEntity.OPENING_TYPE_MORE == contractHoldOrderEntity.getOpeningType()) {
					// (最新价-开仓价)*规格*张数
					rewardRatio = newPrice.subtract(contractHoldOrderEntity.getOpeningPrice()).multiply(lotNumber).multiply(new BigDecimal(contractHoldOrderEntity.getSymbolCnt()));
					// 开空
				} else {
					// (开仓价-最新价)*规格*张数
					rewardRatio = contractHoldOrderEntity.getOpeningPrice().subtract(newPrice).multiply(lotNumber).multiply(new BigDecimal(contractHoldOrderEntity.getSymbolCnt()));
				}

				if (member.getIsProfit() == MemberEntity.IS_PROFIT_Y) {
					PlatformTradeSettingEntity tradeSettingEntity = cacheSettingUtils.getTradeSetting();
					if (rewardRatio.compareTo(BigDecimal.ZERO) > -1) {
						rewardRatio = rewardRatio.multiply(BigDecimal.ONE.subtract(tradeSettingEntity.getProfitParam()));
					}
				}

				profitOrLess = profitOrLess.add(rewardRatio).setScale(2, BigDecimal.ROUND_DOWN);
				totalBondAmount = totalBondAmount.add(contractHoldOrderEntity.getBondAmount()).setScale(2, BigDecimal.ROUND_DOWN);
			}
		}

		followInfoVo.setTotalAmount(totalBondAmount);
		followInfoVo.setTotalProfitOrLess(profitOrLess);

		BigDecimal totalPrincipals =  BigDecimal.ZERO;
		BigDecimal totalProfits =  BigDecimal.ZERO;
		Map<String, Object> columnMap = new HashMap<>();
		columnMap.put("member_id", memberId);
		List<FollowFollowerProfitEntity> selectByMap = followFollowerProfitDao.selectByMap(columnMap);
		if(CollUtil.isNotEmpty(selectByMap)) {
			for(FollowFollowerProfitEntity followFollowerProfitEntity : selectByMap) {
				BigDecimal totalPrincipal = followFollowerProfitEntity.getTotalPrincipal();
				totalPrincipals = totalPrincipals.add(totalPrincipal);
				BigDecimal totalProfit = followFollowerProfitEntity.getTotalProfit();
				totalProfits = totalProfits.add(totalProfit);
			}
		}
		followInfoVo.setTotalPrincipal(totalPrincipals.setScale(2, BigDecimal.ROUND_DOWN));
		followInfoVo.setTotalProfit(totalProfits.setScale(2, BigDecimal.ROUND_DOWN));
		
		return Result.ok(followInfoVo);
	}

	@Override
	public Result getHistoryMyFollowOrderRecords(@Valid MyFollowOrderDto myFollowOrderDto) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        List<MyFollowOrderVo> myFollowOrderVos = new ArrayList<>();
        //历史跟单
        	Page<ContractOrderEntity> page = new Page<>(myFollowOrderDto.getPageNum(), myFollowOrderDto.getPageSize());
        	IPage<ContractOrderEntity> contractOrderEntitys = followFollowerProfitDao.getMyFollowOrderHistoryRecords(page, memberId);
        	
        	List<ContractOrderEntity> records = contractOrderEntitys.getRecords();
        	if(CollUtil.isNotEmpty(records)) {
        		for(ContractOrderEntity contractOrderEntity : records) {
        			MyFollowOrderVo myFollowOrderVo = new MyFollowOrderVo();
        			//获取交易员信息
					Long orderId = contractOrderEntity.getId();
					FollowFollowerOrderRelationEntity FollowFollowerOrderRelation = followFollowerOrderRelationDao.selectHistoryOneByorderId(orderId);
					if(ObjectUtil.isNotEmpty(FollowFollowerOrderRelation)) {
						myFollowOrderVo.setOrderId(orderId);
						Long tradeId = FollowFollowerOrderRelation.getTradeId();
						FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectById(tradeId);
						if(ObjectUtil.isNotEmpty(followTraderInfoEntity)) {
							String nickname = followTraderInfoEntity.getNickname();
							myFollowOrderVo.setNickname(nickname);
						}
						String symbol = contractOrderEntity.getSymbol();
						myFollowOrderVo.setSymbol(symbol);
						int orderType = contractOrderEntity.getOrderType();
						myFollowOrderVo.setOrderType(orderType);
						int leverRatio = contractOrderEntity.getLeverRatio();
						myFollowOrderVo.setLeverRatio(leverRatio);
						BigDecimal rewardAmount = contractOrderEntity.getRewardAmount().setScale(2, BigDecimal.ROUND_DOWN);
						myFollowOrderVo.setRewardAmount(rewardAmount);
						BigDecimal rewardRatio = contractOrderEntity.getRewardRatio() == null ? BigDecimal.ZERO : contractOrderEntity.getRewardRatio().setScale(4, BigDecimal.ROUND_DOWN);
						myFollowOrderVo.setRewardRatio(rewardRatio);
						int symbolCnt = contractOrderEntity.getSymbolCnt();
						myFollowOrderVo.setSymbolCnt(symbolCnt);
						BigDecimal bondAmount = contractOrderEntity.getBondAmount().setScale(2, BigDecimal.ROUND_DOWN);
						myFollowOrderVo.setBondAmount(bondAmount);
						BigDecimal openingPrice = contractOrderEntity.getOpeningPrice().setScale(2, BigDecimal.ROUND_DOWN);
						myFollowOrderVo.setOpeningPrice(openingPrice);
						BigDecimal closingPrice = contractOrderEntity.getClosingPrice().setScale(2, BigDecimal.ROUND_DOWN);
						myFollowOrderVo.setClosingPrice(closingPrice);
						Date openingTime = contractOrderEntity.getOpeningTime();
						myFollowOrderVo.setOpeningTime(openingTime);
						Date closingTime = contractOrderEntity.getClosingTime();
						myFollowOrderVo.setClosingTime(closingTime);
						String orderNo = contractOrderEntity.getOrderNo();
						myFollowOrderVo.setOrderNo(orderNo);
						myFollowOrderVos.add(myFollowOrderVo);
					}
        		}
        	}
		return Result.ok(myFollowOrderVos);
		
	}
	@Override
	public Result getNowMyFollowOrderRecords(@Valid MyFollowOrderDto myFollowOrderDto) {
		//获取用户ID
		Long memberId = LoginUserUtils.getAppLoginUser().getId();
		MemberEntity member = memberDao.selectById(memberId);
		
		List<MyFollowOrderVo> myFollowOrderVos = new ArrayList<>();
			//当前跟单	
			Page<ContractHoldOrderEntity> page = new Page<>(myFollowOrderDto.getPageNum(), myFollowOrderDto.getPageSize());
			IPage<ContractHoldOrderEntity> contractHoldOrderEntitys = followFollowerProfitDao.getMyFollowOrderNowRecords(page, memberId);
			
			List<ContractHoldOrderEntity> records = contractHoldOrderEntitys.getRecords();
			if(CollUtil.isNotEmpty(records)) {
				for(ContractHoldOrderEntity contractHoldOrderEntity : records) {
					MyFollowOrderVo myFollowOrderVo = new MyFollowOrderVo();
					//获取交易员信息
					Long orderId = contractHoldOrderEntity.getId();
					myFollowOrderVo.setOrderId(orderId);
					FollowFollowerOrderRelationEntity FollowFollowerOrderRelation = followFollowerOrderRelationDao.selectNowOneByorderId(orderId);
					Long tradeId = FollowFollowerOrderRelation.getTradeId();
					FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectById(tradeId);
					String nickname = followTraderInfoEntity.getNickname();
					myFollowOrderVo.setNickname(nickname);
					
					String symbol = contractHoldOrderEntity.getSymbol();
					myFollowOrderVo.setSymbol(symbol);
					int orderType = contractHoldOrderEntity.getOpeningType();
					myFollowOrderVo.setOrderType(orderType);
					int leverRatio = contractHoldOrderEntity.getLeverRatio();
					myFollowOrderVo.setLeverRatio(leverRatio);
					int symbolCnt = contractHoldOrderEntity.getSymbolCnt();
					myFollowOrderVo.setSymbolCnt(symbolCnt);
					BigDecimal bondAmount = contractHoldOrderEntity.getBondAmount().setScale(2, BigDecimal.ROUND_DOWN);
					myFollowOrderVo.setBondAmount(bondAmount);
					BigDecimal openingPrice = contractHoldOrderEntity.getOpeningPrice().setScale(2, BigDecimal.ROUND_DOWN);
					myFollowOrderVo.setOpeningPrice(openingPrice);
					String orderNo = contractHoldOrderEntity.getOrderNo();
					myFollowOrderVo.setOrderNo(orderNo);
					Date openingTime = contractHoldOrderEntity.getCreateTime();
					myFollowOrderVo.setOpeningTime(openingTime);
					
					// 获取最新价
					BigDecimal newPrice = new BigDecimal(redisUtils.getString(CoinTypeConvert.convertToKey(contractHoldOrderEntity.getSymbol())));
					myFollowOrderVo.setNewPrice(newPrice);
					
					BigDecimal lotNumber = cacheSettingUtils.getSymbolSku(contractHoldOrderEntity.getSymbol());
					// 盈亏
					BigDecimal rewardRatio = BigDecimal.ZERO;
					// 开多
					if (contractHoldOrderEntity.OPENING_TYPE_MORE == contractHoldOrderEntity.getOpeningType()) {
						// (最新价-开仓价)*规格*张数
						rewardRatio = newPrice.subtract(contractHoldOrderEntity.getOpeningPrice()).multiply(lotNumber).multiply(new BigDecimal(contractHoldOrderEntity.getSymbolCnt()));
						// 开空
					} else {
						// (开仓价-最新价)*规格*张数
						rewardRatio = contractHoldOrderEntity.getOpeningPrice().subtract(newPrice).multiply(lotNumber).multiply(new BigDecimal(contractHoldOrderEntity.getSymbolCnt()));
					}
					
					if (member.getIsProfit() == MemberEntity.IS_PROFIT_Y) {
						PlatformTradeSettingEntity tradeSettingEntity = cacheSettingUtils.getTradeSetting();
						if (rewardRatio.compareTo(BigDecimal.ZERO) > -1) {
							rewardRatio = rewardRatio.multiply(BigDecimal.ONE.subtract(tradeSettingEntity.getProfitParam()));
						}
					}
					myFollowOrderVo.setRewardAmount(rewardRatio.setScale(2, BigDecimal.ROUND_DOWN));
					
					// 回报率
					BigDecimal returnRate = rewardRatio.divide(contractHoldOrderEntity.getBondAmount().subtract(contractHoldOrderEntity.getOpeningFeeAmount()), 8, BigDecimal.ROUND_DOWN);
					myFollowOrderVo.setRewardRatio(returnRate.setScale(4, BigDecimal.ROUND_DOWN));
					
					myFollowOrderVos.add(myFollowOrderVo);
				}
			}
		
		return Result.ok(myFollowOrderVos);
		
	}

	@Override
	public Result getMyFollowTraderInfo(@Valid MyFollowTraderInfoDto myFollowTraderInfoDto) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        List<MyFollowTraderInfoVo> myFollowOrderVos = new ArrayList<>();
        
        Page<FollowFollowerProfitEntity> page = new Page<>(myFollowTraderInfoDto.getPageNum(), myFollowTraderInfoDto.getPageSize());
		IPage<FollowFollowerProfitEntity> followFollowerProfitEntitys = followFollowerProfitDao.selectFollowFollowerProfitEntitys(page, memberId);
		List<FollowFollowerProfitEntity> records = followFollowerProfitEntitys.getRecords();
		if(CollUtil.isNotEmpty(records)) {
			for(FollowFollowerProfitEntity FollowFollowerProfitEntity : records) {
				MyFollowTraderInfoVo myFollowTraderInfoVo = new MyFollowTraderInfoVo();
				
				Long tradeId = FollowFollowerProfitEntity.getTradeId();
				FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectById(tradeId);
				String avatar = followTraderInfoEntity.getAvatar();
				myFollowTraderInfoVo.setAvatar(avatar);
				String nickname = followTraderInfoEntity.getNickname();
				myFollowTraderInfoVo.setNickname(nickname);
				BigDecimal totalPrincipal = FollowFollowerProfitEntity.getTotalPrincipal();
				myFollowTraderInfoVo.setTotalPrincipal(totalPrincipal.setScale(2, BigDecimal.ROUND_DOWN));
				BigDecimal totalProfit = FollowFollowerProfitEntity.getTotalProfit();
	        	myFollowTraderInfoVo.setTotalProfit(totalProfit.setScale(2, BigDecimal.ROUND_DOWN));

				myFollowTraderInfoVo.setTradeId(tradeId);
	        	myFollowOrderVos.add(myFollowTraderInfoVo);
	        }
		}
		return Result.ok(myFollowOrderVos);
	}

	@Override
	public Result getDocumentaryOrderInfo() {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("member_id", memberId);
        List<DocumentaryOrderInfoVo> list = new ArrayList<>();
		//获取对应的杠杆等信息和可用余额
        BigDecimal availableBalance  = BigDecimal.ZERO;
        List<MemberWalletContractEntity> selectByMap = memberWalletContractDao.selectByMap(columnMap);
        if(CollUtil.isNotEmpty(selectByMap)) {
        	for(MemberWalletContractEntity MemberWalletContractEntity : selectByMap) {
        		availableBalance = MemberWalletContractEntity.getAvailableBalance();
        	}
        }
        List<MemberLevelRateEntity> memberLevelRateEntitys = memberLevelRateDao.selectByMap(columnMap);
        if(CollUtil.isNotEmpty(memberLevelRateEntitys)) {
        	for(MemberLevelRateEntity memberLevelRateEntity : memberLevelRateEntitys) {
        		DocumentaryOrderInfoVo documentaryOrderInfoVo = new DocumentaryOrderInfoVo();
        		String symbol = memberLevelRateEntity.getSymbol();
        		documentaryOrderInfoVo.setSymbol(symbol);
        		int levelRateDown = memberLevelRateEntity.getLevelRateDown();
        		documentaryOrderInfoVo.setLevelRate(levelRateDown);
        		documentaryOrderInfoVo.setAvaliableCoin(availableBalance);
        		list.add(documentaryOrderInfoVo);
        	}
        }
		return Result.ok(list);
	}

	@Override
	@Transactional
	public Result getDocumentaryOrderSet(@Valid DocumentaryOrderSetDto documentaryOrderSetDto) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
		Long traderId = documentaryOrderSetDto.getTraderId();

		FollowTraderInfoEntity traderInfoEntity = followTraderInfoDao.selectTraderInfoByMemberId(memberId);
		if (traderInfoEntity != null) {
			return Result.fail(MessageSourceUtils.getString("documentary_service_0014"));
		}
		
		//判断当前用户是否是逐仓模式
		MemberEntity selectById2 = memberDao.selectById(memberId);
		Integer contractPositionType = selectById2.getContractPositionType();
		if(ContractEntrustOrderEntity.POSITION_TYPE_ADD != contractPositionType) {
			return Result.fail(MessageSourceUtils.getString("documentary_service_0017"));
		}
		
		//判断交易员是否开启了跟单
		FollowTraderInfoEntity selectById = followTraderInfoDao.selectById(traderId);
		Integer isOpen = selectById.getIsOpen();
		if(FollowTraderInfoEntity.ISOPEN_Y != isOpen) {
			return Result.fail(MessageSourceUtils.getString("documentary_service_0016"));
		}

		FollowFollowerSettingEntity isExistSetting = followFollowerSettingDao.selectOneBymemberIdAndTradeId(memberId, traderId);
		if (isExistSetting == null) {
			//新增【跟随者设置】数据
			FollowFollowerSettingEntity followFollowerSettingEntity = new FollowFollowerSettingEntity();
			followFollowerSettingEntity.setMemberId(memberId);
			followFollowerSettingEntity.setTraderId(traderId);
			FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectById(traderId);
			Long traderMemberId = followTraderInfoEntity.getMemberId();
			followFollowerSettingEntity.setTraderMemberId(traderMemberId);
			followFollowerSettingEntity.setSymbols(documentaryOrderSetDto.getSymbols());
			followFollowerSettingEntity.setFollowType(documentaryOrderSetDto.getFollowType());
			followFollowerSettingEntity.setFollowCnt(documentaryOrderSetDto.getFollowCnt());
			followFollowerSettingEntity.setMaxFollowCnt(documentaryOrderSetDto.getMaxFollowCnt());
			followFollowerSettingDao.insert(followFollowerSettingEntity);
			//更新【跟随者收益】数据
			Map<String, Object> columnMap = new HashMap<>();
			columnMap.put("member_id", memberId);
			columnMap.put("trade_id", traderId);
			List<FollowFollowerProfitEntity> selectByMap = followFollowerProfitDao.selectByMap(columnMap);
			if (CollUtil.isNotEmpty(selectByMap)) {
				FollowFollowerProfitEntity followFollowerProfitEntity = selectByMap.get(0);
				followFollowerProfitEntity.setIsFollow(FollowFollowerProfitEntity.IS_FOLLOW_Y);
				followFollowerProfitDao.updateById(followFollowerProfitEntity);
			} else {
				FollowFollowerProfitEntity followFollowerProfitEntity = new FollowFollowerProfitEntity();
				followFollowerProfitEntity.setMemberId(memberId);
				followFollowerProfitEntity.setTradeId(traderId);
				followFollowerProfitEntity.setTradeMemberId(traderMemberId);
				followFollowerProfitEntity.setTotalPrincipal(BigDecimal.ZERO);
				followFollowerProfitEntity.setTotalProfit(BigDecimal.ZERO);
				followFollowerProfitEntity.setIsFollow(FollowFollowerProfitEntity.IS_FOLLOW_Y);
				followFollowerProfitDao.insert(followFollowerProfitEntity);
			}
		} else {
			//更新【跟随者收益】数据
			Map<String, Object> columnMap = new HashMap<>();
			columnMap.put("member_id", memberId);
			columnMap.put("trade_id", traderId);
			List<FollowFollowerProfitEntity> selectByMap = followFollowerProfitDao.selectByMap(columnMap);
			if (CollUtil.isNotEmpty(selectByMap)) {
				FollowFollowerProfitEntity followFollowerProfitEntity = selectByMap.get(0);
				followFollowerProfitEntity.setIsFollow(FollowFollowerProfitEntity.IS_FOLLOW_Y);
				followFollowerProfitDao.updateById(followFollowerProfitEntity);
			}else {
				FollowFollowerProfitEntity followFollowerProfitEntity = new FollowFollowerProfitEntity();
				followFollowerProfitEntity.setMemberId(memberId);
				followFollowerProfitEntity.setTradeId(traderId);
				FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectById(traderId);
				Long traderMemberId = followTraderInfoEntity.getMemberId();
				followFollowerProfitEntity.setTradeMemberId(traderMemberId);
				followFollowerProfitEntity.setTotalPrincipal(BigDecimal.ZERO);
				followFollowerProfitEntity.setTotalProfit(BigDecimal.ZERO);
				followFollowerProfitEntity.setIsFollow(FollowFollowerProfitEntity.IS_FOLLOW_Y);
				followFollowerProfitDao.insert(followFollowerProfitEntity);
			}
			
			isExistSetting.setSymbols(documentaryOrderSetDto.getSymbols());
			isExistSetting.setFollowType(documentaryOrderSetDto.getFollowType());
			isExistSetting.setFollowCnt(documentaryOrderSetDto.getFollowCnt());
			isExistSetting.setMaxFollowCnt(documentaryOrderSetDto.getMaxFollowCnt());
			followFollowerSettingDao.updateById(isExistSetting);
		}
		return Result.ok(MessageSourceUtils.getString("member_service_0024"));
	}

	@Override
	public Result getDocumentaryOrderSetInfo(String tradeId) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        log.info("跟单---点击跟单或者编辑---"+memberId+"参数"+tradeId);
        DocumentaryOrderSetInfoVo documentaryOrderSetInfoVo = new DocumentaryOrderSetInfoVo();
        long parseLong = Long.parseLong(tradeId);
        
        //只能跟随一个人
//        Map<String, Object> columnMaps = new HashMap<>();
//        columnMaps.put("member_id", memberId);
//        List<FollowFollowerSettingEntity> followFollowerSettingEntityAllows = followFollowerSettingDao.selectByMap(columnMaps);
//        if(CollUtil.isNotEmpty(followFollowerSettingEntityAllows)) {
//        	for(FollowFollowerSettingEntity followFollowerSettingEntityAllow : followFollowerSettingEntityAllows) {
//        		Long tradeIdAllow = followFollowerSettingEntityAllow.getTraderId();
//        		if(parseLong != tradeIdAllow) {
//        			return Result.fail(MessageSourceUtils.getString("documentary_service_0015"));
//        		}
//        	}
//        }
        
        //获取【跟随者设置】数据
        FollowFollowerSettingEntity followFollowerSettingEntity = followFollowerSettingDao.selectOneBymemberIdAndTradeId(memberId,parseLong);

        documentaryOrderSetInfoVo.setTraderId(parseLong);
        
        FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectById(tradeId);
        String avatar = followTraderInfoEntity.getAvatar();
        documentaryOrderSetInfoVo.setAvatar(avatar);
        
        String nickname = followTraderInfoEntity.getNickname();
        documentaryOrderSetInfoVo.setNickname(nickname);

		documentaryOrderSetInfoVo.setProfit(followTraderInfoEntity.getProfitRatio());
        if (followFollowerSettingEntity == null) {
        	return Result.ok(documentaryOrderSetInfoVo);
		}
        String symbols = followFollowerSettingEntity.getSymbols();
        documentaryOrderSetInfoVo.setSymbols(symbols);
        
        Integer followType = followFollowerSettingEntity.getFollowType();
        documentaryOrderSetInfoVo.setFollowType(followType);
        
        Integer followCnt = followFollowerSettingEntity.getFollowCnt();
        documentaryOrderSetInfoVo.setFollowCnt(followCnt);
        
        Integer maxFollowCnt = followFollowerSettingEntity.getMaxFollowCnt();
        if(maxFollowCnt > 0){
        	documentaryOrderSetInfoVo.setMaxFollowCnt(maxFollowCnt.toString());
		}else {
			documentaryOrderSetInfoVo.setMaxFollowCnt("");
		}
        log.info(memberId + "-最大持仓张数-"+maxFollowCnt.toString());
		return Result.ok(documentaryOrderSetInfoVo);
	}

	@Override
	@Transactional
	public Result cancelDocumentaryOrderSetInfo(@Valid CancelDocumentaryOrderSetDto cancelDocumentaryOrderSetDto) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        Long traderId = cancelDocumentaryOrderSetDto.getTraderId();
        //删除【跟随者设置】数据
        FollowFollowerSettingEntity followFollowerSettingEntity = followFollowerSettingDao.selectOneBymemberIdAndTradeId(memberId,traderId);
        followFollowerSettingDao.deleteById(followFollowerSettingEntity.getId());
        //更新【跟随者收益】数据
        FollowFollowerProfitEntity followFollowerProfitEntity = followFollowerProfitDao.selectDocumentaryOrderSetInfoBymemberIdAndTradeId(memberId,traderId);
        followFollowerProfitEntity.setIsFollow(FollowFollowerProfitEntity.IS_FOLLOW_N);
        followFollowerProfitDao.updateById(followFollowerProfitEntity);
		return Result.ok(MessageSourceUtils.getString("documentary_service_0011"));
	}

	@Override
	@Transactional
	public Result updateDocumentaryOrderSetInfo(@Valid UpdateDocumentaryOrderSetDto updateDocumentaryOrderSetDto) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        Long traderId = updateDocumentaryOrderSetDto.getTraderId();
        //更新【跟随者设置】数据
        FollowFollowerSettingEntity followFollowerSettingEntity = followFollowerSettingDao.selectOneBymemberIdAndTradeId(memberId, traderId);
        if (followFollowerSettingEntity == null) {
        	FollowTraderInfoEntity traderInfoEntity = followTraderInfoDao.selectById(traderId);
			followFollowerSettingEntity = new FollowFollowerSettingEntity();
			followFollowerSettingEntity.setSymbols(updateDocumentaryOrderSetDto.getSymbols());
			followFollowerSettingEntity.setFollowType(updateDocumentaryOrderSetDto.getFollowType());
			followFollowerSettingEntity.setFollowCnt(updateDocumentaryOrderSetDto.getFollowCnt());
			followFollowerSettingEntity.setMaxFollowCnt(updateDocumentaryOrderSetDto.getMaxFollowCnt());
			followFollowerSettingEntity.setTraderId(traderId);
			followFollowerSettingEntity.setMemberId(memberId);
			followFollowerSettingEntity.setTraderMemberId(traderInfoEntity.getMemberId());
			followFollowerSettingDao.insert(followFollowerSettingEntity);
		} else {
			followFollowerSettingEntity.setSymbols(updateDocumentaryOrderSetDto.getSymbols());
			followFollowerSettingEntity.setFollowType(updateDocumentaryOrderSetDto.getFollowType());
			followFollowerSettingEntity.setFollowCnt(updateDocumentaryOrderSetDto.getFollowCnt());
			followFollowerSettingEntity.setMaxFollowCnt(updateDocumentaryOrderSetDto.getMaxFollowCnt());
			followFollowerSettingDao.updateById(followFollowerSettingEntity);
		}
		
		return Result.ok(MessageSourceUtils.getString("member_service_0024"));
	}

	@Override
	public Result getFollowTraderProfit(long traderId) {
		FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectById(traderId);
		Long memberId = followTraderInfoEntity.getMemberId();
		FollowTraderProfitInfoVo followTraderProfitInfoVo = followTraderProfitInfoDao.selectOneByMemberId(memberId);
		MemberEntity user = LoginUserUtils.getUser();
		if(ObjectUtil.isNotEmpty(user)) {
			FollowFollowerProfitEntity followFollowerProfitEntity = followFollowerProfitDao.selectDocumentaryOrderSetInfoBymemberIdAndTradeId(user.getId(), traderId);
			if(ObjectUtil.isNotEmpty(followFollowerProfitEntity)) {
				followTraderProfitInfoVo.setDocumentaryType(followFollowerProfitEntity.getIsFollow());
			}else {
				followTraderProfitInfoVo.setDocumentaryType(2);
    		}
		}
		String avatar = followTraderInfoEntity.getAvatar();
		String nickname = followTraderInfoEntity.getNickname();
		String declaration = followTraderInfoEntity.getDeclaration();
		Integer isAll = followTraderInfoEntity.getIsAll();
		Integer followNum = followTraderInfoEntity.getFollowNum();
		Date entryTime = followTraderInfoEntity.getEntryTime();
		int datePoor = getDatePoor(entryTime, new Date());
		followTraderProfitInfoVo.setEntryDays(datePoor);
		//获取当前跟单人数
		Map<String, Object> columnMap = new HashMap<>();
		columnMap.put("trade_id", traderId);
		columnMap.put("is_follow", FollowFollowerProfitEntity.IS_FOLLOW_Y);
		List<FollowFollowerProfitEntity> selectByMap = followFollowerProfitDao.selectByMap(columnMap);
		if(CollUtil.isNotEmpty(selectByMap)) {
			followTraderProfitInfoVo.setFollowNumNow(selectByMap.size());
		}else {
			followTraderProfitInfoVo.setFollowNumNow(0);
		}
		if(CollUtil.isNotEmpty(selectByMap)) {
			if(followNum > selectByMap.size()){
				followTraderProfitInfoVo.setIsActualAll(2);
			}else{
				followTraderProfitInfoVo.setIsActualAll(1);
			}
		}else {
			followTraderProfitInfoVo.setIsActualAll(2);
		}
		followTraderProfitInfoVo.setFollowNum(followNum);
		followTraderProfitInfoVo.setAvatar(avatar);
		followTraderProfitInfoVo.setNickname(nickname);
		followTraderProfitInfoVo.setDeclaration(declaration);
		followTraderProfitInfoVo.setIsAll(isAll);
		return Result.ok(followTraderProfitInfoVo);
	}
	
	//获取两个时间之间的日期
	private int getDatePoor(Date endDate, Date nowDate) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(endDate);
		long time1 = cal.getTimeInMillis();
		cal.setTime(nowDate);
		long time2 = cal.getTimeInMillis();
		long between_days=(time2-time1)/(1000*3600*24);
		int parseInt = Integer.parseInt(String.valueOf(between_days));
		parseInt = parseInt + 1;
		return parseInt ;
	}

	@Override
	@Transactional
	public Result beTrader(@Valid BeTraderDto beTraderDto) {
		//头像
		String avatar = beTraderDto.getAvatar();
		//昵称
		String nickname = beTraderDto.getNickname();
		//宣言
		String declaration = beTraderDto.getDeclaration();
		//标签
		String labels = beTraderDto.getLabels();
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        MemberEntity memberEntity = memberDao.selectById(memberId);
        Integer certifyStatus = memberEntity.getCertifyStatus();
        if(MemberEntity.CERTIFY_STATUS_Y != certifyStatus) {
        	return Result.fail(MessageSourceUtils.getString("member_controller_0009"));
        }
        
        //不可以处于跟单状态
        Map<String, Object> columnMaps = new HashMap<>();
        columnMaps.put("member_id", memberId);
        columnMaps.put("is_follow", 1);
        List<FollowFollowerProfitEntity> followFollowerProfitEntitys = followFollowerProfitDao.selectByMap(columnMaps);
        if(CollUtil.isNotEmpty(followFollowerProfitEntitys)) {
        	return Result.fail(MessageSourceUtils.getString("documentary_service_0015"));
        }
        
        //合约不能持仓
        Map<String, Object> contractHoldColumnMap = new HashMap<>();
        contractHoldColumnMap.put("member_id", memberId);
        List<ContractHoldOrderEntity> contractHoldOrderEntitys = contractHoldOrderDao.selectByMap(contractHoldColumnMap);
        if(CollUtil.isNotEmpty(contractHoldOrderEntitys)) {
        	return Result.fail(MessageSourceUtils.getString("documentary_service_0013"));
        }
        
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("member_id", memberId);
		List<FollowTraderInfoEntity> selectByMap = followTraderInfoDao.selectByMap(columnMap);
		if(CollUtil.isNotEmpty(selectByMap)) {
			return Result.fail(MessageSourceUtils.getString("submit_repeat"));
		}

        //新增【交易员信息表】数据
        FollowTraderInfoEntity followTraderInfoEntity = new FollowTraderInfoEntity();
        followTraderInfoEntity.setMemberId(memberId);
        followTraderInfoEntity.setProfitRatio(BigDecimal.valueOf(0.1));
//        followTraderInfoEntity.setAvatar(FollowTraderInfoEntity.AVATAR_DEFAULT);
//        String phone = memberEntity.getPhone();
//        String email = memberEntity.getEmail();
//        if(StrUtil.isNotEmpty(phone)) {
//        	followTraderInfoEntity.setNickname(phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2"));
//        }else {
//        	followTraderInfoEntity.setNickname(email.replaceAll("(\\w?)(\\w+)(\\w)(@\\w+\\.[a-z]+(\\.[a-z]+)?)","$1****$3$4"));
//        }
        if(StrUtil.isNotEmpty(avatar)) {
        	followTraderInfoEntity.setAvatar(avatar);
        }
        followTraderInfoEntity.setNickname(nickname);
        followTraderInfoEntity.setNicknameState(FollowTraderInfoEntity.STATE_Y);
        if(StrUtil.isEmpty(declaration)) {
        	followTraderInfoEntity.setDeclaration(FollowTraderInfoEntity.DECLARATION_DEFAULT);
        }else {
        	followTraderInfoEntity.setDeclaration(declaration);
        }
        followTraderInfoEntity.setLabels(labels);
        followTraderInfoEntity.setFollowNum(FollowTraderInfoEntity.FOLLOWNUM_DEFAULT);
        followTraderInfoEntity.setIsAll(FollowTraderInfoEntity.IS_ALL_N);
        followTraderInfoEntity.setProfitRatio(BigDecimal.ZERO);
        followTraderInfoEntity.setVerifyStatus(FollowTraderInfoEntity.VERIFYSTATUS_ING);
        followTraderInfoEntity.setIsOpen(FollowTraderInfoEntity.ISOPEN_Y);
        followTraderInfoDao.insert(followTraderInfoEntity);
		return Result.ok(MessageSourceUtils.getString("member_service_0024"));
	}

	@Override
	public Result beTraderStatus() {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        MemberEntity memberEntity = memberDao.selectById(memberId);
        
        TraderStatusVo traderStatusVo = new TraderStatusVo();
        Integer isTraer = memberEntity.getIsTrader();
        traderStatusVo.setIsTrader(isTraer);
        
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("member_id", memberId);
		List<FollowTraderInfoEntity> selectByMap = followTraderInfoDao.selectByMap(columnMap);
		if(CollUtil.isNotEmpty(selectByMap)) {
			for(FollowTraderInfoEntity followTraderInfoEntity : selectByMap) {
				Integer verifyStatus = followTraderInfoEntity.getVerifyStatus();
				traderStatusVo.setVerifyStatus(verifyStatus);
			}
		}else{
			traderStatusVo.setVerifyStatus(4);
		}
		return Result.ok(traderStatusVo);
	}

	@Override
	public Result getTradeSetInfo() {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectTraderInfoByMemberId(memberId);
        
        TradeSetInfoVo tradeSetInfoVo = new TradeSetInfoVo();
        Long id = followTraderInfoEntity.getId();
        tradeSetInfoVo.setTradeId(id);
        String avatar = followTraderInfoEntity.getAvatar();
        tradeSetInfoVo.setAvatar(avatar);
        String nickname = followTraderInfoEntity.getNickname();
        tradeSetInfoVo.setNickname(nickname);
        Integer nicknameState = followTraderInfoEntity.getNicknameState();
        tradeSetInfoVo.setNicknameState(nicknameState);
        String declaration = followTraderInfoEntity.getDeclaration();
        tradeSetInfoVo.setDeclaration(declaration);
        Integer isOpen = followTraderInfoEntity.getIsOpen();
        tradeSetInfoVo.setIsOpen(isOpen);
        
        String labels = followTraderInfoEntity.getLabels();
		if(StrUtil.isNotEmpty(labels)) {
			ArrayList<FollowTraderLabelEntity> arrayList = new ArrayList<>();
			String[] split = labels.split(",");
			int length = split.length;
			for(int i = 0;i < length;i++) {
				String string = split[i];
				FollowTraderLabelEntity selectById = followTraderLabelDao.selectById(Long.parseLong(string));
				arrayList.add(selectById);
			}
			tradeSetInfoVo.setFollowTraderLabelEntitys(arrayList);
		}
		return Result.ok(tradeSetInfoVo);
	}

	@Override
	public Result updateTradeSetInfo(@Valid UpdateTradeSetInfoDto updateTradeSetInfoDto) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectTraderInfoByMemberId(memberId);
        /**
         * todo
         * 当前交易员有合约多单，是否可以直接调整【是否带单】，是否需要在调整前【判断是否已经有带单的合约单】
         */
        String avatar = updateTradeSetInfoDto.getAvatar();
        String nickname = updateTradeSetInfoDto.getNickname();
        String declaration = updateTradeSetInfoDto.getDeclaration();
        int isOpen = updateTradeSetInfoDto.getIsOpen();
        String labels = updateTradeSetInfoDto.getLabels();
        Integer nicknameState = followTraderInfoEntity.getNicknameState();
        if(FollowTraderInfoEntity.STATE_Y == nicknameState && !nickname.equals(followTraderInfoEntity.getNickname())) {
        	return Result.ok(MessageSourceUtils.getString("member_service_0099"));
        }
        if(!nickname.equals(followTraderInfoEntity.getNickname())) {
        	followTraderInfoEntity.setNickname(nickname);
        	followTraderInfoEntity.setNicknameState(FollowTraderInfoEntity.STATE_Y);
        }
        followTraderInfoEntity.setLabels(labels);
        followTraderInfoEntity.setAvatar(avatar);
        followTraderInfoEntity.setNickname(nickname);
        followTraderInfoEntity.setDeclaration(declaration);
        followTraderInfoEntity.setIsOpen(isOpen);
        followTraderInfoDao.updateById(followTraderInfoEntity);
		return Result.ok(MessageSourceUtils.getString("member_service_0024"));
	}
	
	@Override
	public Result getTradeProfitInfo() {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        TradeProfitInfoVo tradeProfitInfoVo = new TradeProfitInfoVo();
        //获取【交易员信息表】数据
        FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectTraderInfoByMemberId(memberId);
        Date entryTime = followTraderInfoEntity.getEntryTime();
		int datePoor = getDatePoor(entryTime, new Date());
		tradeProfitInfoVo.setEntryDays(datePoor);
        if(ObjectUtil.isNotEmpty(followTraderInfoEntity)) {
			Integer followNum = followTraderInfoEntity.getFollowNum();
			//获取当前跟单人数
			Map<String, Object> columnMap = new HashMap<>();
			columnMap.put("trade_id", followTraderInfoEntity.getId());
			columnMap.put("is_follow", FollowFollowerProfitEntity.IS_FOLLOW_Y);
			List<FollowFollowerProfitEntity> selectByMap = followFollowerProfitDao.selectByMap(columnMap);
			if(CollUtil.isNotEmpty(selectByMap)) {
				tradeProfitInfoVo.setFollowNumNow(selectByMap.size());
			}else {
				tradeProfitInfoVo.setFollowNumNow(0);
			}
			tradeProfitInfoVo.setFollowNum(followNum);
        	String avatar = followTraderInfoEntity.getAvatar();
        	tradeProfitInfoVo.setAvatar(avatar);
        	String nickname = followTraderInfoEntity.getNickname();
        	tradeProfitInfoVo.setNickname(nickname);
        	String declaration = followTraderInfoEntity.getDeclaration();
        	tradeProfitInfoVo.setDeclaration(declaration);
        }
        //获取【交易员收益信息】数据
        FollowTraderProfitInfoVo followTraderProfitInfoVo = followTraderProfitInfoDao.selectOneByMemberId(memberId);
        if(ObjectUtil.isNotEmpty(followTraderProfitInfoVo)) {
        	BigDecimal totalProfitRatio = followTraderProfitInfoVo.getTotalProfitRatio();
        	tradeProfitInfoVo.setTotalProfitRatio(totalProfitRatio);
        	BigDecimal totalProfit = followTraderProfitInfoVo.getTotalProfit();
        	tradeProfitInfoVo.setTotalProfit(totalProfit);
        	BigDecimal followerTotalProfit = followTraderProfitInfoVo.getFollowerTotalProfit();
        	tradeProfitInfoVo.setFollowerTotalProfit(followerTotalProfit);
        	BigDecimal winRate = followTraderProfitInfoVo.getWinRate();
        	tradeProfitInfoVo.setWinRate(winRate);
        	BigDecimal totalFollowerCnt = followTraderProfitInfoVo.getTotalFollowerCnt();
        	tradeProfitInfoVo.setTotalFollowerCnt(totalFollowerCnt);
        	BigDecimal totalOrderCnt = followTraderProfitInfoVo.getTotalOrderCnt();
        	tradeProfitInfoVo.setTotalOrderCnt(totalOrderCnt);
			BigDecimal thirtyProfitRatio = followTraderProfitInfoVo.getThirtyProfitRatio();
			tradeProfitInfoVo.setThirtyProfitRatio(thirtyProfitRatio);
			BigDecimal thirtyRatio = followTraderProfitInfoVo.getThirtyRatio();
			tradeProfitInfoVo.setThirtyRatio(thirtyRatio);
		}
		return Result.ok(tradeProfitInfoVo);
	}

	@Override
	public Result getTradeOrderInfo(@Valid TradeOrderInfoDto tradeOrderInfoDto) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
		MemberEntity member = memberDao.selectById(memberId);
		
		List<TradeOrderInfoVo> myFollowOrderVos = new ArrayList<>();
			//当前跟单	
			Page<ContractHoldOrderEntity> page = new Page<>(tradeOrderInfoDto.getPageNum(), tradeOrderInfoDto.getPageSize());
			IPage<ContractHoldOrderEntity> contractHoldOrderEntitys = followFollowerProfitDao.getMyFollowOrderNowRecords(page, memberId);
			
			List<ContractHoldOrderEntity> records = contractHoldOrderEntitys.getRecords();
			if(CollUtil.isNotEmpty(records)) {
				for(ContractHoldOrderEntity contractHoldOrderEntity : records) {
					TradeOrderInfoVo myFollowOrderVo = new TradeOrderInfoVo();
					//获取交易员信息
					Long orderId = contractHoldOrderEntity.getId();
					FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectTraderInfoByMemberId(memberId);
					if(ObjectUtil.isNotEmpty(followTraderInfoEntity)) {
						myFollowOrderVo.setOrderId(orderId);
						String nickname = followTraderInfoEntity.getNickname();
						myFollowOrderVo.setNickname(nickname);
						String symbol = contractHoldOrderEntity.getSymbol();
						myFollowOrderVo.setSymbol(symbol);
						int orderType = contractHoldOrderEntity.getOpeningType();
						myFollowOrderVo.setOrderType(orderType);
						int leverRatio = contractHoldOrderEntity.getLeverRatio();
						myFollowOrderVo.setLeverRatio(leverRatio);
						int symbolCnt = contractHoldOrderEntity.getSymbolCnt();
						myFollowOrderVo.setSymbolCnt(symbolCnt);
						BigDecimal bondAmount = contractHoldOrderEntity.getBondAmount().setScale(2, BigDecimal.ROUND_DOWN);
						myFollowOrderVo.setBondAmount(bondAmount);
						BigDecimal openingPrice = contractHoldOrderEntity.getOpeningPrice().setScale(2, BigDecimal.ROUND_DOWN);
						myFollowOrderVo.setOpeningPrice(openingPrice);
						String orderNo = contractHoldOrderEntity.getOrderNo();
						myFollowOrderVo.setOrderNo(orderNo);
						Date openingTime = contractHoldOrderEntity.getCreateTime();
						myFollowOrderVo.setOpeningTime(openingTime);
						
						// 获取最新价
						BigDecimal newPrice = new BigDecimal(redisUtils.getString(CoinTypeConvert.convertToKey(contractHoldOrderEntity.getSymbol())));
						myFollowOrderVo.setNewPrice(newPrice);
						
						BigDecimal lotNumber = cacheSettingUtils.getSymbolSku(contractHoldOrderEntity.getSymbol());
						// 盈亏
						BigDecimal rewardRatio = BigDecimal.ZERO;
						// 开多
						if (contractHoldOrderEntity.OPENING_TYPE_MORE == contractHoldOrderEntity.getOpeningType()) {
							// (最新价-开仓价)*规格*张数
							rewardRatio = newPrice.subtract(contractHoldOrderEntity.getOpeningPrice()).multiply(lotNumber).multiply(new BigDecimal(contractHoldOrderEntity.getSymbolCnt()));
							// 开空
						} else {
							// (开仓价-最新价)*规格*张数
							rewardRatio = contractHoldOrderEntity.getOpeningPrice().subtract(newPrice).multiply(lotNumber).multiply(new BigDecimal(contractHoldOrderEntity.getSymbolCnt()));
						}
						
						if (member.getIsProfit() == MemberEntity.IS_PROFIT_Y) {
							PlatformTradeSettingEntity tradeSettingEntity = cacheSettingUtils.getTradeSetting();
							if (rewardRatio.compareTo(BigDecimal.ZERO) > -1) {
								rewardRatio = rewardRatio.multiply(BigDecimal.ONE.subtract(tradeSettingEntity.getProfitParam()));
							}
						}
						myFollowOrderVo.setRewardAmount(rewardRatio.setScale(2, BigDecimal.ROUND_DOWN));
						
						// 回报率
						BigDecimal returnRate = rewardRatio.divide(contractHoldOrderEntity.getBondAmount().subtract(contractHoldOrderEntity.getOpeningFeeAmount()), 8, BigDecimal.ROUND_DOWN);
						myFollowOrderVo.setRewardRatio(returnRate.setScale(4, BigDecimal.ROUND_DOWN));
						
						myFollowOrderVos.add(myFollowOrderVo);
					}
				}
			}
		
		return Result.ok(myFollowOrderVos);
	}

	@Override
	public Result getTradeHistoryOrderInfo(@Valid TradeOrderInfoDto tradeOrderInfoDto) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        List<TradeHistoryOrderInfoVo> myFollowOrderVos = new ArrayList<>();
        //历史跟单
        	Page<ContractOrderEntity> page = new Page<>(tradeOrderInfoDto.getPageNum(), tradeOrderInfoDto.getPageSize());
        	IPage<ContractOrderEntity> contractOrderEntitys = followFollowerProfitDao.getMyFollowOrderHistoryRecords(page, memberId);
        	
        	List<ContractOrderEntity> records = contractOrderEntitys.getRecords();
        	if(CollUtil.isNotEmpty(records)) {
        		for(ContractOrderEntity contractOrderEntity : records) {
        			TradeHistoryOrderInfoVo myFollowOrderVo = new TradeHistoryOrderInfoVo();
        			//获取【跟随者-订单关联表】中的累计数据
        			BigDecimal allRewardAmount = BigDecimal.ZERO;
        			BigDecimal allRewardRatio = BigDecimal.ZERO;
        			
        			Long orderId = contractOrderEntity.getId();
        			String orderNo = contractOrderEntity.getOrderNo();
        			Map<String, Object> columnMapRelation = new HashMap<>();
        			columnMapRelation.put("trade_order_no", orderNo);
        			columnMapRelation.put("trade_member_id", memberId);
        			columnMapRelation.put("order_type", 2);
        			columnMapRelation.put("is_show", 1);
					List<FollowFollowerOrderRelationEntity> followFollowerOrderRelations = followFollowerOrderRelationDao.selectByMap(columnMapRelation);
        			if(CollUtil.isNotEmpty(followFollowerOrderRelations)) {
        				int size = followFollowerOrderRelations.size() - 1;
        				myFollowOrderVo.setFollowerNumber(size);
        				for(FollowFollowerOrderRelationEntity followFollowerOrderRelation : followFollowerOrderRelations) {
        					Long followerMemberId = followFollowerOrderRelation.getMemberId();
        					if(!memberId.equals(followerMemberId)) {
        						Long followerOrderId = followFollowerOrderRelation.getOrderId();
        						ContractOrderEntity orderEntity = contractOrderDao.selectById(followerOrderId);
        						BigDecimal rewardAmount = orderEntity.getRewardAmount();
        						allRewardAmount = allRewardAmount.add(rewardAmount);
        						BigDecimal rewardRatio = orderEntity.getRewardRatio();
								rewardRatio = rewardRatio == null ? BigDecimal.ZERO : rewardRatio;
        						allRewardRatio = allRewardRatio.add(rewardRatio);
        					}
        				}
        			}else {
        				myFollowOrderVo.setFollowerNumber(0);
        			}
        			myFollowOrderVo.setFollowerRewardAmount(allRewardAmount);
        			myFollowOrderVo.setFollowerRewardRatio(allRewardRatio);
        			
        			//获取交易员信息
        			FollowTraderInfoEntity followTraderInfoEntity = followTraderInfoDao.selectTraderInfoByMemberId(memberId);
					String nickname = followTraderInfoEntity.getNickname();
					myFollowOrderVo.setNickname(nickname);
					myFollowOrderVo.setOrderId(orderId);
        			String symbol = contractOrderEntity.getSymbol();
        			myFollowOrderVo.setSymbol(symbol);
        			int orderType = contractOrderEntity.getOrderType();
        			myFollowOrderVo.setOrderType(orderType);
        			int leverRatio = contractOrderEntity.getLeverRatio();
        			myFollowOrderVo.setLeverRatio(leverRatio);
        			BigDecimal rewardAmount = contractOrderEntity.getRewardAmount().setScale(2, BigDecimal.ROUND_DOWN);
        			myFollowOrderVo.setRewardAmount(rewardAmount);
        			BigDecimal rewardRatio = contractOrderEntity.getRewardRatio() == null ? BigDecimal.ZERO : contractOrderEntity.getRewardRatio().setScale(4, BigDecimal.ROUND_DOWN);
        			myFollowOrderVo.setRewardRatio(rewardRatio);
        			int symbolCnt = contractOrderEntity.getSymbolCnt();
        			myFollowOrderVo.setSymbolCnt(symbolCnt);
        			BigDecimal bondAmount = contractOrderEntity.getBondAmount().setScale(2, BigDecimal.ROUND_DOWN);
        			myFollowOrderVo.setBondAmount(bondAmount);
        			BigDecimal openingPrice = contractOrderEntity.getOpeningPrice().setScale(2, BigDecimal.ROUND_DOWN);
        			myFollowOrderVo.setOpeningPrice(openingPrice);
        			BigDecimal closingPrice = contractOrderEntity.getClosingPrice().setScale(2, BigDecimal.ROUND_DOWN);
        			myFollowOrderVo.setClosingPrice(closingPrice);
        			Date openingTime = contractOrderEntity.getOpeningTime();
        			myFollowOrderVo.setOpeningTime(openingTime);
        			Date closingTime = contractOrderEntity.getClosingTime();
        			myFollowOrderVo.setClosingTime(closingTime);
        			
        			myFollowOrderVo.setOrderNo(orderNo);
        			myFollowOrderVos.add(myFollowOrderVo);
        		}
        	}
		return Result.ok(myFollowOrderVos);
	}

	@Override
	public Result getTradeFollowInfo(@Valid TradeFollowInfoDto tradeFollowInfoDto) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        List<TradeFollowInfoVo> myFollowOrderVos = new ArrayList<>();
        
        Page<FollowFollowerProfitEntity> page = new Page<>(tradeFollowInfoDto.getPageNum(), tradeFollowInfoDto.getPageSize());
		IPage<FollowFollowerProfitEntity> followFollowerProfitEntitys = followFollowerProfitDao.selectTradeFollowerProfitEntitys(page, memberId);
		List<FollowFollowerProfitEntity> records = followFollowerProfitEntitys.getRecords();
		if(CollUtil.isNotEmpty(records)) {
			for(FollowFollowerProfitEntity followFollowerProfitEntity : records) {
				TradeFollowInfoVo myFollowTraderInfoVo = new TradeFollowInfoVo();
				
				Long followMemberId = followFollowerProfitEntity.getMemberId();
				MemberEntity memberEntity = memberDao.selectById(followMemberId);
				if(ObjectUtil.isNotEmpty(memberEntity)) {
					String phone = memberEntity.getPhone();
					String email = memberEntity.getEmail();
					if(StrUtil.isNotEmpty(phone)) {
						myFollowTraderInfoVo.setNickname(phone);
					}else {
						myFollowTraderInfoVo.setNickname(email);
					}
				}
				
				Long id = followFollowerProfitEntity.getId();
				myFollowTraderInfoVo.setId(id);

				Long tradeId = followFollowerProfitEntity.getTradeId();
				//获取当前跟随者最后一个历史跟单的保证金
				BigDecimal bondAmount = BigDecimal.ZERO;
				List<BigDecimal> bondamounts = followFollowerProfitDao.selectBondAmountByTradeIdAndMemberId(followMemberId,tradeId);
				if(CollUtil.isNotEmpty(bondamounts)){
					bondAmount = bondamounts.get(0).setScale(2, BigDecimal.ROUND_DOWN);

				}
				myFollowTraderInfoVo.setTotalPrincipal(bondAmount);
//				BigDecimal totalPrincipal = followFollowerProfitEntity.getTotalPrincipal();
//				myFollowTraderInfoVo.setTotalPrincipal(totalPrincipal);
				BigDecimal totalProfit = followFollowerProfitEntity.getTotalProfit();
				myFollowTraderInfoVo.setTotalProfit(totalProfit.setScale(2, BigDecimal.ROUND_DOWN));
				
	        	myFollowOrderVos.add(myFollowTraderInfoVo);
	        }
		}
		return Result.ok(myFollowOrderVos);
	}

	@Override
	@Transactional
	public Result getOutFollowInfo(@Valid OutFollowInfoDto outFollowInfoDto) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        long id = outFollowInfoDto.getId();
        //获取【跟随者收益】
        FollowFollowerProfitEntity followFollowerProfitEntity = followFollowerProfitDao.selectById(id);
        
        //当前有跟单合约不允许移除
        //获取【跟随者-订单关联表】
        Map<String, Object> selectColumnMap = new HashMap<>();
        selectColumnMap.put("member_id", followFollowerProfitEntity.getMemberId());
        selectColumnMap.put("trade_member_id", memberId);
        selectColumnMap.put("order_type", FollowFollowerOrderRelationEntity.ORDER_TYPE_HOLD);
        List<FollowFollowerOrderRelationEntity> followFollowerOrderRelationEntitys = followFollowerOrderRelationDao.selectByMap(selectColumnMap);
        if(CollUtil.isNotEmpty(followFollowerOrderRelationEntitys)) {
        	return Result.fail(MessageSourceUtils.getString("documentary_service_0019"));
        }
        
        followFollowerProfitEntity.setIsFollow(FollowFollowerProfitEntity.IS_FOLLOW_N);
        followFollowerProfitDao.updateById(followFollowerProfitEntity);

        //删除【跟随者设置】
        Map<String, Object> columnMap = new HashMap<>();
        Long followMemberId = followFollowerProfitEntity.getMemberId();
        Long tradeId = followFollowerProfitEntity.getTradeId();
        columnMap.put("member_id", followMemberId);
        columnMap.put("trader_id", tradeId);
        List<FollowFollowerSettingEntity> selectByMap = followFollowerSettingDao.selectByMap(columnMap);
        if(CollUtil.isNotEmpty(selectByMap)) {
        	for(FollowFollowerSettingEntity followFollowerSettingEntity : selectByMap) {
        		followFollowerSettingDao.deleteById(followFollowerSettingEntity.getId());
        	}
        }

		FollowTraderInfoEntity traderInfoEntity = followTraderInfoDao.selectTraderInfoByMemberId(memberId);

		if (traderInfoEntity != null) {
			LogRecordUtils.insertFollowerNotice(followMemberId, NoticeConstant.STOP_FOLLOW_TITLE, StrUtil.format(NoticeConstant.STOP_FOLLOW_CONTENT, traderInfoEntity.getNickname()));
		}
		return Result.ok(MessageSourceUtils.getString("member_service_0026"));
	}

	@Override
	@Transactional
	public Result getFollowFollowerNoticeList(FollowFollowerNoticeDto followFollowerNoticeDto) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        List<FollowFollowerNoticeVo> arrayList = new ArrayList<>();
        
        Page<FollowFollowerNoticeEntity> page = new Page<>(followFollowerNoticeDto.getPageNum(), followFollowerNoticeDto.getPageSize());
        FollowFollowerNoticeEntity followFollowerNoticeEntity = new FollowFollowerNoticeEntity();
        followFollowerNoticeEntity.setMemberId(memberId);
        IPage<FollowFollowerNoticeEntity> followFollowerNoticelist = followFollowerNoticeDao.selectFollowFollowerNoticePage(page, followFollowerNoticeEntity);
        List<FollowFollowerNoticeEntity> records = followFollowerNoticelist.getRecords();
		if(CollUtil.isNotEmpty(records)) {
			for(FollowFollowerNoticeEntity followFollowerNotice : records) {
				FollowFollowerNoticeVo followFollowerNoticeVo = new FollowFollowerNoticeVo();
				String title = followFollowerNotice.getTitle();
				followFollowerNoticeVo.setTitle(title);
				String content = followFollowerNotice.getContent();
				followFollowerNoticeVo.setContent(content);
				Date createTime = followFollowerNotice.getCreateTime();
				followFollowerNoticeVo.setCreateTime(createTime);
				arrayList.add(followFollowerNoticeVo);
			}
		}
		MemberSettingEntity memberSettingEntity = memberSettingDao.selectMemberSettingByMemberId(memberId);
		if(ObjectUtil.isNotEmpty(memberSettingEntity)) {
			log.info(memberId + "的消息提醒状态变更");
			memberSettingEntity.setMessageReminder(0);
			memberSettingDao.updateById(memberSettingEntity);
		}
        
		return Result.ok(arrayList);
	}

	@Override
	public Result getTradeSetLabelInfo() {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        
        Map<String, Object> columnMap = new HashMap<>();
		List<FollowTraderLabelEntity> selectByMap = followTraderLabelDao.selectByMap(columnMap);
		ArrayList<TradeSetLabelInfoVo> arrayList = new ArrayList<>();
		if(CollUtil.isNotEmpty(selectByMap)) {
			for(FollowTraderLabelEntity followTraderLabelEntity : selectByMap) {
				TradeSetLabelInfoVo tradeSetLabelInfoVo = new TradeSetLabelInfoVo();
				Long id = followTraderLabelEntity.getId();
				String labels = followTraderLabelEntity.getLabels();
				tradeSetLabelInfoVo.setId(id);
				tradeSetLabelInfoVo.setLabels(labels);
				arrayList.add(tradeSetLabelInfoVo);
			}
		}
		return Result.ok(arrayList);
	}

	@Override
	public Result beTraderCondition() {
		String type = "apply_trader_rule";
		List<BeTraderConditionVo> beTraderConditionVos = followTraderInfoDao.selectBeTraderCondition(type);
		return Result.ok(beTraderConditionVos);
	}

	@Override
	public Result getDocumentaryOrderSetState(String tradeId) {
		//获取用户ID
        Long memberId = LoginUserUtils.getAppLoginUser().getId();
        long parseLong = Long.parseLong(tradeId);
		//交易员判断
		Map<String, Object> columnMapTrader = new HashMap<>();
		columnMapTrader.put("member_id", memberId);
		List<FollowTraderInfoEntity> followTraderInfoEntitys = followTraderInfoDao.selectByMap(columnMapTrader);

		//只能跟随一个人
		Map<String, Object> columnMaps = new HashMap<>();
		columnMaps.put("member_id", memberId);
		List<FollowFollowerSettingEntity> followFollowerSettingEntityAllows = followFollowerSettingDao.selectByMap(columnMaps);

		//没有交易员审核记录
		if(CollUtil.isEmpty(followTraderInfoEntitys)) {
			//没有跟随记录
			if(CollUtil.isEmpty(followFollowerSettingEntityAllows)) {
				return Result.ok("获取成功");
			}else {
				//有跟随记录
				if(followFollowerSettingEntityAllows.size() == 1) {
					Long tradeIdAllow = followFollowerSettingEntityAllows.get(0).getTraderId();
					if(parseLong == tradeIdAllow) {
						return Result.ok("获取成功");
					}else{
						return Result.fail("最多跟单一人");
					}
				}else{
					return Result.fail("已经跟随多人，请修改");
				}
			}
		}else{
			Integer verifyStatus = followTraderInfoEntitys.get(0).getVerifyStatus();
			if(FollowTraderInfoEntity.VERIFYSTATUS_N == verifyStatus) {
				if(CollUtil.isEmpty(followFollowerSettingEntityAllows)) {
					return Result.ok("获取成功");
				}else {
					if(followFollowerSettingEntityAllows.size() == 1) {
						Long tradeIdAllow = followFollowerSettingEntityAllows.get(0).getTraderId();
						if(parseLong == tradeIdAllow) {
							return Result.ok("获取成功");
						}else{
							return Result.fail("最多跟单一人");
						}
					}else{
						return Result.fail("已经跟随多人，请修改");
					}
				}
			}else if(FollowTraderInfoEntity.VERIFYSTATUS_Y == verifyStatus){
				return Result.fail("交易员不允许跟单");
			}else {
				return Result.fail("交易员审核中不允许跟单");
			}
		}
	}
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	

}