package com.zteits.bill.biz.vipcard;

import org.apache.commons.collections4.CollectionUtils;
import com.alibaba.fastjson.JSONObject;
import com.clouds.common.cache.park.ParkingLotCacheUtil;
import com.clouds.common.cache.sys.SysCodeValueCacheUtil;
import com.clouds.common.constants.CodeValKindEnum;
import com.clouds.common.utils.BeanValidatorsUtils;
import com.clouds.common.utils.DateUtil;
import com.clouds.common.utils.ListCopyUtil;
import com.clouds.common.utils.SequenceUtil;
import com.github.pagehelper.PageInfo;
import com.xiaoleilu.hutool.util.CollectionUtil;
import com.zteits.bill.biz.tailNumberLimited.inner.TailNumberLimitInnerService;
import com.zteits.bill.dao.vipcard.*;
import com.zteits.bill.domain.*;
import com.zteits.bill.domain.sdomain.VipCardMaxBuyNumIsLimitDO;
import com.zteits.bill.pagepager.PageBeanUtil;
import com.zteits.clouds.api.apibase.bean.BizResult;
import com.zteits.clouds.api.apibase.bean.PageBean;
import com.zteits.clouds.api.apibase.constants.*;
import com.zteits.clouds.api.apibase.exception.BizException;
import com.zteits.clouds.api.dto.bill.vipcard.*;
import com.zteits.clouds.api.dto.bill.vipcard.param.*;
import com.zteits.clouds.api.dto.park.dto.ParkingLotDTO;
import com.zteits.clouds.api.dto.sys.SysCodeValueDTO;
import com.zteits.clouds.api.service.bill.vipcard.VipCardService;
import jodd.util.StringUtil;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.ZoneId;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 停车场会员卡-(月卡／年卡规则serviceImpl)
 *
 * Copyright: Copyright (c) 2017  ZTE-ITS
 *
 * @ClassName: AmountUtils.java
 * @Description:
 * @version: v1.0.0
 * @author: wangfs
 * @date: 2017年10月27日
 * Modification History:
 * Date             Author          Version            Description
 *---------------------------------------------------------*
 * 2017年10月27日      wangfs           v1.0.0               创建
 */
@Service("com.zteits.bill.biz.vipcard.VipCardServiceImpl")
public class VipCardServiceImpl implements VipCardService {

	private static final Logger logger = LoggerFactory.getLogger(VipCardServiceImpl.class);

	@Autowired
	private VipCardDao vipCardDao;

	@Autowired
	private VipCardCustInfoDao vipCardCustInfoDao;

	@Autowired
	private VipCardParkSaleRelDao vipCardParkSaleRelDao;

	@Autowired
	private VipCardParkCustRelDao vipCardParkCustRelDao;

	@Autowired
	private VipCardCustInfoIrainDao  vipCardCustInfoIrainDao;

	@Autowired
	private TailNumberLimitInnerService tailNumberLimitInnerService;

	@Autowired
	private TVipCardLogsDao tVipCardLogsDao;


	/**
	 * 新增会员卡(年卡／月卡等).<br/>
	 * @return
	 */
	@Override
	public BizResult<Boolean> insertVipCard(VipCardInsertRequest request) throws Exception {
		logger.info("---begin新增会员卡,入参={}",JSONObject.toJSON(request));
		BeanValidatorsUtils.validateWithException(request);
		if(request == null){
			logger.info("入参为空");
			throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
		}
		String vipCardSequenceId = SequenceUtil.getNextId(SequenceTypeEnum.VIP_ID_SQE);
		request.setPrice(request.getPrice() != null ? request.getPrice() * 100 :0L);
		request.setCardNo(vipCardSequenceId);
		if(CollectionUtils.isNotEmpty(request.getVipCardParkSaleRelDTOList())){
			for(VipCardParkSaleRelDTO dto:request.getVipCardParkSaleRelDTOList()){
				if(dto != null){
					dto.setCardNo(vipCardSequenceId);
					dto.setCreateDate(new Date());
					dto.setCreateEmpid(request.getCreateEmpid());
					dto.setCreateName(request.getCreateName());
					dto.setDataState(1);
					dto.setTotalNum(0);
					dto.setSellNum(0);
					dto.setDiscValue(request.getDiscValue());
					dto.setPrice(request.getPrice());
					dto.setOrgId(request.getOrgId());
				}
			}
		}
		int insertCount = vipCardDao.insert(request);
		logger.info("---end新增会员卡,成功插入条数={}条。",insertCount);
		return new BizResult<Boolean>(insertCount > 0 ? true : false);
	}

	/**
	 * 通过会员卡编码查询会员卡信息.<br/>
	 * @param request
	 * @return
	 * @throws Exception
	 */
	@Override
	public BizResult<VipCardDTO> queryVipCardByCardNo(QueryVipCardByCardNoRequest request) throws Exception {
		logger.info("---begin通过会员卡编码查询会员卡信,入参={}",JSONObject.toJSON(request));
		VipCardDTO vipCardDTO = new VipCardDTO();
		if(request != null){
			TVipCard vipCard = vipCardDao.queryVipCardByCardNo(request);
			if(vipCard != null){
				BeanUtils.copyProperties(vipCard, vipCardDTO);

				List<VIPCardParkDTO>  vipCardParkList = new ArrayList<>();
				TVipCardParkSaleRel tVipCardParkSaleRel=new TVipCardParkSaleRel();
				tVipCardParkSaleRel.setCardNo(vipCardDTO.getCardNo());
				//查询会员卡可售卖的停车场编码
				List<TVipCardParkSaleRel> list = vipCardParkSaleRelDao.queryVipCardParkSaleRelForListByCardNo(tVipCardParkSaleRel);
				ListCopyUtil.listCopyProperties(list, vipCardParkList, VIPCardParkDTO.class);
				vipCardDTO.setVipCardParkList(vipCardParkList);

			}
		}else{
			logger.info("入参为空");
			throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
		}
		logger.info("---end通过会员卡编码查询会员卡信..");
		return new BizResult<VipCardDTO>(vipCardDTO);
	}

	@Override
	public BizResult<VipCardDTO> queryVipCardByVipCard(VipCardRequest request) throws Exception {
		logger.info("---begin通过会员卡编码查询会员卡信,入参={}",JSONObject.toJSON(request));
		VipCardDTO vipCardDTO = new VipCardDTO();
		if(request != null){
			TVipCard tVipCard=new TVipCard();
			BeanUtils.copyProperties(request, tVipCard);
			TVipCard vipCardNew = vipCardDao.queryVipCardByVipCard(tVipCard);
			if(vipCardNew != null){
				BeanUtils.copyProperties(vipCardNew, vipCardDTO);
			}
		}else{
			logger.info("入参为空");
			throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
		}
		logger.info("---end通过会员卡编码查询会员卡信..");
		return new BizResult<VipCardDTO>(vipCardDTO);
	}

	@Override
	public BizResult<PageBean<VipCardDTO>> queryVipCardForPageByVipCard(VipCardForPageRequest request) {
		PageBean<VipCardDTO> pageBean = new PageBean<VipCardDTO>();
		logger.info("---begin分页查询会员卡记录,入参={}",JSONObject.toJSON(request));
		if(request == null){
			logger.info("入参为空");
			throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
		}
		PageInfo<TVipCard> pageInfo = vipCardDao.queryVipCardForPageByVipCard(request);
		if(pageInfo != null){
			PageBeanUtil.copyProperties(pageInfo, pageBean, VipCardDTO.class);
		}
		logger.info("---end分页查询会员卡记录...");
		return new BizResult<PageBean<VipCardDTO>>(pageBean);
	}

	@Override
	public BizResult<List<VipCardParkSaleRelDTO>> queryVipCardParkSaleRelForListByCardNo(VipCardRequest request) {
		List<VipCardParkSaleRelDTO> dtoList=new ArrayList<VipCardParkSaleRelDTO>();
		TVipCardParkSaleRel tVipCardParkSaleRel=new TVipCardParkSaleRel();
		if(request == null ){
			logger.info("入参为空");
			throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
		}
		BeanUtils.copyProperties(request, tVipCardParkSaleRel);
		List<TVipCardParkSaleRel> list = vipCardParkSaleRelDao.queryVipCardParkSaleRelForListByCardNo(tVipCardParkSaleRel);
		if(CollectionUtils.isNotEmpty(list)){
			for (TVipCardParkSaleRel vipdo : list) {
				VipCardParkSaleRelDTO dto=new VipCardParkSaleRelDTO();
				if(vipdo !=null){
					BeanUtils.copyProperties(vipdo, dto);
//					String discRuleNo=dto.getDiscRuleNo();
//					if(discRuleNo != null && "".equals(discRuleNo)){
//						TActivityDiscountRule a = activityDiscountRuleDao.queryDiscountRuleByDiscNo(discRuleNo);
//						dto.setDiscValue(a.getDiscValue());
//					}
				}
				dtoList.add(dto);
			}
		}

		return new BizResult<List<VipCardParkSaleRelDTO>>(dtoList);
	}

	/**
	 * 分页查询-会员卡规则.<br/>
	 * @param request
	 * @return
	 */
	@Override
	public BizResult<PageBean<VipCardDTO>> queryVIPCardRuleForPage(QueryVIPCardRuleRequest request) {
		logger.info("---begin分页查询会员卡规则记录,入参={}",JSONObject.toJSON(request));
		PageBean<VipCardDTO> pageBean = new PageBean<VipCardDTO>();
		if(request == null){
			logger.info("入参为空");
			throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
		}
		PageInfo<TVipCard> pageInfo = vipCardDao.queryVIPCardRuleForPage(request);
		PageBeanUtil.copyProperties(pageInfo, pageBean, VipCardDTO.class);
		if(pageBean != null && CollectionUtils.isNotEmpty(pageBean.getDataList())){
			for(VipCardDTO vipCardDTO:pageBean.getDataList()){
				if(vipCardDTO == null){
					continue;
				}
				List<VIPCardParkDTO>  vipCardParkList = new ArrayList<>();
				TVipCardParkSaleRel tVipCardParkSaleRel=new TVipCardParkSaleRel();
				tVipCardParkSaleRel.setCardNo(vipCardDTO.getCardNo());
				//查询会员卡可售卖的停车场编码
				List<TVipCardParkSaleRel> list = vipCardParkSaleRelDao.queryVipCardParkSaleRelForListByCardNo(tVipCardParkSaleRel);
				ListCopyUtil.listCopyProperties(list, vipCardParkList, VIPCardParkDTO.class);
				vipCardDTO.setVipCardParkList(vipCardParkList);
			}

		}
		logger.info("---end分页查询会员卡规则记录");
		return new BizResult<PageBean<VipCardDTO>>(pageBean);
	}

	/**
	 * 校验对应的时间段内停车场是否重复办理.<br/>
	 * @param request
	 * @return
	 */
	@Override
	public BizResult<List<CheckVipCardParkDTO>> checkVipCardPark(CheckVipCardParkRequest request) {
		logger.info("begin校验会员卡是否重复办理服务,入参={}",JSONObject.toJSON(request));

		List<CheckVipCardParkDTO> listDTO = new ArrayList<>();
		List<CheckVipCardParkDO> list = vipCardDao.checkVipCardPark(request);
		ListCopyUtil.listCopyProperties(list, listDTO, CheckVipCardParkDTO.class);
		logger.info("end校验会员卡是否重复办理dubbo服务");
		return new BizResult<List<CheckVipCardParkDTO>>(listDTO);
	}

	/**
	 * 修改会员卡(年卡／月卡等).<br/>
	 * @return
	 */
	@Override
	public BizResult<Boolean> updateVipCard(VipCardUpdateRequest request) throws Exception {
		logger.info("begin修改会员卡,入参={}",JSONObject.toJSON(request));
		if(CollectionUtils.isNotEmpty(request.getVipCardParkSaleRelDTOList())){
			for(VipCardParkSaleRelDTO dto:request.getVipCardParkSaleRelDTOList()){
				if(dto != null){
					dto.setCardNo(request.getCardNo());
					dto.setCreateDate(new Date());
					dto.setCreateEmpid(request.getModifyEmpid());
					dto.setCreateName(request.getModifyName());
					dto.setDataState(1);
					dto.setTotalNum(0);
					dto.setSellNum(0);
					dto.setPrice(request.getPrice() != null ? request.getPrice() * 100 :0L);
					dto.setDiscValue(request.getDiscValue());
				}
			}
		}
		int insertCount = vipCardDao.updateVipCard(request);
		logger.info("end修改会员卡");
		return new BizResult<Boolean>(insertCount > 0 ? true:false);
	}

	/**
	 * 下架(年卡／月卡等).<br/>
	 * @return
	 */
	@Override
	public BizResult<Boolean> deleteVipCard(VipCardUpdateRequest request) throws Exception {
	    //判断是否改卡已经购买过
	    int buyNumber = vipCardCustInfoDao.selectVipCardCustInfoByCardNo(request.getCardNo());
	    if(buyNumber > 0){
	        logger.info("该会员卡["+request.getCardNo()+"]已经购买过，不允许删除!");
	        throw new BizException(ErrorType.VIP_CARD_ALREADY_BUY,ErrorType.VIP_CARD_ALREADY_BUY.getMsg());
	    }
		int updateCount = vipCardDao.deleteVipCard(request);
		return new BizResult<Boolean>(updateCount > 0 ? true:false);
	}

	/**
	 * 查询未推送给第三发的会员卡
	 */
	@Override
	public BizResult<List<VipNoPushCardCustInfoDTO>> queryNoPustVipCardCustInfo(VipPushRequest vipPushRequest) {
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String currentDate = format.format(new Date());
		logger.info("begin查询未推送的会员信息...推送时间={}",currentDate);
		List<TVipNoPushCardCustInfoDO> list=vipCardCustInfoDao.queryNoPustVipCardCustInfo(currentDate,vipPushRequest.getId());
		List<VipNoPushCardCustInfoDTO> dtoList=new ArrayList<VipNoPushCardCustInfoDTO>();
		if(CollectionUtils.isNotEmpty(list)){
			for (TVipNoPushCardCustInfoDO tVipCardCustInfo : list) {
				VipNoPushCardCustInfoDTO dto=new VipNoPushCardCustInfoDTO();
				if(tVipCardCustInfo!=null){
					BeanUtils.copyProperties(tVipCardCustInfo, dto);
					dtoList.add(dto);
				}

			}
		}
		logger.info("end查询未推送的会员信息...查询到未推送条数={}条。",dtoList.size());
		return new BizResult<List<VipNoPushCardCustInfoDTO>>(dtoList);
	}
	/**
	 * 查询推送和未推送给第三发的会员卡
	 */
	@Override
	public BizResult<List<VipNoPushCardCustInfoDTO>> queryPustVipCardCustInfo(VipPushRequest vipPushRequest) {
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String currentDate = format.format(new Date());
		logger.info("begin查询推送和未推送的会员信息...推送时间={}",currentDate);
		List<TVipNoPushCardCustInfoDO> list=vipCardCustInfoDao.queryPustVipCardCustInfo(currentDate,vipPushRequest.getId());
		List<VipNoPushCardCustInfoDTO> dtoList=new ArrayList<VipNoPushCardCustInfoDTO>();
		if(CollectionUtils.isNotEmpty(list)){
			for (TVipNoPushCardCustInfoDO tVipCardCustInfo : list) {
				VipNoPushCardCustInfoDTO dto=new VipNoPushCardCustInfoDTO();
				if(tVipCardCustInfo!=null){
					BeanUtils.copyProperties(tVipCardCustInfo, dto);
					dtoList.add(dto);
				}

			}
		}
		logger.info("end查询未推送的会员信息...查询到未推送条数={}条。",dtoList.size());
		return new BizResult<List<VipNoPushCardCustInfoDTO>>(dtoList);
	}

	@Override
	public VipCardCustInfoDTO queryParentCard(QueryVipCardCustInfoByCustIdRequest requestVip) {
		return vipCardCustInfoDao.queryParentCard(requestVip);
	}

	/**
	 * 更新会员卡推送状态.<br/>
	 * @param vipPushRequest
	 * @return
	 * 2017年12月1日  wangfs.<br/>
	 */
	@Override
	public BizResult<Integer> updateByPrimaryKeySelective(VipPushRequest vipPushRequest) {
		if(vipPushRequest == null){
			logger.info("入参为空");
			throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
		}
		TVipCardParkCustRel record = new TVipCardParkCustRel();
		record.setId(vipPushRequest.getId());
		record.setPushState(vipPushRequest.getPushState());
		record.setRecordNo(vipPushRequest.getRecordNo());
		int updateCount = vipCardParkCustRelDao.updateByPrimaryKeySelective(record);
		return new BizResult<Integer>(updateCount);
	}

	@Override
	public BizResult<PageBean<VIPCardPark4AppDTO>> queryVIPCard4App(QueryVIPCardRuleRequest request) {
		logger.info("---begin分页查询会员卡规则记录,入参={}",JSONObject.toJSON(request));
		PageBean<VIPCardPark4AppDTO> pageBean = new PageBean<VIPCardPark4AppDTO>();
		if(request == null){
			logger.info("入参为空");
			throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
		}
		PageInfo<TVipCardParkSaleRel>  pageInfo = vipCardParkSaleRelDao.querySaleVIPCardRuleForPage(request);
		PageBeanUtil.copyProperties(pageInfo, pageBean, VIPCardPark4AppDTO.class);
		if(pageBean != null && CollectionUtils.isNotEmpty(pageBean.getDataList())){
			for(VIPCardPark4AppDTO vipCardDTO:pageBean.getDataList()){
				if(vipCardDTO == null){
					continue;
				}
				QueryVIPCardRuleRequest QueryVIPCardRuleRequest  = new QueryVIPCardRuleRequest();
				List<String>  plNos = new ArrayList<String>();
				plNos.add(vipCardDTO.getPlNo());
				QueryVIPCardRuleRequest.setPlNos(plNos);
				QueryVIPCardRuleRequest.setSaleChannel(request.getSaleChannel());

				List<VipCardAppDTO>  vipCardParkList = new ArrayList<>();
				List<TVipCard> vipCardList  = vipCardDao.queryParkVipCardByPlNo(QueryVIPCardRuleRequest);
				ListCopyUtil.listCopyProperties(vipCardList, vipCardParkList, VipCardAppDTO.class);
				if(CollectionUtil.isNotEmpty(vipCardParkList)) {
					vipCardParkList.forEach(card->{
						SysCodeValueDTO sysCodeValueDTO  = SysCodeValueCacheUtil.getDTO(CodeValKindEnum.T_IVP_CARD_CARD_TYPE, card.getCardType()+"");
						if(sysCodeValueDTO ==null) {
							throw new BizException(ErrorType.RESOURCE_NOT_EXISTS, "请配置系统码表："+CodeValKindEnum.T_IVP_CARD_CARD_TYPE);
						}
						card.setCardTypeColor(sysCodeValueDTO.getCodeValueColor());
						card.setCardTypeName(sysCodeValueDTO.getCodeValueName());
					});
				}

				ParkingLotDTO parkingLotDTO = ParkingLotCacheUtil.getParkLotByPlNo(vipCardDTO.getPlNo());
				if(parkingLotDTO==null) {
					throw new BizException(ErrorType.RESOURCE_NOT_EXISTS, "请刷新缓存或者检查数据库配置");
				}
				vipCardDTO.setPlName(parkingLotDTO.getPlName());
				vipCardDTO.setPlAddress(vipCardDTO.getPlAddress());
				vipCardDTO.setVipCardList(vipCardParkList);
			}
		}
		logger.info("---end分页查询会员卡规则记录");
		return new BizResult<PageBean<VIPCardPark4AppDTO>>(pageBean);
	}

	@Override
	public BizResult<Integer> insertVipCardIrain(VipCardCustIrainRequest request) {
		List<TVipCardCustInfoIrain> irainVipCardList = new ArrayList<>();
		List<VipCardCustInfoIrainRequest>  irainList = request.getIrainList();
		if(CollectionUtil.isNotEmpty(irainList)) {
			irainList.forEach(cardInforeq->{
				TVipCardCustInfoIrain tVipCardCustInfoIrain = new TVipCardCustInfoIrain();
				BeanUtils.copyProperties(cardInforeq, tVipCardCustInfoIrain);
				irainVipCardList.add(tVipCardCustInfoIrain);
			});
		}
		Integer i = vipCardCustInfoIrainDao.backInsertIrainVipCard(irainVipCardList);
		return new BizResult<Integer>(i);
	}

	@Override
	public BizResult<Integer> deleteVipCardIrainByParkCode(VipCardCustIrainRequest request) {
		if(StringUtil.isBlank(request.getParkCode())) {
			throw new BizException(ErrorType.PARAMM_NULL, "停车场编号不能为空");
		}
		Integer i = vipCardCustInfoIrainDao.deleteByParkCode(request.getParkCode());
		return new BizResult<Integer>(i);
	}

	@Override
	public BizResult<List<String>> queryPlNoList(QueryVipCardByPlNoRequest request) {
		List<String> plNos = vipCardDao.queryPlNoList(request);
		return new BizResult<List<String>>(plNos);
	}

	@Override
	public BizResult<List<String>> queryVipCardNosByPlNos(
			QueryVipCardByPlNoRequest request) {
		List<String> vipCardList = vipCardDao.queryVipCardNosByPlNos(request);
		return new BizResult<List<String>>(vipCardList);
	}

	@Override
	public BizResult<List<VipCardAndCustInfoDTO>> queryVipCardParkSaleRelForListByPlNo(
			QueryVipCardByPlNoRequest request) {
		List<VipCardAndCustInfoDTO> vipCardList = vipCardDao.queryVipCardParkSaleRelForListByPlNo(request);
		return new BizResult<List<VipCardAndCustInfoDTO>>(vipCardList);
	}

	@Override
	public BizResult<List<VipCardListByCardTypeDTO>> queryVipCardParkListByPlNo(
			QueryVipCardByPlNoRequest request) {
		List<VipCardListByCardTypeDTO> vipCardListByCardTypeDTOs = new ArrayList<>();
		List<VipCardAndCustInfoDTO> vipCardList = vipCardDao.queryVipCardParkSaleRelForListByPlNo(request);

		Map<Integer, List<VipCardAndCustInfoDTO>> vipMap = new HashMap<>();
		vipMap = vipCardList.stream().collect(Collectors.groupingBy(VipCardAndCustInfoDTO::getCardType));
		/**合并卡类型相同的会员卡*/
		if(CollectionUtils.isNotEmpty(vipCardList)){
			for(Integer key : vipMap.keySet()){
				VipCardListByCardTypeDTO vipCardListByCardTypeDTO = new VipCardListByCardTypeDTO();
				vipCardListByCardTypeDTO.setCardType(key);
				vipCardListByCardTypeDTO.setVipCardList(vipMap.get(key));
				vipCardListByCardTypeDTOs.add(vipCardListByCardTypeDTO);
			}
		}
		return new BizResult<List<VipCardListByCardTypeDTO>>(vipCardListByCardTypeDTOs);
	}

	@Override
	public BizResult<List<VipCardAndCustInfoDTO>> queryVipCardByCustId(QueryVipCardCustInfoByCustIdRequest request) {
		List<VipCardAndCustInfoDTO> vipCardList = vipCardDao.queryVipCardByCustId(request);
		List<VipCardAndCustInfoDTO> vipCardResList = new ArrayList<>();
		if(CollectionUtils.isNotEmpty(vipCardList)){
			for(VipCardAndCustInfoDTO dto:vipCardList){
				//会员卡合并
				logger.info(" 会员卡合并 ");
				Integer a = 0;
				for(VipCardAndCustInfoDTO dtoR:vipCardResList){
					if(dtoR.getCustCardId().equals(dto.getCustCardId())){
						a=1;
						dtoR.getPlNos().add(dto.getPlNo());
					}
				}
				if(a==0){
					List<String> plNos = new ArrayList<>();
					plNos.add(dto.getPlNo());
					dto.setPlNos(plNos);
					vipCardResList.add(dto);
				}
			}
		}
		return new BizResult<List<VipCardAndCustInfoDTO>>(vipCardResList);
	}

	@Override
	public BizResult<List<VipCardAndCustInfoDTO>> queryVipCardAllByCustId(QueryVipCardCustInfoByCustIdRequest request) {
		List<VipCardAndCustInfoDTO> vipCardList = vipCardDao.queryVipCardAllByCustId(request);
		List<VipCardAndCustInfoDTO> vipCardResList = new ArrayList<>();
		if(CollectionUtils.isNotEmpty(vipCardList)){
			for(VipCardAndCustInfoDTO dto:vipCardList){
				//会员卡合并
				logger.info(" 会员卡合并 ");
				Integer a = 0;
				for(VipCardAndCustInfoDTO dtoR:vipCardResList){
					if(dtoR.getCustCardId().equals(dto.getCustCardId())){
						a=1;
						dtoR.getPlNos().add(dto.getPlNo());
					}
				}
				if(a==0){
					List<String> plNos = new ArrayList<>();
					plNos.add(dto.getPlNo());
					dto.setPlNos(plNos);
					vipCardResList.add(dto);
				}
			}
		}
		return new BizResult<List<VipCardAndCustInfoDTO>>(vipCardResList);
	}

	@Override
	public BizResult<String> saveVipCardForCust(SaveVipCardAndPersonRequest request) throws Exception {
		/** 1.查询会员卡 */
		logger.info(" 1.查询会员卡 ");
		QueryVipCardByCardNoRequest vipCardRequest = new QueryVipCardByCardNoRequest();
		vipCardRequest.setCardNo(request.getCardNo());
		vipCardRequest.setSysCode("1001");
		TVipCard vipCard = vipCardDao.queryVipCardByCardNo(vipCardRequest);

		/** 2.新增会员卡个人购买记录 */
		logger.info("2.新增会员卡个人购买记录  ");
		TVipCardCustInfo tVipCardCustInfo=this.getVipCardCustInfo(vipCard, request);
		if(tVipCardCustInfo !=null){
			tVipCardCustInfo.setModifyName(null);
			vipCardCustInfoDao.saveVipCardCustInfo(tVipCardCustInfo);
		}
		List<String> plNos=new ArrayList<String>();
		/** 3、判断是单体卡还是共享卡*/
		logger.info("3、判断是单体卡还是共享卡:"+tVipCardCustInfo);
		if(vipCard.getUseType()==Integer.parseInt(VIPCardEnum.CARD_USE_TYPE_1.getValue())){
			plNos.add(StringUtils.isNotEmpty(request.getPlNo()) ? request.getPlNo() : null);
		}else{
			/*** 通过卡编码查询关联的停车场 */
			TVipCardParkSaleRel tVipCardParkSaleRel=new TVipCardParkSaleRel();
			tVipCardParkSaleRel.setCardNo(request.getCardNo());
			List<TVipCardParkSaleRel> list = vipCardParkSaleRelDao.queryVipCardParkSaleRelForListByCardNo(tVipCardParkSaleRel);

			for (TVipCardParkSaleRel tdo : list) {
				if(tdo!=null){
					if(!plNos.contains(tdo.getPlNo())){
						plNos.add(tdo.getPlNo());
					}
				}
			}
		}
		/*** 4、新增会员卡和停车场关联信息*/
		logger.info("4、新增会员卡和停车场关联信息:"+plNos.toString());
		for (String plNo : plNos) {
			TVipCardParkCustRel tVipCardParkCustRel =new TVipCardParkCustRel();
			tVipCardParkCustRel.setPlNo(plNo);
			tVipCardParkCustRel.setCustId(request.getCustId());
			tVipCardParkCustRel.setCustCardNo(tVipCardCustInfo.getCustCardNo());
			tVipCardParkCustRel.setCarNumber(request.getCarNumber());
			tVipCardParkCustRel.setCreateDate(new Date());
			tVipCardParkCustRel.setCreateEmpid(request.getCreateEmpid());
			tVipCardParkCustRel.setCreateName(request.getCreateName());
			tVipCardParkCustRel.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
			//推送状态 1:已推送 0:未推送
			tVipCardParkCustRel.setPushState(0);
			//个人会员卡购买类型：1:购卡  2:续费
			tVipCardParkCustRel.setCardBuyType(1);
			vipCardParkCustRelDao.saveVipCardParkCustRel(tVipCardParkCustRel);
		}
		/**5.插入会员卡购买日志**/
		this.saveTVipCardLogs(tVipCardCustInfo,request);

		return new BizResult<String>(tVipCardCustInfo.getCustCardNo());
	}
	/**
	 * 保存会员卡购买日志信息
	 * @param
	 * @return
	 * @Author: xiejianpeng
	 * @Date: 2018/6/22 17:31
	 *
	 */
	private void saveTVipCardLogs(TVipCardCustInfo tVipCardCustInfo,SaveVipCardAndPersonRequest request) {

		TVipCardLogs record = new TVipCardLogs();
		//个人客户id
		record.setCustId(request.getCustId());
		//购买数量
		record.setNum(request.getNum());
		//卡编码
		record.setCardNo(request.getCardNo());
		//个人卡编码
		record.setCustCardNo(tVipCardCustInfo.getCustCardNo());
		//车牌号
		record.setCarNumber(request.getCarNumber());
		//停车场编号
		record.setPlNo(request.getPlNo());
		//业务类型:301：会员卡购买单，302：会员卡续费 ，303:变更车牌
		record.setBusiType(request.getOptType());
		//购买时优惠后金额
		record.setDiscountAmount(tVipCardCustInfo.getDiscountAmount());
		//购买时实收金额=优惠后金额
		record.setCardActAmount(tVipCardCustInfo.getTotalAmount()-tVipCardCustInfo.getDiscountAmount());
		//生效时间
		record.setEffDate(request.getEffDate());
		//失效效时间
		record.setExpDate(request.getExpDate());
		//数据状态
		record.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
		//创建人ID
		record.setCreateEmpid(request.getCreateEmpid() == null ? request.getModifyEmpid() + "" : request.getCreateEmpid() + "");
		//创建人
		record.setCreateName(StringUtils.isEmpty(request.getCreateName()) ? request.getModifyName() : request.getCreateName());
		//创建时间
		record.setCreateDate(new Date());
		int insertSelective = tVipCardLogsDao.insertSelective(record);
		logger.info("会员卡办理,业务类型:(301：会员卡购买单，302：会员卡续费 ，303:变更车牌 业务类型={},插入日志数={}条。", record.getBusiType(), insertSelective);


	}


		/**
         * 获取个人用户购买会员卡记录.<br/>
         * @param vipCard
         */
	private TVipCardCustInfo getVipCardCustInfo(TVipCard vipCard,SaveVipCardAndPersonRequest request){
		logger.info("begin获取个人用户购卡信息");

		if (null == vipCard) {
            throw new BizException(ErrorType.PARAMM_NULL, "vipCard请求对象为空");
        }

		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		TVipCardCustInfo vipCardCustInfo = new TVipCardCustInfo();
		TVipCardParkSaleRel vipCardParkSaleRel = new TVipCardParkSaleRel();
		try{
			/**通过会员卡编码查询会员卡售卖关系.*/
			if(StringUtils.isNotEmpty(vipCard.getCardNo())){
				vipCardParkSaleRel = this.queryVipCardParkSaleRelForListByCardNo(vipCard.getCardNo());
			}
			//个人会员卡编码
			vipCardCustInfo.setCustCardNo(SequenceUtil.getNextId(SequenceTypeEnum.PERSON_CUST_CARD_NO_SQE));
			//客户id
			vipCardCustInfo.setCustId(request.getCustId());
	        //卡编码
			vipCardCustInfo.setCardNo(vipCard.getCardNo());
	        //绑定的车牌号
			vipCardCustInfo.setCarNumber(request.getCarNumber());
			//是否支持续费1：是，0否
			vipCardCustInfo.setIsSupportRenew(vipCard.getIsSupportRenew());
		    //购卡来源: 1:App购买 2:公众号购买 3:线下购买
			vipCardCustInfo.setCardRes(Integer.valueOf(VIPCardEnum.CARD_RES_1.getValue()));
			//车辆类型 1:大型车 2:小型车
			 if(vipCardCustInfo.getCarType() ==null){
				 vipCardCustInfo.setCarType(vipCard.getCarType());
			 }
			 //卡单价:分
			 vipCardCustInfo.setPrice(vipCard.getPrice());
	         //购买时的数量
			 vipCardCustInfo.setNum(request.getNum());
	         //生效效时间
			 vipCardCustInfo.setEffDate(request.getEffDate());

			 //购买时的总金额 = 单价 * 数量
			 vipCardCustInfo.setTotalAmount(vipCard.getPrice() * request.getNum());
			 //优惠规则编码
			 vipCardCustInfo.setDiscNo(vipCardParkSaleRel.getDiscNo());
			 //折扣规则编码
			 vipCardCustInfo.setDiscRuleNo(vipCardParkSaleRel.getDiscRuleNo());
			 //购买时优惠金额
			 if(StringUtils.isNotEmpty(vipCardParkSaleRel.getDiscValue())){
				 Double discAmount = Math.ceil(vipCard.getPrice() * request.getNum()  * (1-Double.valueOf(vipCardParkSaleRel.getDiscValue())/10));
				 vipCardCustInfo.setDiscountAmount(discAmount.longValue());
			 }else{
				 vipCardCustInfo.setDiscountAmount(0L);
			 }
		     //失效时间
			 vipCardCustInfo.setExpDate(request.getExpDate());
			//备注
			vipCardCustInfo.setRemark("APP购买会员卡");
		    //审核状态1:待审核 2: 审核不通过 3:审核通过
			vipCardCustInfo.setCheckStatus(3);
			//数据状态 1:生效 0:失效
			vipCardCustInfo.setDataState(1);

			vipCardCustInfo.setPlNo(request.getPlNo());
			//创建时间
			vipCardCustInfo.setCreateDate(new Date());
		}catch (Exception e) {
			logger.info("获取个人用户购卡信息,获取数据异常....");
			e.printStackTrace();
			throw new BizException(ErrorType.BIZ_ERROR, "获取个人用户购卡信息,获取数据异常!");
		}
		logger.info("end获取个人用户购卡信息");

		return vipCardCustInfo;
	}
	/**
	 * 通过会员卡编码查询会员卡售卖关系.<br/>
	 * @param cardNo
	 * @return
	 */
	private TVipCardParkSaleRel queryVipCardParkSaleRelForListByCardNo(String cardNo){
		logger.info("---begin通过会员卡编码查询会员卡售卖关系,入参={}",cardNo);
		TVipCardParkSaleRel vipCardParkSaleRel = new TVipCardParkSaleRel();
		if(StringUtils.isNotEmpty(cardNo)){
			TVipCardParkSaleRel vipCardParkSaleRelDO = new TVipCardParkSaleRel();
			vipCardParkSaleRelDO.setCardNo(cardNo);
			List<TVipCardParkSaleRel> list = vipCardParkSaleRelDao.queryVipCardParkSaleRelForListByCardNo(vipCardParkSaleRelDO);
			if(CollectionUtils.isNotEmpty(list)){
				vipCardParkSaleRel = list.get(0);
			}
		}
		logger.info("---begin通过会员卡编码查询会员卡售卖关系,结果={}",JSONObject.toJSON(vipCardParkSaleRel));
		return vipCardParkSaleRel;

	}

	@Override
	public BizResult<String> updateVipCardForCust(SaveVipCardAndPersonRequest request) {
		/**1.修改个人用户购买会员卡记录*/
		logger.info("1、修改个人用户购买会员卡记录:"+JSONObject.toJSON(request));
		TVipCardCustInfo vipCardCustInfo = vipCardCustInfoDao.queryCardCustInfoBycustCardNo(request.getCustCardNo());

		TVipCardCustInfo tVipCardCustInfo=new TVipCardCustInfo();
		tVipCardCustInfo.setPrice(request.getPrice());
		tVipCardCustInfo.setNum(vipCardCustInfo.getNum() + request.getNum());
		tVipCardCustInfo.setDiscountAmount(vipCardCustInfo.getDiscountAmount() + request.getDiscountAmount());
		tVipCardCustInfo.setTotalAmount(vipCardCustInfo.getTotalAmount() + request.getPrice()*request.getNum());
		tVipCardCustInfo.setModifyDate(new Date());
		tVipCardCustInfo.setModifyEmpid(request.getCreateEmpid());
		tVipCardCustInfo.setCustCardNo(request.getCustCardNo());
		//失效时间
		tVipCardCustInfo.setExpDate(request.getExpDate());
		vipCardCustInfoDao.updateVipCardCustInfoByCustCardNo(tVipCardCustInfo);

		/**2.修改用户购买的会员卡关联的停车场**/
		logger.info("2、修改用户购买的会员卡关联的停车场录:"+request.toString());
		TVipCardParkCustRel tVipCardParkCustRel =new TVipCardParkCustRel();
		tVipCardParkCustRel.setCustId(request.getCustId());
		tVipCardParkCustRel.setCustCardNo(request.getCustCardNo());
		tVipCardParkCustRel.setModifyDate(new Date());
		tVipCardParkCustRel.setModifyEmpid(request.getCreateEmpid());
		tVipCardParkCustRel.setModifyName(request.getCreateName());
		//推送状态 1:已推送 0:未推送
		tVipCardParkCustRel.setPushState(0);
		//个人会员卡购买类型：1:购卡  2:续费
		tVipCardParkCustRel.setCardBuyType(2);
		vipCardParkCustRelDao.updateVipCardParkCustRelByCustCardId(tVipCardParkCustRel);
		/**3.插入会员卡购买日志*/
		this.saveTVipCardLogs(tVipCardCustInfo,request);

		return new BizResult<String>(tVipCardCustInfo.getCustCardNo());
	}

	@Override
	public BizResult<List<VipCardAndCustInfoDTO>> queryVipCardMsgByCardNo(QueryVipCardByCardNoRequest request) {
		List<VipCardAndCustInfoDTO> vipCardList = vipCardDao.queryVipCardMsgByCardNo(request);
		List<VipCardAndCustInfoDTO> vipCardResList = new ArrayList<>();
		if(CollectionUtils.isNotEmpty(vipCardList)){
			for(VipCardAndCustInfoDTO dto:vipCardList){
				//会员卡合并
				Integer a = 0;
				for(VipCardAndCustInfoDTO dtoR:vipCardResList){
					if(dto.getCardNo().equals(dto.getCardNo())){
						a=1;
						dtoR.getPlNos().add(dto.getPlNo());
					}
				}
				if(a==0){
					List<String> plNos = new ArrayList<>();
					plNos.add(dto.getPlNo());
					dto.setPlNos(plNos);
					vipCardResList.add(dto);
				}
			}
		}
		return new BizResult<List<VipCardAndCustInfoDTO>>(vipCardResList);
	}

	@Override
	public BizResult<Long> queryVipCardFeeByCardNo(QueryVipCardFeeByCardNoRequest request) throws Exception {

		return new BizResult<Long> (vipCardDao.queryVipCardFeeByCardNo (request.getCardNo()));
	}

	@Override
	public BizResult<List<VipNoPushCardCustInfoDTO>> queryCouponNoPushInfo(VipPushRequest vipPushRequest) {
		List<VipNoPushCardCustInfoDTO> dtoList=new ArrayList<VipNoPushCardCustInfoDTO>();
		String date = DateUtil.getDateString(vipPushRequest.getPushDate(), DateUtil.DATETIME_FORMAT);
		logger.info("查询购买了卡类型为：6-错峰停车年卡（周末免费），7-错峰停车月卡（周末免费）的会员卡信息...推送时间={}",date);
		List<TVipNoPushCardCustInfoDO> list=vipCardCustInfoDao.queryCouponNoPushInfo(date);
		BizResult<List<VipNoPushCardCustInfoDTO>> bizResult = new BizResult<>();
		if(CollectionUtils.isEmpty(list)){
			bizResult.setSuccess(false);
			bizResult.setErrMsg("没有查询到购买了卡类型为错峰停车的会员卡信息");
			return bizResult;
		}
		logger.info("查询到购买了卡类型为错峰停车的会员卡信息{}条",list.size());
		//判断是否周末，如果为周末全部下发优惠券
		Instant instant = vipPushRequest.getPushDate().toInstant();
        ZoneId zoneId = ZoneId.systemDefault();
		DayOfWeek dayOfWeek = instant.atZone(zoneId).getDayOfWeek();
		if(dayOfWeek == DayOfWeek.SATURDAY || dayOfWeek == DayOfWeek.SUNDAY){
			for (TVipNoPushCardCustInfoDO tVipCardCustInfo : list) {
				VipNoPushCardCustInfoDTO dto=new VipNoPushCardCustInfoDTO();
				BeanUtils.copyProperties(tVipCardCustInfo, dto);
				dtoList.add(dto);
			}
			logger.info("推送时间为周末，返回全部错峰停车会员卡信息...查询到条数={}条。",dtoList.size());
			return new BizResult<List<VipNoPushCardCustInfoDTO>>(dtoList);
		}
		//判断车辆是否限行,目前只查询北京的
		List<TbTailNumberLimitedRuleDO> limitedRules = tailNumberLimitInnerService.queryTailNumberLimitRules(110100L, DateUtil.to_date(date, DateUtil.DATE_FORMAT));
		if(CollectionUtils.isEmpty(limitedRules)){
			bizResult.setSuccess(false);
			bizResult.setErrMsg("该城市：110100（北京）没有查询到"+DateUtil.to_date(date, DateUtil.DATE_FORMAT)+"的限行规则");
			return bizResult;
		}
		//筛选出限行的车辆信息
		List<TVipNoPushCardCustInfoDO> cardCustInfoDOs = new ArrayList<>();
		for(TVipNoPushCardCustInfoDO cardCustInfo:list){
			if(tailNumberLimitInnerService.isLimitedForCarNumber(cardCustInfo.getCarNumber(), limitedRules)){
				cardCustInfoDOs.add(cardCustInfo);
			}
		}
		if(CollectionUtils.isEmpty(cardCustInfoDOs)){
			bizResult.setSuccess(false);
			bizResult.setErrMsg("根据限号规则，没有找到限号的车辆信息");
			return bizResult;
		}

		for (TVipNoPushCardCustInfoDO tVipCardCustInfo : cardCustInfoDOs) {
			VipNoPushCardCustInfoDTO dto=new VipNoPushCardCustInfoDTO();
			if(tVipCardCustInfo!=null){
				BeanUtils.copyProperties(tVipCardCustInfo, dto);
				dtoList.add(dto);
			}
		}
		logger.info("根据限号规则查询到购买了错峰停车的会员卡信息条数={}条。",dtoList.size());
		return new BizResult<List<VipNoPushCardCustInfoDTO>>(dtoList);
	}

	@Override
	public BizResult<List<VipCardStatisticDTO>> queryVipCardStatisticPlNos(QueryVipCardByCarNumberAndPlNosRequest request) {
		logger.info("---通过停车场编码List查询的的授权车的信息,入参={}",JSONObject.toJSON(request));
		if(request == null){
			logger.info("入参为空");
			throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
		}
		List<VipCardStatisticDTO> vipCardStatisticDTOs = vipCardDao.queryVipCardStatisticPlNos(request);
		return new BizResult<List<VipCardStatisticDTO>>(vipCardStatisticDTOs);
	}

	 /**
     * 通过停车场编码及卡编码查询会员卡规则售卖关系
     * @param request
     * @return
     * 2018年5月19日  wangfs.<br/>
     */
	@Override
	public BizResult<VipCardParkSaleRelDTO> queryCardParkSaleByPlNoAndCardNo(
			QueryCardParkSaleByPlNoAndCardNoReq request) {
		VipCardParkSaleRelDTO vipCardParkSaleRelDTO = new VipCardParkSaleRelDTO();
		TVipCardParkSaleRel queryCardParkSaleByPlNoAndCardNo = vipCardParkSaleRelDao.queryCardParkSaleByPlNoAndCardNo(request);
		if(queryCardParkSaleByPlNoAndCardNo != null){
			BeanUtils.copyProperties(queryCardParkSaleByPlNoAndCardNo, vipCardParkSaleRelDTO);
		}
		return new BizResult<VipCardParkSaleRelDTO>(vipCardParkSaleRelDTO);
	}

	/**
	 * 查询停车场会员卡购买数量是否超过最大限制数量
	 * @param request
	 * @return true : 超过最大数量 ; false:没有超过最大数量
	 */
	@Override
	public BizResult<Boolean> queryVipCardMaxBuyNumIsLimit(VipCardBuyNumLimtReq request) {
		logger.info("begin查询停车场会员卡购买数量是否超过最大限制数量,入参={}",request);
		BizResult<Boolean> result = new BizResult<Boolean>();
		Boolean flg = false; //true : 超过最大数量 ; false:没有超过最大数量

		VipCardMaxBuyNumIsLimitDO vipCardMaxBuyNumIsLimitDO = vipCardDao.queryVipCardMaxBuyNumIsLimit(request);
		if(vipCardMaxBuyNumIsLimitDO != null ){
			if(vipCardMaxBuyNumIsLimitDO.getMaxLimitNum() ==0 || null == vipCardMaxBuyNumIsLimitDO.getMaxLimitNum() ){
				flg = false;
			}else if(vipCardMaxBuyNumIsLimitDO.getBuyTotal() == 0 && vipCardMaxBuyNumIsLimitDO.getMaxLimitNum() ==0){
				flg = false;
			}else{
				if(vipCardMaxBuyNumIsLimitDO.getBuyTotal() < vipCardMaxBuyNumIsLimitDO.getMaxLimitNum()){
					flg = false;
				}else{
					flg = true;
				}
			}
		}else{
			flg = true;
		}

		//result.setData(flg);
		logger.info("end查询停车场会员卡购买数量是否超过最大限制数量,结果={},[true : 超过最大数量 ; false:没有超过最大数量]",flg);

		//校验入参数
		return new BizResult<Boolean>(flg);
	}

	@Override
	public BizResult<List<String>> queryParkListForVipCard(QueryVipCardPlNoListRequest req) {
		List<String> list = vipCardDao.queryParkListForVipCard(req);
		return new BizResult<>(list);
	}

	@Override
	public BizResult<List<String>> queryHotParkListForVipCard(QueryVipCardPlNoListRequest req) {
		List<String> list = vipCardDao.queryHotParkListForVipCard(req);
		return new BizResult<>(list);
	}

	@Override
	public BizResult<List<VipCardDTO>> queryVipCardInfoByPlNo(QueryVipCardByPlNoRequest req) {
		req.setNowDate(new Date());
		List<VipCardDTO> list = vipCardDao.queryVipCardInfoByPlNo(req);
		if(CollectionUtils.isEmpty(list)){
			return new BizResult<>(list);
		}
		list.stream().forEach(dto -> dto.setDiscValue(StringUtils.isBlank(dto.getDiscValue()) ? "10" : dto.getDiscValue()));
		return new BizResult<>(list);
	}

	@Override
	public BizResult<String> updateVipCardCarNumberBycustCardNo(SaveVipCardAndPersonRequest req) {
		logger.info("修改会员卡车牌入参={}", JSONObject.toJSON(req));

		if (req == null || StringUtils.isEmpty(req.getCustCardNo()) || StringUtils.isEmpty(req.getCarNumber())) {
			throw new BizException(ErrorType.PARAMM_NULL, "入参为空或个人会员卡编码/车牌号为空!");
		}

		try {
			// 1. 查询现有的会员卡信息
			TVipCardCustInfo vipCardCustInfo = vipCardCustInfoDao.queryCardCustInfoBycustCardNo(req.getCustCardNo());
			if (vipCardCustInfo == null) {
				throw new BizException(ErrorType.RESOURCE_NOT_EXISTS, "会员卡信息不存在!");
			}

			// 2. 修改车牌信息
			TVipCardCustInfo updateInfo = new TVipCardCustInfo();
			updateInfo.setCustCardNo(req.getCustCardNo());
			updateInfo.setCarNumber(req.getCarNumber());
			updateInfo.setModifyDate(new Date());
			updateInfo.setModifyEmpid(req.getModifyEmpid());
			updateInfo.setModifyName(req.getModifyName());
			updateInfo.setUpdateNum(vipCardCustInfo.getUpdateNum()-1);

			// 3. 更新会员卡信息
			int updateCount = vipCardCustInfoDao.updateVipCardCustInfoByCustCardNo(updateInfo);
			if (updateCount <= 0) {
				throw new BizException(ErrorType.BIZ_ERROR, "修改会员卡车牌失败!");
			}

			// 4. 更新关联的停车场信息
			TVipCardParkCustRel parkCustRel = new TVipCardParkCustRel();
			parkCustRel.setCustCardNo(req.getCustCardNo());
			parkCustRel.setCarNumber(req.getCarNumber());
			parkCustRel.setModifyDate(new Date());
			parkCustRel.setModifyEmpid(req.getModifyEmpid());
			parkCustRel.setModifyName(req.getModifyName());
			// 推送状态 1:已推送 0:未推送
			parkCustRel.setPushState(0);

			vipCardParkCustRelDao.updateVipCardParkCustRelByCustCardId(parkCustRel);

			// 5. 插入会员卡变更日志
			// 设置业务类型为变更车牌
//			req.setOptType(303);
//			this.saveTVipCardLogs(updateInfo, req);
//
			logger.info("修改会员卡车牌成功,个人会员卡编码={}", req.getCustCardNo());
			return new BizResult<String>(req.getCustCardNo());
		} catch (BizException e) {
			logger.error("修改会员卡车牌业务异常:", e);
			throw e;
		} catch (Exception e) {
			logger.error("修改会员卡车牌系统异常:", e);
			throw new BizException(ErrorType.BIZ_ERROR, "修改会员卡车牌失败!");
		}
	}

	@Override
	public BizResult<Boolean> resetVipCardUpdateNum(int updateNum) {
		logger.info("---begin重置会员卡修改次数,入参={}", updateNum);
		int rows = vipCardCustInfoDao.resetVipCardUpdateNum(updateNum);
		logger.info("---end重置会员卡修改次数,影响行数={}", rows);
		return rows > 0 ? new BizResult<Boolean>(true) : new BizResult<Boolean>(false);
	}

}