BJ_ZTEITS-Developers / parking-cloud

package com.zteits.bill.biz.vipcard;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.Map.Entry;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.clouds.common.cache.park.ParkingLotCacheUtil;
import com.clouds.common.constants.HolidayEnum;
import com.clouds.common.utils.ListCopyUtil;
import com.clouds.common.utils.SequenceUtil;
import com.github.pagehelper.PageInfo;
import com.google.common.collect.Lists;
import com.xiaoleilu.hutool.date.DateField;
import com.xiaoleilu.hutool.date.DateUnit;
import com.xiaoleilu.hutool.date.DateUtil;
import com.zteits.bill.biz.vipcard.inner.VipCardInnerService;
import com.zteits.bill.dao.vipcard.TVipCardLogsDao;
import com.zteits.bill.dao.vipcard.VipCardCustInfoDao;
import com.zteits.bill.dao.vipcard.VipCardDao;
import com.zteits.bill.dao.vipcard.VipCardParkCustRelDao;
import com.zteits.bill.dao.vipcard.VipCardParkSaleRelDao;
import com.zteits.bill.domain.TVipCard;
import com.zteits.bill.domain.TVipCardCustInfo;
import com.zteits.bill.domain.TVipCardLogs;
import com.zteits.bill.domain.TVipCardParkCustRel;
import com.zteits.bill.domain.TVipCardParkSaleRel;
import com.zteits.bill.domain.TdBVipCardInfoCheckDayDO;
import com.zteits.bill.domain.sdomain.VipCardCustInfoBuyDO;
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.BasicEnum;
import com.zteits.clouds.api.apibase.constants.DataStatusEnum;
import com.zteits.clouds.api.apibase.constants.ErrorType;
import com.zteits.clouds.api.apibase.constants.OrderBigTypeEnum;
import com.zteits.clouds.api.apibase.constants.OrderStateEnum;
import com.zteits.clouds.api.apibase.constants.ParkDetailTypeEnum;
import com.zteits.clouds.api.apibase.constants.PayOrderTypeEnum;
import com.zteits.clouds.api.apibase.constants.PayTypeEnum;
import com.zteits.clouds.api.apibase.constants.SequenceTypeEnum;
import com.zteits.clouds.api.apibase.constants.TerminalSourceEnum;
import com.zteits.clouds.api.apibase.constants.VIPCardEnum;
import com.zteits.clouds.api.apibase.exception.BizException;
import com.zteits.clouds.api.dto.bill.holiday.dto.SpHolidaysDTO;
import com.zteits.clouds.api.dto.bill.holiday.param.DaysInfoQueryReq;
import com.zteits.clouds.api.dto.bill.vipcard.*;
import com.zteits.clouds.api.dto.bill.vipcard.param.*;
import com.zteits.clouds.api.dto.bill.whitelist.CarNumIsFreeDTO;
import com.zteits.clouds.api.dto.bill.whitelist.param.QueryCarNumIsWhitelistRequest;
import com.zteits.clouds.api.dto.order.payorder.dto.PayOrderDTO;
import com.zteits.clouds.api.dto.order.payorder.dto.PayOrderDiscountRemarkDTO;
import com.zteits.clouds.api.dto.order.vipcardorder.dto.OrderVipcardDTO;
import com.zteits.clouds.api.dto.order.vipcardorder.dto.OrderVipcardDetailDTO;
import com.zteits.clouds.api.dto.order.vipcardorder.dto.VipCardBuyPayTypeDTO;
import com.zteits.clouds.api.dto.order.vipcardorder.param.NewPayOrderRecordRequest;
import com.zteits.clouds.api.dto.order.vipcardorder.param.OrderVipcardAndDetailRequest;
import com.zteits.clouds.api.dto.order.vipcardorder.param.QueryOrderIDByPersonCardNoRequest;
import com.zteits.clouds.api.dto.order.vipcardorder.param.QueryVipCardBuyPayTypeRequest;
import com.zteits.clouds.api.dto.order.vipcardorder.param.SaveVipCardOrderAndDetailAndPayOrderReq;
import com.zteits.clouds.api.dto.order.vipcardorder.param.UpdateOrderVipcardRequest;
import com.zteits.clouds.api.dto.order.vipcardorder.param.UpdatePayOrderRequest;
import com.zteits.clouds.api.dto.order.vipcardorder.param.UpdateVipcardDetailReq;
import com.zteits.clouds.api.dto.park.dto.ParkingLotDTO;
import com.zteits.clouds.api.dto.park.param.QueryParkLotInfoByPkNoRequest;
import com.zteits.clouds.api.dto.park.param.QueryParkLotInfoByPkNosRequest;
import com.zteits.clouds.api.dto.pay.TdBCheckDayDTO;
import com.zteits.clouds.api.dto.pay.TdCCustPersonDTO;
import com.zteits.clouds.api.dto.pay.param.AppPayCardOrderRequest;
import com.zteits.clouds.api.dto.pay.param.TdCCarEditRequest;
import com.zteits.clouds.api.dto.pay.param.TdCCustPersonByCustIdRequest;
import com.zteits.clouds.api.service.bill.holiday.HolidayService;
import com.zteits.clouds.api.service.bill.vipcard.VipCardCustInfoService;
import com.zteits.clouds.api.service.order.vipcardorder.oper.VipCardOrderOperService;
import com.zteits.clouds.api.service.order.vipcardorder.query.VipCardOrderQueryService;
import com.zteits.clouds.api.service.park.ParkingLotQueryService;
import com.zteits.clouds.api.service.pay.TdCCustPersonService;
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 org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.Map.Entry;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 个人购买会员卡记录serviceImpl.<br/>
 * <p>
 * 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.VipCardCustInfoServiceImpl")
public class VipCardCustInfoServiceImpl implements VipCardCustInfoService {

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

    @Autowired
    private VipCardCustInfoDao vipCardCustInfoDao;

    @Autowired
    private VipCardInnerService vipCardInnerService;

    @Autowired
    private VipCardDao vipCardDao;

    @Autowired
    private VipCardParkSaleRelDao vipCardParkSaleRelDao;

    @Autowired
    private VipCardParkCustRelDao vipCardParkCustRelDao;

    @Autowired
    private HolidayService holidayService;

    @Autowired
    private VipCardOrderOperService vipCardOrderOperService;

    /**
     * 会员卡订单service
     */
    @Autowired
    private VipCardOrderQueryService vipCardOrderQueryService;

    @Autowired
    private TdCCustPersonService tdCCustPersonService;

    @Autowired
    private ParkingLotQueryService parkingLotQueryService;
    @Autowired
    private TVipCardLogsDao tVipCardLogsDao;

    /**
     * 分页查询-用户购买会员卡记录.<br/>
     *
     * @param request
     * @return
     */
    @Override
    public BizResult<PageBean<VipCardCustInfoBuyDTO>> queryVipCardCustInfoForPage(VipCardCustInfoBuyReq request) {
        PageBean<VipCardCustInfoBuyDTO> pageBean = new PageBean<VipCardCustInfoBuyDTO>();
        logger.info("---begin分页查询用户购买会员卡记录,入参={}", JSONObject.toJSON(request));
        if (request == null) {

            logger.info("入参为空");
            throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
        }
        PageInfo<VipCardCustInfoBuyDO> pageInfo = vipCardCustInfoDao.queryVipCardCustInfoForPage(request);
        this.queryParkNameAndPersonCustInfo(pageInfo);
        PageBeanUtil.copyProperties(pageInfo, pageBean, VipCardCustInfoBuyDTO.class);
        logger.info("---end分页查询用户购买会员卡记录...");
        return new BizResult<PageBean<VipCardCustInfoBuyDTO>>(pageBean);
    }

    /**
     * 获取停车场信息及个人客户信息.<br/>
     *
     * @param pageInfo
     *     2018年5月15日  wangfs.<br/>
     */
    private void queryParkNameAndPersonCustInfo(PageInfo<VipCardCustInfoBuyDO> pageInfo) {
        //计算剩余天数
        Date currntDate = DateUtil.parse(DateUtil.format(new Date(), DateUtil.NORM_DATE_PATTERN));
        List<String> plNosList = new ArrayList<>();
        if (pageInfo != null && !CollectionUtils.isEmpty(pageInfo.getList())) {
            List<VipCardCustInfoBuyDO> list = pageInfo.getList();
            for (VipCardCustInfoBuyDO dos : list) {
                if (dos == null) {
                    continue;
                }
                //1.计算失效状态
                if (dos.getExpDate() == null) {
                    dos.setDueDate("0天");
                } else {
                    //					Date currntDate = DateUtil.parse(DateUtil.format(new Date(),DateUtil
					//					.NORM_DATE_PATTERN));
                    //					Date expDate = DateUtil.parse(DateUtil.format(dos.getExpDate(), DateUtil
					//					.NORM_DATE_PATTERN));
                    //					int dueDate = (int) ((expDate.getTime() - currntDate.getTime()) /
					//					(1000*3600*24));
                    //					dos.setDueDate(dueDate > 0 ? (dueDate+"天") : "0天");
                    Date effDate = DateUtil.parse(DateUtil.format(dos.getEffDate(), DateUtil.NORM_DATE_PATTERN));
                    Date expDate = DateUtil.parse(DateUtil.format(dos.getExpDate(), DateUtil.NORM_DATE_PATTERN));
                    if (effDate.getTime() > currntDate.getTime()) {
                        int dueDate = (int)((expDate.getTime() - effDate.getTime()) / (1000 * 3600 * 24));
                        dos.setDueDate(dueDate > 0 ? dueDate + 1 + " 天" : "0 天");
                    } else if (currntDate.getTime() > expDate.getTime()) {
                        dos.setDueDate("0 天");
                    } else {
                        int dueDate = (int)((expDate.getTime() - currntDate.getTime()) / (1000 * 3600 * 24));
                        dos.setDueDate(dueDate + 1 + " 天");
                    }
                }
                ;
                //DateUtil.formatBetween
                if (!plNosList.contains(dos.getPlNo())) {
                    plNosList.add(dos.getPlNo());
                }
                if (StringUtils.isNotEmpty(dos.getPeronCustId())) {
                    //查询个人信息
                    TdCCustPersonByCustIdRequest request1 = new TdCCustPersonByCustIdRequest();
                    request1.setSysCode("1001");
                    request1.setCustId(dos.getPeronCustId());
                    //根据客户id查询客户信息
                    BizResult<TdCCustPersonDTO> personDTO = tdCCustPersonService.queryPersonByCustId(request1);
                    logger.info("---end--根据客户id查询客户信息,结果＝{}", JSONObject.toJSONString(personDTO));
                    if (personDTO != null && personDTO.getData() != null) {
                        dos.setPersonCustName(personDTO.getData().getCustName());
                        dos.setUserPhone(personDTO.getData().getUserPhone());
                    }
                }
            }
        }
        //获取停车场名称
        if (CollectionUtils.isNotEmpty(plNosList)) {
            QueryParkLotInfoByPkNosRequest request = new QueryParkLotInfoByPkNosRequest();
            request.setPlNos(plNosList);
            request.setSysCode(BasicEnum.SYS_CODE.getValue());
            BizResult<List<ParkingLotDTO>> result = parkingLotQueryService.QueryParkingLotByPkNos(request);
            if (result != null && CollectionUtils.isNotEmpty(result.getData())) {
                //转map
                Map<String, ParkingLotDTO> collect = result.getData().stream().
                    collect(Collectors.toMap(ParkingLotDTO::getPlNo, Function.identity(), (key1, key2) -> key2));
                if (pageInfo != null && !CollectionUtils.isEmpty(pageInfo.getList())) {
                    List<VipCardCustInfoBuyDO> list = pageInfo.getList();
                    for (VipCardCustInfoBuyDO dos : list) {
                        if (dos == null) {
                            continue;
                        }
                        ParkingLotDTO parkingLotDTO = collect.get(dos.getPlNo());
                        if (parkingLotDTO != null) {
                            dos.setPlName(parkingLotDTO.getPlName());
                            dos.setPlType(parkingLotDTO.getPlType());
                        }

                    }
                }
            }
        }

    }

    /**
     * 保存用户购买会员卡记录.<br/>
     *
     * @param request
     * @return
     * @throws Exception
     */
    @Override
    public BizResult<Boolean> saveVipCardCustInfo(SaveVipCardCustInfoRequest request) throws Exception {
        logger.info("---begin保存用户购买会员卡记录,入参={}", JSONObject.toJSON(request));
        int insertCount = 0;
        if (request == null) {
            logger.info("入参为空");
            throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
        } else {
            TVipCardCustInfo tVipCardCustInfo = new TVipCardCustInfo();
            BeanUtils.copyProperties(request, tVipCardCustInfo);
            insertCount = vipCardCustInfoDao.saveVipCardCustInfo(tVipCardCustInfo);
        }
        logger.info("---begin保存用户购买会员卡记录,成功插入={}条", insertCount);
        return new BizResult<Boolean>(insertCount > 0 ? true : false);

    }

    /************************************************************************************************************************/
    /**
     * 保存会员卡和个人客户信息-新增  wangfs
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BizResult<Boolean> saveVipCardCustInfoAndPerson(SaveVipCardCustInfoBuyReq request) throws Exception {
        int insertCount = 0;
        logger.info("---begin--根据会员卡编码查询会员卡信息,入参＝{}", JSONObject.toJSON(request));
        if (request == null || CollectionUtils.isEmpty(request.getDetailList())) {
            throw new BizException(ErrorType.PARAMM_NULL, "没有要保存的会员卡信息");
        }
        List<SaveVipCardCustInfoBuyDetailReq> detailList = request.getDetailList();
        for (SaveVipCardCustInfoBuyDetailReq vipCardCustInfo : detailList) {
            if (vipCardCustInfo == null) {
                continue;
            }
            if (StringUtils.isEmpty(vipCardCustInfo.getPeronCustId())) {
                /**保存个人客户信息.*/
                String custId = vipCardInnerService.saveCustPerson(vipCardCustInfo.getPersonCustName(),
                    vipCardCustInfo.getUserPhone(), "");
                if (StringUtils.isEmpty(custId)) {
                    throw new BizException(ErrorType.PARAMM_NULL, "客户信息保存失败");
                }
                vipCardCustInfo.setPeronCustId(custId);
                /**保存车牌信息*/
                TdCCarEditRequest carEditRequest = new TdCCarEditRequest();
                carEditRequest.setOptType("00");
                carEditRequest.setSysCode("1001");
                carEditRequest.setCustId(custId);
                carEditRequest.setCarNumber(vipCardCustInfo.getCarNumber());
                /**保存车牌信息.*/
                int count = vipCardInnerService.insertCar(carEditRequest);
                logger.info("保存车牌信息插入条数,结果={}条.", count);
                if (count == 0) {
                    logger.info("保存车牌信息失败");
                    throw new BizException(ErrorType.BIZ_ERROR, "保存车牌信息失败!");
                }
            }
            //计算金额
            Long totalAmount = vipCardCustInfo.getNum() * request.getPrice();
            Double discValue = StringUtils.isEmpty(request.getDiscValue()) ? 0L : (Double.valueOf(
                request.getDiscValue()) / 10);
            Long actFeeAmount = new BigDecimal(totalAmount).multiply(new BigDecimal(discValue)).longValue();
            vipCardCustInfo.setTotalAmount(totalAmount);
            System.out.println(discValue.doubleValue());
            if (StringUtils.isEmpty(request.getDiscValue()) || "0".equals(request.getDiscValue()) || "0.0".equals(
                request.getDiscValue())) {
                vipCardCustInfo.setActFee(totalAmount);
                vipCardCustInfo.setDiscountAmount(0L);
            } else {
                vipCardCustInfo.setActFee(actFeeAmount);
                vipCardCustInfo.setDiscountAmount(totalAmount - actFeeAmount);
            }
            //计算结束时间
            vipCardCustInfo.setExpDate(
                this.getExpDate(vipCardCustInfo.getEffDate(), request.getCardType(), vipCardCustInfo.getNum()));
        }
        /***************************************************保存信息
		 * *************************************************************/
        for (SaveVipCardCustInfoBuyDetailReq vipCardCustInfoDetail : detailList) {
            if (vipCardCustInfoDetail == null) {
                continue;
            }
            vipCardCustInfoDetail.setCustCardNo("");
            /**保存个人购买记录.*/
            this.saveVipCardCustInfo(request, vipCardCustInfoDetail, 1);
            /**保存会员卡订单信息.*/
            insertCount = this.insertVipCardOrder(request, vipCardCustInfoDetail,
                PayOrderTypeEnum.VIP_CARD_ADDED.value());
            if (insertCount == 0) {
                throw new BizException(ErrorType.PARAMM_NULL, "插入会员卡订单失败..");
            }
        }
        return new BizResult<Boolean>(insertCount > 0 ? true : false);
    }

    /**
     * 批量购买
     *
     * @param request
     * @return
     * @throws Exception
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BizResult<Boolean> batchSaveVipCardBuy(BatchVipBuyReq request) {
        int insertCount = 0;
        List<BatchVipCardBuyDetailReq> detailList = request.getDetailList();
        if (CollectionUtils.isNotEmpty(detailList)) {
            for (BatchVipCardBuyDetailReq vipCardCustInfoDetail : detailList) {
                QueryVipCardByCardNoRequest vipCardReq = new QueryVipCardByCardNoRequest();
                vipCardReq.setCardNo(vipCardCustInfoDetail.getCardNo());

                TVipCard tVipCard = vipCardDao.queryVipCardByCardNo(vipCardReq);
                if (null == tVipCard || StringUtils.isEmpty(tVipCard.getCardNo())) {
                    throw new BizException(ErrorType.PARAMM_NULL, vipCardCustInfoDetail.getCardNo() + "卡规则编码不存在!");
                }
                TVipCardCustInfo vipCardCustInfo = new TVipCardCustInfo();
                String nextId = SequenceUtil.getNextId(SequenceTypeEnum.PERSON_CUST_CARD_NO_SQE);
                //个人会员卡编码
                vipCardCustInfo.setCustCardNo(nextId);
                //客户id
                vipCardCustInfo.setCustId("");
                //卡编码
                vipCardCustInfo.setCardNo(tVipCard.getCardNo());
                //绑定的车牌号
                vipCardCustInfo.setCarNumber(vipCardCustInfoDetail.getCarNumber());
                //是否支持续费1：是，0否
                vipCardCustInfo.setIsSupportRenew(1);
                //购卡来源: 1:App购买 2:公众号购买 3:线下购买
                vipCardCustInfo.setCardRes(Integer.valueOf(VIPCardEnum.CARD_RES_3.getValue()));
                //车辆类型 1:大型车 2:小型车
                vipCardCustInfo.setCarType(2);
                //卡单价:分
                vipCardCustInfo.setPrice(tVipCard.getPrice());
                //购买时的数量
                vipCardCustInfo.setNum(1);
                //生效效时间
                if (vipCardCustInfoDetail.getEffDate() != null && vipCardCustInfoDetail.getEffDate().length() > 10) {
                    vipCardCustInfo.setEffDate(DateUtil.beginOfDay(
                        DateUtil.parse(vipCardCustInfoDetail.getEffDate(), DateUtil.NORM_DATETIME_PATTERN)));
                } else {
                    vipCardCustInfo.setEffDate(DateUtil
                        .parse((vipCardCustInfoDetail.getEffDate() + " 00:00:00"), DateUtil.NORM_DATETIME_PATTERN));
                }
                //购买时的总金额 = 单价 * 数量
                vipCardCustInfo.setTotalAmount(vipCardCustInfoDetail.getActFee());
                //购买时优惠金额
                vipCardCustInfo.setDiscountAmount(0L);
                //失效时间
                vipCardCustInfo.setExpDate(DateUtil
                    .endOfDay(DateUtil.parse(vipCardCustInfoDetail.getExpDate(), DateUtil.NORM_DATETIME_PATTERN)));
                //备注
                vipCardCustInfo.setRemark("线下批量购买会员卡");
                //审核状态1:待审核 2: 审核不通过 3:审核通过
                vipCardCustInfo.setCheckStatus(3);
                //数据状态 1:生效 0:失效
                vipCardCustInfo.setDataState(1);
                //创建人
                vipCardCustInfo.setCreateEmpid(request.getCreateEmpid());
                //创建人名称
                vipCardCustInfo.setCreateName(request.getCreateName());
                //创建时间
                if (StringUtils.isEmpty(vipCardCustInfoDetail.getCreateDate())) {
                    vipCardCustInfo.setCreateDate(new Date());
                } else {
                    vipCardCustInfo.setCreateDate(
                        DateUtil.parse(vipCardCustInfoDetail.getCreateDate(), DateUtil.NORM_DATETIME_PATTERN));
                }
                vipCardCustInfo.setCustName(vipCardCustInfoDetail.getPersonCustName());
                vipCardCustInfo.setCustPhone(vipCardCustInfoDetail.getUserPhone());

                insertCount += vipCardCustInfoDao.saveVipCardCustInfo(vipCardCustInfo);
                logger.info("保存个人购买会员卡信息,结果=【{}】条.", insertCount);

                TVipCardParkSaleRel tVipCardParkSaleRel = new TVipCardParkSaleRel();
                tVipCardParkSaleRel.setCardNo(tVipCard.getCardNo());
                List<TVipCardParkSaleRel> list = vipCardParkSaleRelDao.queryVipCardParkSaleRelForListByCardNo(
                    tVipCardParkSaleRel);
                if (CollectionUtils.isEmpty(list)) {
                    throw new BizException(ErrorType.BIZ_ERROR, "卡规则售卖车场不存在!");
                }
                /**保存会员卡售卖信息.*/
                TVipCardParkCustRel vipCardParkCustRel = new TVipCardParkCustRel();
                vipCardParkCustRel.setCustId("");
                vipCardParkCustRel.setCustCardNo(nextId);
                vipCardParkCustRel.setPlNo(list.get(0).getPlNo());
                vipCardParkCustRel.setCarNumber(vipCardCustInfoDetail.getCarNumber());
                vipCardParkCustRel.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
                vipCardParkCustRel.setCreateEmpid(request.getCreateEmpid());
                vipCardParkCustRel.setCreateName(request.getCreateName());
                if (StringUtils.isEmpty(vipCardCustInfoDetail.getCreateDate())) {
                    vipCardParkCustRel.setCreateDate(new Date());
                } else {
                    vipCardParkCustRel.setCreateDate(
                        DateUtil.parse(vipCardCustInfoDetail.getCreateDate(), DateUtil.NORM_DATETIME_PATTERN));
                }
                //查询停车场信息，如果为路侧默认推送成功
                int plType = this.getParkLogPlTypeByPlNo(list.get(0).getPlNo());
                if (plType == 1) {
                    //推送状态 1:已推送 0:未推送
                    vipCardParkCustRel.setPushState(1);
                } else {
                    //推送状态 1:已推送 0:未推送
                    vipCardParkCustRel.setPushState(0);
                }
                //个人会员卡购买类型：1:购卡  2:续费
                vipCardParkCustRel.setCardBuyType(1);
                insertCount += vipCardParkCustRelDao.saveVipCardParkCustRel(vipCardParkCustRel);
                logger.info("保存个人购买会员卡适应停车场信息,结果=【{}】条.", insertCount);
                batchVipCardOrder(vipCardCustInfo.getCustCardNo(), request, vipCardCustInfoDetail,
                    list.get(0).getPlNo(), tVipCard);
                logger.info("end获取个人用户购卡信息");
            }

        }
        return new BizResult<Boolean>(insertCount > 0);
    }

    /**
     * 保存会员卡订单信息-新表会员卡订单.<br/>
     * 步骤:1.保存会员卡订单信息
     * 2.保存会员卡订单明细
     * 3.保存支付单
     *
     * @return
     * @throws Exception
     * @Date 2018-02-28
     */
    private int batchVipCardOrder(String custCardNo, BatchVipBuyReq req, BatchVipCardBuyDetailReq vipCardCustInfoDetail,
        String plNo, TVipCard tVipCard) {
        logger.info("---begin保存会员卡订单信息");
        SaveVipCardOrderAndDetailAndPayOrderReq request = new SaveVipCardOrderAndDetailAndPayOrderReq();
        int flg = 0;
        Date createDate = new Date();
        if (StringUtils.isEmpty(vipCardCustInfoDetail.getCreateDate())) {
            createDate = new Date();
        } else {
            createDate = DateUtil.parse(vipCardCustInfoDetail.getCreateDate(), DateUtil.NORM_DATETIME_PATTERN);
        }

        OrderVipcardDTO order = new OrderVipcardDTO();

        /********1.构建订单对象*****/
        String orderId = SequenceUtil.getNextId(SequenceTypeEnum.ORDER_CARD_BUY);
        // 订单id
        order.setOrderId(orderId);
        //订单类型:301：会员卡购买单，302：会员卡续费
        order.setOrderType(301);
        //订单状态[字典表:ORDER_STATE]: 10:待核算、20：待支付、30:支付中,40：已支付、50：已完成
        order.setOrderState(OrderStateEnum.COMPLETED.value());

        order.setTerminalSource(TerminalSourceEnum.CloudsPlatform.value());
        //优惠金额 单位:分
        order.setOrderDicountFee(0L);
        //订单实收金额 单位:分
        order.setOrderActFee(vipCardCustInfoDetail.getActFee() == null ? 0L : vipCardCustInfoDetail.getActFee());
        //订单应收金额 单位:分
        order.setOrderTotalFee(vipCardCustInfoDetail.getActFee() == null ? 0L : vipCardCustInfoDetail.getActFee());
        //数据状态
        order.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
        //创建时间
        order.setCreateDate(createDate);
        //创建人ID
        order.setCreateEmpId(req.getCreateEmpid() == null ? req.getModifyEmpid() + "" : req.getCreateEmpid() + "");
        //创建人
        order.setCreateEmpName(StringUtils.isEmpty(req.getCreateName()) ? req.getModifyName() : req.getCreateName());
        //描述
        order.setRemark("平台购买");
        request.setOrderVipcardDTO(order);

        /********2.构建会员卡订单明细*****/
        List<OrderVipcardDetailDTO> orderVipcardDetailDTOList = new ArrayList<>();
        //西城需要拆分
        if (Long.valueOf("10007").equals(req.getOrgId()) || Long.valueOf("10003").equals(req.getOrgId())) {
            //生效效时间
            Date beginTime = null;
            Date endTime = null;
            if (vipCardCustInfoDetail.getEffDate() != null && vipCardCustInfoDetail.getEffDate().length() > 10) {
                beginTime = DateUtil.beginOfDay(
                    DateUtil.parse(vipCardCustInfoDetail.getEffDate(), DateUtil.NORM_DATETIME_PATTERN));
            } else {
                beginTime = DateUtil.parse((vipCardCustInfoDetail.getEffDate() + " 00:00:00"),
                    DateUtil.NORM_DATETIME_PATTERN);
            }
            endTime = DateUtil.endOfDay(
                DateUtil.parse(vipCardCustInfoDetail.getExpDate(), DateUtil.NORM_DATETIME_PATTERN));
            int monthNum = getMonth(beginTime, endTime);
            if (monthNum == 0) {
                monthNum = 1;
            }

            Long actTotalFee = vipCardCustInfoDetail.getActFee() == null ? 0L : vipCardCustInfoDetail.getActFee();
            //计算拆分费用
            Long actFee = BigDecimal.valueOf(actTotalFee).divide(new BigDecimal(monthNum), 2, BigDecimal.ROUND_HALF_UP)
                .longValue();

            for (int i = 0; i < monthNum; i++) {
                OrderVipcardDetailDTO detailCardDTO = new OrderVipcardDetailDTO();
                String detailOrderId = SequenceUtil.getNextId(SequenceTypeEnum.ORDER_CARD_BUY_FLOW);
                //会员卡主表ID
                detailCardDTO.setOrderId(orderId);
                //订单明细id
                detailCardDTO.setDetailOrderId(detailOrderId);
                //停车场卡券id 对应t_vip_card
                detailCardDTO.setVipCardNo(tVipCard.getCardNo());
                //订单类型:301：会员卡购买单，302：会员卡续费
                detailCardDTO.setOrderType(301);
                //个人卡券关联编码
                detailCardDTO.setPersonCardNo(custCardNo);
                //1-大型车；2-小型车
                detailCardDTO.setCarType(tVipCard.getCarType());
                //卡类型 1-年卡；2-半年卡；3-季卡；4-月卡；5-日卡；
                //西城都是月卡
                detailCardDTO.setCardType(tVipCard.getCardType());
                detailCardDTO.setTerminalSource(TerminalSourceEnum.CloudsPlatform.value());
                //卡金额（单价）
                detailCardDTO.setPrice(tVipCard.getPrice() != null ? tVipCard.getPrice() : 0L);
                //购买数量
                detailCardDTO.setBuyNum(1);
                //购买时优惠后金额
                detailCardDTO.setOrderDicountFee(0L);
                //购买时实收金额=优惠后金额
                detailCardDTO.setCardActAmount(actFee);
                //使用类型:1-单体卡；2-共享卡
                detailCardDTO.setUseType(1);
                //停车场编号
                detailCardDTO.setPlNo(plNo);
                //个人客户id
                detailCardDTO.setPersonCustId("");
                //车牌号
                detailCardDTO.setCarNumber(vipCardCustInfoDetail.getCarNumber());

                //生效时间
                detailCardDTO.setEffDate(beginTime);
                //失效效时间
                detailCardDTO.setExpDate(endTime);

                //数据状态
                detailCardDTO.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());

                //创建人ID
                detailCardDTO.setCreateEmpId(req.getCreateEmpid() + "");
                //创建人
                detailCardDTO.setCreateName(req.getCreateName());
                if (i == 0) {
                    //创建时间
                    detailCardDTO.setCreateDate(beginTime);
                } else {
                    detailCardDTO.setCreateDate(DateUtil.beginOfMonth(DateUtil.offsetMonth(beginTime, i)));
                }
                orderVipcardDetailDTOList.add(detailCardDTO);
            }//for

        } else {
            OrderVipcardDetailDTO detailCardDTO = new OrderVipcardDetailDTO();
            String detailOrderId = SequenceUtil.getNextId(SequenceTypeEnum.ORDER_CARD_BUY_FLOW);
            //会员卡主表ID
            detailCardDTO.setOrderId(orderId);
            //订单明细id
            detailCardDTO.setDetailOrderId(detailOrderId);
            //停车场卡券id 对应t_vip_card
            detailCardDTO.setVipCardNo(tVipCard.getCardNo());
            //订单类型:301：会员卡购买单，302：会员卡续费
            detailCardDTO.setOrderType(301);
            //个人卡券关联编码
            detailCardDTO.setPersonCardNo(custCardNo);
            //1-大型车；2-小型车
            detailCardDTO.setCarType(tVipCard.getCarType());
            //卡类型 1-年卡；2-半年卡；3-季卡；4-月卡；5-日卡；
            //西城都是月卡
            detailCardDTO.setCardType(tVipCard.getCardType());
            detailCardDTO.setTerminalSource(TerminalSourceEnum.CloudsPlatform.value());
            //卡金额（单价）
            detailCardDTO.setPrice(tVipCard.getPrice() != null ? tVipCard.getPrice() : 0L);
            //购买数量
            detailCardDTO.setBuyNum(1);
            //购买时优惠后金额
            detailCardDTO.setOrderDicountFee(0L);
            //购买时实收金额=优惠后金额
            detailCardDTO.setCardActAmount(
                vipCardCustInfoDetail.getActFee() == null ? 0L : vipCardCustInfoDetail.getActFee());
            //使用类型:1-单体卡；2-共享卡
            detailCardDTO.setUseType(1);
            //停车场编号
            detailCardDTO.setPlNo(plNo);
            //个人客户id
            detailCardDTO.setPersonCustId("");
            //车牌号
            detailCardDTO.setCarNumber(vipCardCustInfoDetail.getCarNumber());

            //生效时间
            detailCardDTO.setEffDate(
                DateUtil.parse(vipCardCustInfoDetail.getEffDate(), DateUtil.NORM_DATETIME_PATTERN));
            //失效效时间
            detailCardDTO.setExpDate(
                DateUtil.parse(vipCardCustInfoDetail.getExpDate(), DateUtil.NORM_DATETIME_PATTERN));

            //数据状态
            detailCardDTO.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());

            //创建人ID
            detailCardDTO.setCreateEmpId(req.getCreateEmpid() + "");
            //创建人
            detailCardDTO.setCreateName(req.getCreateName());
            detailCardDTO.setCreateDate(createDate);
            orderVipcardDetailDTOList.add(detailCardDTO);
        }
        request.setOrderVipcardDetailDTOList(orderVipcardDetailDTOList);

        /***3.构建支付单信息.*/
        PayOrderDTO payOrder = new PayOrderDTO();
        String payOrderId = SequenceUtil.getNextId(SequenceTypeEnum.ORDER_PAY_FLOW_XIANJIN);
        //支付单id
        payOrder.setPayOrderId(payOrderId);
        //关联的订单大类型[字典表:ORDER_BIG_TYPE]：100：停车订单 200：充值订单 300:会员卡订单
        payOrder.setOrderBigType(300);
        //支付单类型[字典表:PAY_ORDER_TYPE]:101:停车付款单,102：停车预付单，103:停车补缴单；201：余额充值单,202：押金充值；301：会员卡购买单，302：会员卡续费
        payOrder.setPayOrderType(301);
        // 关联订单id
        payOrder.setRltOrderId(orderId);
        //支付方式-- 1:支付宝 2：微信 3：银联. 6 现金 */
        payOrder.setPayType(null == vipCardCustInfoDetail.getPayType() ? 33 : vipCardCustInfoDetail.getPayType());
        //终端来源[字典表:TERMINAL_SOURCE]：1:任你听 2：pda 3：微信公共号 4:云平台
        payOrder.setTerminalSource(TerminalSourceEnum.CloudsPlatform.value());
        //优惠金额 单位:分
        payOrder.setOrderDicountFee(0L);
        //订单实收金额 单位:分
        payOrder.setOrderActFee(vipCardCustInfoDetail.getActFee() == null ? 0 : vipCardCustInfoDetail.getActFee());
        //订单应收金额 单位:分
        payOrder.setOrderTotalFee(vipCardCustInfoDetail.getActFee() == null ? 0 : vipCardCustInfoDetail.getActFee());
        //订单状态[字典表:ORDER_STATE]: 10:待核算、20：待支付、30:支付中,40：已支付、50：已完成
        payOrder.setPayOrderState(OrderStateEnum.PAYED.value());
        //停车场编码
        payOrder.setPlNo(plNo);
        //支付完成时间
        payOrder.setPayFinishTime(createDate);
        //创建人ID
        payOrder.setCreateEmpId(req.getCreateEmpid() == null ? req.getModifyEmpid() + "" : req.getCreateEmpid() + "");
        //创建人
        payOrder.setCreateEmpName(StringUtils.isEmpty(req.getCreateName()) ? req.getModifyName() : req.getCreateName());
        //创建时间
        payOrder.setCreateDate(new Date());
        //设置appid :微信、支付宝、公众号对应appid
        payOrder.setAppId("no_app_id");
        //数据状态
        payOrder.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
        request.setPayOrderDTO(payOrder);
        request.setSysCode("101");
        try {
            BizResult<Boolean> result = vipCardOrderOperService.saveVipCardOrderAndDetailAndPayOrder(request);
        } catch (Exception e) {

            e.printStackTrace();
            throw new BizException(ErrorType.BIZ_ERROR, "保存支付单信息失败!");
        }

        logger.info("---end保存会员卡订单信息");
        return flg;
    }

    /**
     * cardType
     *
     * @param start
     * @param end
     * @return
     */
    public static int getMonth(Date start, Date end) {
        if (start.after(end)) {
            Date t = start;
            start = end;
            end = t;
        }
        Calendar startCalendar = Calendar.getInstance();
        startCalendar.setTime(start);
        Calendar endCalendar = Calendar.getInstance();
        endCalendar.setTime(end);
        Calendar temp = Calendar.getInstance();
        temp.setTime(end);
        temp.add(Calendar.DATE, 1);

        int year = endCalendar.get(Calendar.YEAR)
            - startCalendar.get(Calendar.YEAR);
        int month = endCalendar.get(Calendar.MONTH)
            - startCalendar.get(Calendar.MONTH);

        if ((startCalendar.get(Calendar.DATE) == 1)
            && (temp.get(Calendar.DATE) == 1)) {
            return year * 12 + month + 1;
        } else if ((startCalendar.get(Calendar.DATE) != 1)
            && (temp.get(Calendar.DATE) == 1)) {
            return year * 12 + month;
        } else if ((startCalendar.get(Calendar.DATE) == 1)
            && (temp.get(Calendar.DATE) != 1)) {
            return year * 12 + month;
        } else {
            return (year * 12 + month - 1) < 0 ? 0 : (year * 12 + month);
        }
    }

    public static void main(String[] args) throws ParseException {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        Date start = df.parse("2015-01-04 00:00:00");
        Date end = df.parse("2015-01-16 23:59:59");
        System.out.println("###start:==" + start);
        System.out.println("###end:==" + end);

        getMonth(start, end);
        System.out.println("###getMonth():=" + getMonth(start, end));
    }

    /**
     * 通过主键修改个人会员卡信息(续费)
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BizResult<Boolean> updateVipCardCustInfoById(SaveVipCardCustInfoBuyReq request) throws Exception {
        int count = 0;
        logger.info("---begin续费会员卡记录,入参={}", JSONObject.toJSON(request));
        if (null == request) {
            logger.info("入参为空");
            throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
        }

        List<SaveVipCardCustInfoBuyDetailReq> detailList = request.getDetailList();
        for (SaveVipCardCustInfoBuyDetailReq vipCardCustInfoDetail : detailList) {

            if (vipCardCustInfoDetail == null || vipCardCustInfoDetail.getId() == null) {
                continue;
            }
            //计算续费金额
            Long totalAmount = vipCardCustInfoDetail.getNum() * request.getPrice();
            Double discValue = StringUtils.isEmpty(request.getDiscValue()) ? 0L : (Double.valueOf(
                request.getDiscValue()) / 10);
            Long actFeeAmount = new BigDecimal(totalAmount).multiply(new BigDecimal(discValue)).longValue();
            if (StringUtils.isEmpty(request.getDiscValue()) || "0".equals(request.getDiscValue()) || "0.0".equals(
                request.getDiscValue())) {
                vipCardCustInfoDetail.setActFee(totalAmount);
                vipCardCustInfoDetail.setDiscountAmount(0L);
            } else {
                vipCardCustInfoDetail.setActFee(actFeeAmount);
                vipCardCustInfoDetail.setDiscountAmount(totalAmount - actFeeAmount);
            }
            vipCardCustInfoDetail.setTotalAmount(totalAmount);
            QueryVipCardCustInfoByCustIdRequest request1 = new QueryVipCardCustInfoByCustIdRequest();
            request1.setCustId(vipCardCustInfoDetail.getPeronCustId());
            request1.setSysCode("1001");
            request1.setId(vipCardCustInfoDetail.getId());
            /**1、根据客户id查询个人购买会员卡记录 */
            List<TVipCardCustInfo> list = vipCardCustInfoDao.queryVipCardCustInfoByCustId(request1);
            if (CollectionUtils.isEmpty(list)) {
                throw new BizException(ErrorType.PARAMM_NULL, "续费个人会员卡信息查询失败!");
            }
            TVipCardCustInfo tVipCardCustInfo = list.get(0);
            //续费前的结束时间
            //Date preExpDate = tVipCardCustInfo.getExpDate();
            Date currentExpDate = DateUtil.offset(tVipCardCustInfo.getExpDate(), DateField.DAY_OF_MONTH, 1);
            logger.info("结束日期增加一天,结果为={}", currentExpDate);
            String expDate = this.getExpDate(DateUtil.format(currentExpDate, DateUtil.NORM_DATETIME_PATTERN),
                request.getCardType(),
                (vipCardCustInfoDetail.getNum()));
            logger.info("根据结束日期计算最新的续费日期为={}", expDate);
            tVipCardCustInfo.setExpDate(DateUtil.parse(expDate, DateUtil.NORM_DATETIME_PATTERN));
            //续费后的数量
            tVipCardCustInfo.setNum(tVipCardCustInfo.getNum() + vipCardCustInfoDetail.getNum());
            //续费后的优惠金额
            tVipCardCustInfo.setDiscountAmount(
                tVipCardCustInfo.getDiscountAmount() + (totalAmount - vipCardCustInfoDetail.getActFee()));
            //续费后的总金额
            tVipCardCustInfo.setTotalAmount(tVipCardCustInfo.getTotalAmount() + totalAmount);
            //计算结束时间
            vipCardCustInfoDetail.setExpDate(expDate);
            tVipCardCustInfo.setCreateDate(new Date());
            /**2.通过主键修改个人会员卡信息.*/
            count = vipCardCustInfoDao.updateVipCardCustInfoById(tVipCardCustInfo);
            if (count == 0) {
                throw new BizException(ErrorType.PARAMM_NULL, "续费更新个人会员卡信息查询失败!");
            }
            vipCardCustInfoDetail.setEffDate(
                DateUtil.format(DateUtil.beginOfDay(currentExpDate), DateUtil.NORM_DATETIME_PATTERN));
            vipCardCustInfoDetail.setExpDate(expDate);
            vipCardCustInfoDetail.setCarNumber(tVipCardCustInfo.getCarNumber());
            vipCardCustInfoDetail.setCustCardNo(tVipCardCustInfo.getCustCardNo());

            /**保存会员卡订单信息.*/
            count = this.insertVipCardOrder(request, vipCardCustInfoDetail, PayOrderTypeEnum.VIP_CARD_RENEW.value());
            if (count == 0) {
                throw new BizException(ErrorType.PARAMM_NULL, "续费订单信息失败!");
            }
            int plType = getParkLogPlTypeByPlNo(request.getPlNo());
            /**3.更新个人会员卡停车场关系表*/
            TVipCardParkCustRel vipCardParkCustRel = new TVipCardParkCustRel();
            if (plType == 1) {//路侧
                vipCardParkCustRel.setPushState(1);
            } else {
                vipCardParkCustRel.setPushState(0);
            }

            //个人会员卡购买类型：1:购卡  2:续费 由于状态2有时候出问题，统一改成1
            vipCardParkCustRel.setCardBuyType(2);
            vipCardParkCustRel.setCustCardNo(tVipCardCustInfo.getCustCardNo());
            count = vipCardParkCustRelDao.updateVipCardParkCustRelByCustCardId(vipCardParkCustRel);
            if (count == 0) {
                throw new BizException(ErrorType.PARAMM_NULL, "续费更新个人会员卡停车场关系表失败!");
            }
            logger.info("---end续费会员卡记录,入参={}", JSONObject.toJSON(request));

        }

        return new BizResult<Boolean>(count > 0 ? true : false);
    }

    @Override
    public BizResult<Boolean> updateVipCardCustInfoByCustCardNo(UpdateVipCardCustInfoRequest request) throws Exception {
        int count = 0;
        TVipCardCustInfo tVipCardCustInfo=new TVipCardCustInfo();
        tVipCardCustInfo.setPrice(request.getPrice());
        tVipCardCustInfo.setEffDate(request.getEffDate());
        tVipCardCustInfo.setExpDate(request.getExpDate());
        tVipCardCustInfo.setModifyEmpid(request.getCreateEmpid());
        tVipCardCustInfo.setCustCardNo(request.getCustCardNo());
        count = vipCardCustInfoDao.updateVipCardCustInfoByCustCardNo(tVipCardCustInfo);
        return new BizResult<Boolean>(count > 0 ? true : false);
    }

    /**
     * 更换会员卡车牌.<br/>
     * 步骤：
     * 1.
     *
     * @param request
     * @return
     * @throws Exception
     *     wangfs
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BizResult<Boolean> changeVipCardCustInfoCarNumberById(SaveVipCardCustInfoBuyReq request) throws Exception {
        logger.info("---begin更换会员卡记录,入参={}", JSONObject.toJSON(request));
        int count = 0;
        if (null == request) {
            logger.info("入参为空");
            throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
        }
        List<SaveVipCardCustInfoBuyDetailReq> detailList = request.getDetailList();
        if (CollectionUtils.isEmpty(detailList)) {
            throw new BizException(ErrorType.PARAMM_NULL, "更换车牌失败!传入明细list为空");
        }
        /**1、根据客户id查询个人购买会员卡记录.*/
        SaveVipCardCustInfoBuyDetailReq vipCardCustInfoDetail = detailList.get(0);
        QueryVipCardCustInfoByCustIdRequest request1 = new QueryVipCardCustInfoByCustIdRequest();
        request1.setCustId(vipCardCustInfoDetail.getPeronCustId());
        request1.setSysCode("1001");
        request1.setId(vipCardCustInfoDetail.getId());
        List<TVipCardCustInfo> list = vipCardCustInfoDao.queryVipCardCustInfoByCustId(request1);
        if (CollectionUtils.isEmpty(detailList)) {
            throw new BizException(ErrorType.PARAMM_NULL, "更换车牌失败!查询明细list为空");
        }
        /**2.将改会员卡更改为失效.*/
        TVipCardCustInfo tVipCardCustInfo = list.get(0);
        TVipCardCustInfo updateVipCardCustInfo = new TVipCardCustInfo();
        updateVipCardCustInfo.setCustCardNo(tVipCardCustInfo.getCustCardNo());
        updateVipCardCustInfo.setExpDate(DateUtil.yesterday());
        updateVipCardCustInfo.setModifyEmpid(request.getModifyEmpid());
        updateVipCardCustInfo.setModifyName(request.getModifyName());
        updateVipCardCustInfo.setDataState(1);//失效状
        /**2.更新个人会员卡信息.*/
        count = vipCardCustInfoDao.updateVipCardCustInfoByCustCardNo(updateVipCardCustInfo);

        TVipCardParkCustRel vipCardParkCustRel = new TVipCardParkCustRel();
        int plType = getParkLogPlTypeByPlNo(request.getPlNo());
        if (plType == 1) {
            vipCardParkCustRel.setPushState(1);
        } else {
            vipCardParkCustRel.setPushState(0);
        }

        //个人会员卡购买类型：1:购卡  2:续费
        vipCardParkCustRel.setCardBuyType(1);
        vipCardParkCustRel.setCustCardNo(tVipCardCustInfo.getCustCardNo());
        /**3.更新个人购买会员卡记录为未推送.*/
        count = vipCardParkCustRelDao.updateVipCardParkCustRelByCustCardId(vipCardParkCustRel);

        vipCardCustInfoDetail.setTotalAmount(0L);
        vipCardCustInfoDetail.setParentCustCardNo(tVipCardCustInfo.getCustCardNo());
        vipCardCustInfoDetail.setDiscountAmount(0L);
        vipCardCustInfoDetail.setEffDate(
            DateUtil.format(tVipCardCustInfo.getEffDate(), DateUtil.NORM_DATETIME_PATTERN));
        vipCardCustInfoDetail.setExpDate(
            DateUtil.format(tVipCardCustInfo.getExpDate(), DateUtil.NORM_DATETIME_PATTERN));
        vipCardCustInfoDetail.setNum(tVipCardCustInfo.getNum());
        vipCardCustInfoDetail.setPeronCustId(tVipCardCustInfo.getCustId());
        vipCardCustInfoDetail.setActFee(0L);
        /**4.重新生成个人购买记录(金额为0).*/
        count = this.saveVipCardCustInfo(request, vipCardCustInfoDetail, 1);
        if (count == 0) {
            throw new BizException(ErrorType.PARAMM_NULL, "更换车牌失败，重新生成个人购买记录失败");
        }

        /**5保存会员卡订单信息.*/
        count = this.insertVipCardOrder(request, vipCardCustInfoDetail,
            PayOrderTypeEnum.VIP_CARD_CHANGE_CARNUM.value());

        return new BizResult<Boolean>(count > 0 ? true : false);
    }

    /**
     * 删除会员卡信息.<br/>
     * 说明:本功能会将会员卡失效时间更改成昨天，然后推送道闸也至失效.<br/>
     *
     * @param request
     * @return
     * @throws Exception
     *     wangfs
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BizResult<Boolean> deleteVipCardCustInfoById(SaveVipCardCustInfoBuyReq request) throws Exception {
        logger.info("---begin更换会员卡记录,入参={}", JSONObject.toJSON(request));
        int count = 0;
        if (null == request || CollectionUtils.isEmpty(request.getDetailList())) {
            logger.info("入参为空");
            throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
        }
        List<SaveVipCardCustInfoBuyDetailReq> detailList = request.getDetailList();
        for (SaveVipCardCustInfoBuyDetailReq tVipCardCustInfo : detailList) {
            if (tVipCardCustInfo == null || tVipCardCustInfo.getCustCardNo() == null) {
                continue;
            }
            TVipCardCustInfo queryCardCustInfoBycustCardNo = vipCardCustInfoDao.queryCardCustInfoBycustCardNo(tVipCardCustInfo.getCustCardNo());
            /**2.将改会员卡更改为失效.*/
            TVipCardCustInfo updateVipCardCustInfo = new TVipCardCustInfo();
            updateVipCardCustInfo.setCustCardNo(tVipCardCustInfo.getCustCardNo());
            updateVipCardCustInfo.setExpDate(DateUtil.yesterday());
            updateVipCardCustInfo.setModifyEmpid(request.getModifyEmpid());
            updateVipCardCustInfo.setModifyName(request.getModifyName());
            /**2.更新个人会员卡信息.*/
            count = vipCardCustInfoDao.updateVipCardCustInfoByCustCardNo(updateVipCardCustInfo);

            TVipCardParkCustRel vipCardParkCustRel = new TVipCardParkCustRel();
            long nowtime = System.currentTimeMillis();
            long effDatetime = queryCardCustInfoBycustCardNo.getEffDate().getTime();
            if(effDatetime > nowtime){
                //还未推送到本地车场的月卡如果失效 不再自动推送
                vipCardParkCustRel.setPushState(1);
            }else {
                vipCardParkCustRel.setPushState(0);
            }
            //个人会员卡购买类型：1:购卡  2:续费
            vipCardParkCustRel.setCardBuyType(1);
            vipCardParkCustRel.setCustCardNo(tVipCardCustInfo.getCustCardNo());
            /**3.更新个人购买会员卡记录为未推送.*/
            count = vipCardParkCustRelDao.updateVipCardParkCustRelByCustCardId(vipCardParkCustRel);
            /**
             * 4.删除会员卡明细订单
             */

            OrderVipcardAndDetailRequest req = new OrderVipcardAndDetailRequest();
            req.setSysCode("1001");
            req.setPersonCardNo(tVipCardCustInfo.getCustCardNo());
            logger.info("---begin删除会员卡明细,入参={}", JSONObject.toJSON(request));
            vipCardOrderOperService.deleteVipCardOrderAndDetailAndPayOrderByPersonCustCardNo(req);
        }
        return new BizResult<Boolean>(count > 0 ? true : false);
    }

    /**
     * 保存个人用户购买会员卡记录.<br/>
     *
     * @param req
     * @param vipCardCustInfoDetail
     * @param cardBuyType
     *     个人会员卡购买类型：1:购卡  2:续费
     * @return 2018年5月16日  wangfs.<br/>
     */
    @Transactional(rollbackFor = Exception.class)
    public Integer saveVipCardCustInfo(SaveVipCardCustInfoBuyReq req,
        SaveVipCardCustInfoBuyDetailReq vipCardCustInfoDetail, Integer cardBuyType) {
        logger.info("begin获取个人用户购卡信息");
        Integer insertCount = 0;
        if (null == req) {
            throw new BizException(ErrorType.PARAMM_NULL, "请求对象为空");
        }

        TVipCardCustInfo vipCardCustInfo = new TVipCardCustInfo();

        String nextId = SequenceUtil.getNextId(SequenceTypeEnum.PERSON_CUST_CARD_NO_SQE);
        if (StringUtils.isNotEmpty(vipCardCustInfoDetail.getCustCardNo())) {
            //个人会员卡编码
            vipCardCustInfo.setCustCardNo(vipCardCustInfoDetail.getCustCardNo());
        } else {
            vipCardCustInfoDetail.setCustCardNo(nextId);
            //个人会员卡编码
            vipCardCustInfo.setCustCardNo(nextId);
        }

        //客户id
        vipCardCustInfo.setCustId(vipCardCustInfoDetail.getPeronCustId());
        //卡编码
        vipCardCustInfo.setCardNo(req.getCardNo());
        //绑定的车牌号
        vipCardCustInfo.setCarNumber(vipCardCustInfoDetail.getCarNumber());
        //是否支持续费1：是，0否
        vipCardCustInfo.setIsSupportRenew(1);
        //购卡来源: 1:App购买 2:公众号购买 3:线下购买
        vipCardCustInfo.setCardRes(
            req.getCardRes() != null ? req.getCardRes() : Integer.valueOf(VIPCardEnum.CARD_RES_3.getValue()));
        //车辆类型 1:大型车 2:小型车
        vipCardCustInfo.setCarType(req.getCarType());
        //卡单价:分
        vipCardCustInfo.setPrice(req.getPrice());
        //购买时的数量
        vipCardCustInfo.setNum(vipCardCustInfoDetail.getNum());
        //生效效时间
        if (vipCardCustInfoDetail.getEffDate() != null && vipCardCustInfoDetail.getEffDate().length() > 10) {
            vipCardCustInfo.setEffDate(
                DateUtil.parse(vipCardCustInfoDetail.getEffDate(), DateUtil.NORM_DATETIME_PATTERN));
        } else {
            vipCardCustInfo.setEffDate(
                DateUtil.parse((vipCardCustInfoDetail.getEffDate() + " 00:00:00"), DateUtil.NORM_DATETIME_PATTERN));
        }

        //购买时的总金额 = 单价 * 数量
        vipCardCustInfo.setTotalAmount(vipCardCustInfoDetail.getTotalAmount());

        //购买时优惠金额
        vipCardCustInfo.setDiscountAmount(vipCardCustInfoDetail.getDiscountAmount());
        //失效时间
        vipCardCustInfo.setExpDate(DateUtil.parse(vipCardCustInfoDetail.getExpDate(), DateUtil.NORM_DATETIME_PATTERN));
        //备注
        if (VIPCardEnum.CARD_RES_1.getValue().equals(req.getCardRes()) || VIPCardEnum.CARD_RES_2.getValue().equals(
            req.getCardRes())) {
            vipCardCustInfo.setRemark("线上会员卡变更车牌");
        } else {
            vipCardCustInfo.setRemark("线下批量购买会员卡");
        }
        //审核状态1:待审核 2: 审核不通过 3:审核通过
        vipCardCustInfo.setCheckStatus(3);
        //数据状态 1:生效 0:失效
        vipCardCustInfo.setDataState(1);
        //创建人
        vipCardCustInfo.setCreateEmpid(req.getCreateEmpid());
        //创建人名称
        vipCardCustInfo.setCreateName(req.getCreateName());
        //创建时间
        vipCardCustInfo.setCreateDate(new Date());
        if (StringUtils.isNotEmpty(vipCardCustInfoDetail.getParentCustCardNo())) {
            //父级个人会员卡编码
            vipCardCustInfo.setParentCustCardNo(vipCardCustInfoDetail.getParentCustCardNo());
        }

        insertCount = vipCardCustInfoDao.saveVipCardCustInfo(vipCardCustInfo);
        logger.info("保存个人购买会员卡信息,结果=【{}】条.", insertCount);
        if (insertCount == 0) {
            throw new BizException(ErrorType.BIZ_ERROR, "保存个人购买会员卡信息异常!");
        }
        /**保存会员卡售卖信息.*/
        TVipCardParkCustRel vipCardParkCustRel = new TVipCardParkCustRel();
        vipCardParkCustRel.setCustId(vipCardCustInfoDetail.getPeronCustId());
        vipCardParkCustRel.setCustCardNo(vipCardCustInfoDetail.getCustCardNo());
        vipCardParkCustRel.setPlNo(req.getPlNo()); //停车场编码
        vipCardParkCustRel.setCarNumber(vipCardCustInfoDetail.getCarNumber());
        vipCardParkCustRel.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
        vipCardParkCustRel.setCreateEmpid(req.getCreateEmpid());
        vipCardParkCustRel.setCreateName(req.getCreateName());
        vipCardParkCustRel.setCreateDate(new Date());
        //查询停车场信息，如果为路侧默认推送成功
        int plType = this.getParkLogPlTypeByPlNo(req.getPlNo());
        if (plType == 1) {
            //推送状态 1:已推送 0:未推送
            vipCardParkCustRel.setPushState(1);
        } else {
            //推送状态 1:已推送 0:未推送
            vipCardParkCustRel.setPushState(0);
        }
        //个人会员卡购买类型：1:购卡  2:续费
        vipCardParkCustRel.setCardBuyType(cardBuyType);
        insertCount = vipCardParkCustRelDao.saveVipCardParkCustRel(vipCardParkCustRel);
        logger.info("保存个人购买会员卡适应停车场信息,结果=【{}】条.", insertCount);
        if (insertCount == 0) {
            throw new BizException(ErrorType.BIZ_ERROR, "保存个人购买会员卡适应停车场信息!");
        }
        logger.info("end获取个人用户购卡信息");

        return insertCount;
    }

    /**
     * 通过停车场编码获取停车场类型
     *
     * @param plNo
     * @return
     */
    private int getParkLogPlTypeByPlNo(String plNo) {
        int plType = 2;
        QueryParkLotInfoByPkNoRequest request = new QueryParkLotInfoByPkNoRequest();
        request.setPklNo(plNo);
        request.setSysCode("1001");
        BizResult<ParkingLotDTO> parkingLotDTOBizResult = parkingLotQueryService.QueryParkingLotByPkNo(request);
        if (null != parkingLotDTOBizResult && null != parkingLotDTOBizResult.getData()) {
            plType = parkingLotDTOBizResult.getData().getPlType();
        }

        return plType;
    }

    /**
     * 保存会员卡订单信息-新表会员卡订单.<br/>
     * 步骤:1.保存会员卡订单信息
     * 2.保存会员卡订单明细
     * 3.保存支付单
     *
     * @param orderDetailType
     *     订单类型:301：会员卡购买单，302：会员卡续费
     * @return
     * @throws Exception
     * @Date 2018-02-28
     */
    private int insertVipCardOrder(SaveVipCardCustInfoBuyReq req,
        SaveVipCardCustInfoBuyDetailReq vipCardCustInfoDetail, Integer orderDetailType) throws Exception {
        logger.info("---begin保存会员卡订单信息");
        SaveVipCardOrderAndDetailAndPayOrderReq request = new SaveVipCardOrderAndDetailAndPayOrderReq();
        int flg = 0;
        OrderVipcardDTO order = new OrderVipcardDTO();

        /********1.构建订单对象*****/
        String orderId = SequenceUtil.getNextId(SequenceTypeEnum.ORDER_CARD_BUY);
        // 订单id
        order.setOrderId(orderId);
        //订单类型:301：会员卡购买单，302：会员卡续费
        order.setOrderType(orderDetailType);
        //订单状态[字典表:ORDER_STATE]: 10:待核算、20：待支付、30:支付中,40：已支付、50：已完成
        order.setOrderState(OrderStateEnum.COMPLETED.value());
        //终端来源[字典表:TERMINAL_SOURCE]：1:任你听 2：pda 3：微信公共号 4:云平台
        //		if (VIPCardEnum.CARD_RES_1.getValue().equals(req.getCardRes()) ) {
        //			order.setTerminalSource(TerminalSourceEnum.RNT.value());
        //		} else if ( VIPCardEnum.CARD_RES_2.getValue().equals(req.getCardRes())) {
        //			order.setTerminalSource(TerminalSourceEnum.WxPublic.value());
        //		}else{
        //			order.setTerminalSource(TerminalSourceEnum.CloudsPlatform.value());
        //		}
        //
        order.setTerminalSource(TerminalSourceEnum.CloudsPlatform.value());
        //优惠金额 单位:分
        order.setOrderDicountFee(
            vipCardCustInfoDetail.getDiscountAmount() == null ? 0L : vipCardCustInfoDetail.getDiscountAmount());
        //订单实收金额 单位:分
        order.setOrderActFee(vipCardCustInfoDetail.getActFee() == null ? 0L : vipCardCustInfoDetail.getActFee());
        //订单应收金额 单位:分
        order.setOrderTotalFee(
            vipCardCustInfoDetail.getTotalAmount() == null ? 0L : vipCardCustInfoDetail.getTotalAmount());
        //数据状态
        order.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
        //创建时间
        order.setCreateDate(new Date());
        //创建人ID
        order.setCreateEmpId(req.getCreateEmpid() == null ? req.getModifyEmpid() + "" : req.getCreateEmpid() + "");
        //创建人
        order.setCreateEmpName(StringUtils.isEmpty(req.getCreateName()) ? req.getModifyName() : req.getCreateName());
        //描述
        order.setRemark("平台购买");

        request.setOrderVipcardDTO(order);

        /********2.构建会员卡订单明细*****/
        List<OrderVipcardDetailDTO> orderVipcardDetailDTOList = new ArrayList<>();

        //北京西城需要对金额进行拆分
        if (Long.valueOf("10007").equals(req.getOrgId()) && CollectionUtils.isEmpty(
            vipCardCustInfoDetail.getSpiltFee())) {
            throw new BizException(ErrorType.BIZ_ERROR, "拆分金额不能为空!");
        }

        if (CollectionUtils.isEmpty(vipCardCustInfoDetail.getSpiltFee())) {
            vipCardCustInfoDetail.setSpiltFee(Arrays.asList(vipCardCustInfoDetail.getActFee()));
        }

        //北京西城的需要根据数量在做叠加
        if (Long.valueOf("10007").equals(req.getOrgId())) {

            Integer num = vipCardCustInfoDetail.getNum();
            num = num == null ? 1 : num;
            List<Long> tmpList = Lists.newArrayList();

            for (int i = 0; i < num; i++) {
                tmpList.addAll(vipCardCustInfoDetail.getSpiltFee());
            }
            vipCardCustInfoDetail.setSpiltFee(tmpList);
        }

        for (int i = 0; i < vipCardCustInfoDetail.getSpiltFee().size(); i++) {
            Long spiltFee = vipCardCustInfoDetail.getSpiltFee().get(i);
            spiltFee = spiltFee != null ? spiltFee : 0L;
            OrderVipcardDetailDTO detailCardDTO = new OrderVipcardDetailDTO();
            String detailOrderId = SequenceUtil.getNextId(SequenceTypeEnum.ORDER_CARD_BUY_FLOW);
            //会员卡主表ID
            detailCardDTO.setOrderId(orderId);
            //订单明细id
            detailCardDTO.setDetailOrderId(detailOrderId);
            //停车场卡券id 对应t_vip_card
            detailCardDTO.setVipCardNo(req.getCardNo());
            //订单类型:301：会员卡购买单，302：会员卡续费
            detailCardDTO.setOrderType(orderDetailType);
            //个人卡券关联编码
            detailCardDTO.setPersonCardNo(vipCardCustInfoDetail.getCustCardNo());
            //1-大型车；2-小型车
            detailCardDTO.setCarType(req.getCarType());
            //卡类型 1-年卡；2-半年卡；3-季卡；4-月卡；5-日卡；
            if (Long.valueOf("10007").equals(req.getOrgId())) {
                //西城都是月卡
                detailCardDTO.setCardType(4);
            } else {
                detailCardDTO.setCardType(req.getCardType());
            }

            //终端来源[字典表:TERMINAL_SOURCE]：1:任你听 2：pda 3：微信公共号 4:云平台
            //		if (VIPCardEnum.CARD_RES_1.getValue().equals(req.getCardRes()) ) {
            //			detailCardDTO.setTerminalSource(TerminalSourceEnum.RNT.value());
            //		} else if ( VIPCardEnum.CARD_RES_2.getValue().equals(req.getCardRes())) {
            //			detailCardDTO.setTerminalSource(TerminalSourceEnum.WxPublic.value());
            //		}else{
            //			detailCardDTO.setTerminalSource(TerminalSourceEnum.CloudsPlatform.value());
            //		}
            detailCardDTO.setTerminalSource(TerminalSourceEnum.CloudsPlatform.value());
            //卡金额（单价）
            detailCardDTO.setPrice(req.getPrice() != null ? req.getPrice() : 0L);
            //购买数量
            detailCardDTO.setBuyNum(vipCardCustInfoDetail.getNum());
            //购买时优惠后金额
            detailCardDTO.setOrderDicountFee(
                vipCardCustInfoDetail.getDiscountAmount() != null ? vipCardCustInfoDetail.getDiscountAmount() : 0L);
            //购买时实收金额=优惠后金额
            detailCardDTO.setCardActAmount(spiltFee);
            //使用类型:1-单体卡；2-共享卡
            detailCardDTO.setUseType(1);
            //停车场编号
            detailCardDTO.setPlNo(req.getPlNo());
            //个人客户id
            detailCardDTO.setPersonCustId(vipCardCustInfoDetail.getPeronCustId());
            //车牌号
            detailCardDTO.setCarNumber(vipCardCustInfoDetail.getCarNumber());

            //生效时间
            detailCardDTO.setEffDate(
                DateUtil.parse(vipCardCustInfoDetail.getEffDate(), DateUtil.NORM_DATETIME_PATTERN));
            //失效效时间
            detailCardDTO.setExpDate(
                DateUtil.parse(vipCardCustInfoDetail.getExpDate(), DateUtil.NORM_DATETIME_PATTERN));

            //数据状态
            detailCardDTO.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());

            //创建人ID
            detailCardDTO.setCreateEmpId(
                req.getCreateEmpid() == null ? req.getModifyEmpid() + "" : req.getCreateEmpid() + "");
            //创建人
            detailCardDTO.setCreateName(
                StringUtils.isEmpty(req.getCreateName()) ? req.getModifyName() : req.getCreateName());
            if (Long.valueOf("10007").equals(req.getOrgId())) {
                Date effDate = DateUtil.parse(vipCardCustInfoDetail.getEffDate(), DateUtil.NORM_DATETIME_PATTERN);
                if (i == 0) {
                    //创建时间
                    detailCardDTO.setCreateDate(effDate);
                } else {
                    detailCardDTO.setCreateDate(DateUtil.beginOfMonth(DateUtil.offsetMonth(effDate, i)));
                }
            } else {
                detailCardDTO.setCreateDate(new Date());
            }

            orderVipcardDetailDTOList.add(detailCardDTO);
        }
        request.setOrderVipcardDetailDTOList(orderVipcardDetailDTOList);

        /***3.构建支付单信息.*/
        PayOrderDTO payOrder = new PayOrderDTO();
        String payOrderId = SequenceUtil.getNextId(SequenceTypeEnum.ORDER_PAY_FLOW_XIANJIN);
        //支付单id
        payOrder.setPayOrderId(payOrderId);
        //关联的订单大类型[字典表:ORDER_BIG_TYPE]：100：停车订单 200：充值订单 300:会员卡订单
        payOrder.setOrderBigType(300);
        //支付单类型[字典表:PAY_ORDER_TYPE]:101:停车付款单,102：停车预付单，103:停车补缴单；201：余额充值单,202：押金充值；301：会员卡购买单，302：会员卡续费
        payOrder.setPayOrderType(orderDetailType);
        // 关联订单id
        payOrder.setRltOrderId(orderId);
        //支付方式-- 1:支付宝 2：微信 3：银联. 6 现金 */
        payOrder.setPayType(null == vipCardCustInfoDetail.getPayType() ? 33 : vipCardCustInfoDetail.getPayType());
        //终端来源[字典表:TERMINAL_SOURCE]：1:任你听 2：pda 3：微信公共号 4:云平台
        if (VIPCardEnum.CARD_RES_1.getValue().equals(req.getCardRes())) {
            payOrder.setTerminalSource(TerminalSourceEnum.RNT.value());
        } else if (VIPCardEnum.CARD_RES_2.getValue().equals(req.getCardRes())) {
            payOrder.setTerminalSource(TerminalSourceEnum.WxPublic.value());
        } else {
            payOrder.setTerminalSource(TerminalSourceEnum.CloudsPlatform.value());
        }
        //优惠金额 单位:分
        payOrder.setOrderDicountFee(
            vipCardCustInfoDetail.getDiscountAmount() == null ? 0 : vipCardCustInfoDetail.getDiscountAmount());
        //优惠描述
        if (payOrder.getOrderDicountFee() != null && payOrder.getOrderDicountFee() > 0) {
            PayOrderDiscountRemarkDTO payOrderDiscountRemarkDTO = new PayOrderDiscountRemarkDTO();
            payOrderDiscountRemarkDTO.setDiscountValue(vipCardCustInfoDetail.getDiscountAmount());
            payOrder.setDiscountRemark(JSONObject.toJSON(payOrderDiscountRemarkDTO) + "");
        }
        //订单实收金额 单位:分
        payOrder.setOrderActFee(vipCardCustInfoDetail.getActFee() == null ? 0 : vipCardCustInfoDetail.getActFee());
        //订单应收金额 单位:分
        payOrder.setOrderTotalFee(vipCardCustInfoDetail.getTotalAmount());
        //订单状态[字典表:ORDER_STATE]: 10:待核算、20：待支付、30:支付中,40：已支付、50：已完成
        payOrder.setPayOrderState(OrderStateEnum.PAYED.value());
        //停车场编码
        payOrder.setPlNo(req.getPlNo());
        //支付完成时间
        payOrder.setPayFinishTime(new Date());
        //创建人ID
        payOrder.setCreateEmpId(req.getCreateEmpid() == null ? req.getModifyEmpid() + "" : req.getCreateEmpid() + "");
        //创建人
        payOrder.setCreateEmpName(StringUtils.isEmpty(req.getCreateName()) ? req.getModifyName() : req.getCreateName());
        //创建时间
        payOrder.setCreateDate(new Date());
        //设置appid :微信、支付宝、公众号对应appid
        payOrder.setAppId("no_app_id");
        //数据状态
        payOrder.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
        request.setPayOrderDTO(payOrder);
        request.setSysCode("101");
        BizResult<Boolean> result = vipCardOrderOperService.saveVipCardOrderAndDetailAndPayOrder(request);
        if (result != null && result.getData()) {
            flg = 1;
            /**保存会员卡购买日志信息.*/
            TVipCardLogs record = new TVipCardLogs();
            //个人客户id
            record.setCustId(vipCardCustInfoDetail.getPeronCustId());
            //购买数量
            record.setNum(vipCardCustInfoDetail.getNum());
            //卡编码
            record.setCardNo(req.getCardNo());
            //个人卡编码
            record.setCustCardNo(vipCardCustInfoDetail.getCustCardNo());
            //车牌号
            record.setCarNumber(vipCardCustInfoDetail.getCarNumber());
            //停车场编号
            record.setPlNo(req.getPlNo());
            //业务类型:301：会员卡购买单，302：会员卡续费 ，303:变更车牌
            record.setBusiType(orderDetailType);
            //购买时优惠后金额
            record.setDiscountAmount(
                vipCardCustInfoDetail.getDiscountAmount() != null ? vipCardCustInfoDetail.getDiscountAmount() : 0L);
            //购买时实收金额=优惠后金额
            record.setCardActAmount(vipCardCustInfoDetail.getActFee() != null ? vipCardCustInfoDetail.getActFee() : 0L);
            //生效时间
            record.setEffDate(DateUtil.parse(vipCardCustInfoDetail.getEffDate(), DateUtil.NORM_DATETIME_PATTERN));
            //失效效时间
            record.setExpDate(DateUtil.parse(vipCardCustInfoDetail.getExpDate(), DateUtil.NORM_DATETIME_PATTERN));
            //数据状态
            record.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());

            //创建人ID
            record.setCreateEmpid(req.getCreateEmpid() == null ? req.getModifyEmpid() + "" : req.getCreateEmpid() + "");
            //创建人
            record.setCreateName(StringUtils.isEmpty(req.getCreateName()) ? req.getModifyName() : req.getCreateName());
            //创建时间
            record.setCreateDate(new Date());
            //orderVipcardDetailDTOList.add(detailCardDTO);
            int insertSelective = tVipCardLogsDao.insertSelective(record);
            logger.info("会员卡办理,业务类型:(301：会员卡购买单，302：会员卡续费 ，303:变更车牌 业务类型={},插入日志数={}条。", orderDetailType,
                insertSelective);

        }

        logger.info("---end保存会员卡订单信息");
        return flg;
    }

    /**
     * 计算结束时间.<br/>
     *
     * @param effDate
     *     生效时间
     * @param cardType
     *     获取卡类型 1-年卡；2-半年卡；3-季卡；4-月卡；5-日卡
     * @param cardNum
     *     购买数量
     * @return
     */
    private String getExpDate(String effDate, Integer cardType, Integer cardNum) {
        if (StringUtils.isNotEmpty(effDate) && effDate.length() < 11) {
            effDate = effDate + " 00:00:00";
        }
        Date expDate = null;
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar cal = Calendar.getInstance();
        try {
            cal.setTime(format.parse(effDate));
            switch (cardType) {
                case 1:
                    cal.add(Calendar.YEAR, cardNum);
                    expDate = cal.getTime();
                    break;
                case 2:
                    cal.add(Calendar.MONTH, cardNum * 6);
                    expDate = cal.getTime();
                    break;
                case 3:
                    cal.add(Calendar.MONTH, cardNum * 3);
                    expDate = cal.getTime();
                    break;
                case 4:
                    cal.add(Calendar.MONTH, cardNum);
                    expDate = cal.getTime();
                    break;
                case 5:
                    cal.add(Calendar.DAY_OF_MONTH, cardNum);
                    expDate = cal.getTime();
                    break;
                case 6:
                    cal.add(Calendar.YEAR, cardNum);
                    expDate = cal.getTime();
                    break;
                case 7:
                    cal.add(Calendar.MONTH, cardNum);
                    expDate = cal.getTime();
                    break;
                case 8:
                    cal.add(Calendar.MONTH, cardNum);
                    expDate = cal.getTime();
                    break;
                default:
                    break;
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.info("计算买卡结束时间失败!!");
            throw new BizException(ErrorType.BIZ_ERROR, "计算买卡结束时间失败!");
        }

        return DateUtil.formatDateTime(DateUtil.endOfDay(DateUtil.offsetDay(expDate, -1)));
        //return DateUtil.format(DateUtil.offsetDay(expDate,-1),DateUtil.NORM_DATE_PATTERN)+" 23:59:59"; //format
		// .format();
    }

    @Override
    public BizResult<List<VipCardCustInfoDTO>> queryVipCardCustInfoByCustId(
        QueryVipCardCustInfoByCustIdRequest request) {
        if (StringUtils.isEmpty(request.getCustId())) {
            logger.info("入参为空");
            throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
        }
        List<TVipCardCustInfo> list = vipCardCustInfoDao.queryVipCardCustInfoByCustId(request);
        List<VipCardCustInfoDTO> dtoList = new ArrayList<VipCardCustInfoDTO>();
        if (CollectionUtils.isNotEmpty(list)) {
            for (TVipCardCustInfo tVipCardCustInfo : list) {
                VipCardCustInfoDTO dto = new VipCardCustInfoDTO();
                if (tVipCardCustInfo != null) {
                    BeanUtils.copyProperties(tVipCardCustInfo, dto);
                }
                dtoList.add(dto);
            }
        }
        return new BizResult<List<VipCardCustInfoDTO>>(dtoList);
    }

    @Override
    public BizResult<List<VipCardParkCustRelDTO>> queryVipCardParkCustRelByCustId(
        QueryVipCardParkCustRelByCustIdRequest request) {
        if (StringUtils.isEmpty(request.getCustId())) {
            logger.info("入参为空");
            throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
        }
        List<TVipCardParkCustRel> list = vipCardParkCustRelDao.queryVipCardParkCustRelByCustId(request.getCustId());
        List<VipCardParkCustRelDTO> dtoList = new ArrayList<VipCardParkCustRelDTO>();
        if (CollectionUtils.isNotEmpty(list)) {
            for (TVipCardParkCustRel tVipCardParkCustRel : list) {
                VipCardParkCustRelDTO dto = new VipCardParkCustRelDTO();
                if (tVipCardParkCustRel != null) {
                    BeanUtils.copyProperties(tVipCardParkCustRel, dto);
                }
                dtoList.add(dto);
            }
        }
        return new BizResult<List<VipCardParkCustRelDTO>>(dtoList);
    }

    /**
     * 通过卡编码查询停车场与会员卡售卖关联关系
     *
     * @param request
     * @return 2017年10月31日
     */
    @Override
    public BizResult<List<VipCardParkSaleRelDTO>> queryVipCardParkSaleRelForListByCardNo(
        VipCardCustInfoForPageQueryRequest request) {
        List<VipCardParkSaleRelDTO> list = new ArrayList<>();
        TVipCardParkSaleRel vipCardParkSaleRelDO = new TVipCardParkSaleRel();
        vipCardParkSaleRelDO.setCardNo(request.getCardNo());
        List<TVipCardParkSaleRel> parkSaleRelList = vipCardParkSaleRelDao.queryVipCardParkSaleRelForListByCardNo(
            vipCardParkSaleRelDO);
        if (CollectionUtils.isNotEmpty(parkSaleRelList)) {
            ListCopyUtil.listCopyProperties(parkSaleRelList, list, VipCardParkSaleRelDTO.class);
        }
        return new BizResult<List<VipCardParkSaleRelDTO>>(list);
    }

    /**
     * 通过车牌／停车场编码查询车辆是否购买会员卡.<br/>
     *
     * @param request
     * @return 下午2:55:47 wangfs.<br/>
     * @throws Exception
     * @throws Exception
     */
    @Override
    public BizResult<CarNumIsFreeDTO> queryCarNumIsBuyVipCard(QueryCarNumIsWhitelistRequest request) throws Exception {
        SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
        String currentDate = null;
        if (request.getCurrentDate() != null) {
            currentDate = com.clouds.common.utils.DateUtil.getDateString(request.getCurrentDate(),
                com.clouds.common.utils.DateUtil.DATETIME_FORMAT);
        } else {
            currentDate = com.clouds.common.utils.DateUtil.getDateString(new Date(),
                com.clouds.common.utils.DateUtil.DATETIME_FORMAT);
        }

        logger.info("begin查询用户是否购买会员卡,入参={}", JSONObject.toJSON(request));
        //1:免费,0:不免费
        int isFreeFlg = 0;
        CarNumIsFreeDTO carNumIsFreeDTO = new CarNumIsFreeDTO();
        /**1.查询用户是否办理会员卡.*/
        TVipCardCustInfo vipCardCustInfo = vipCardCustInfoDao.queryCarNumIsBuyVipCard(request, currentDate);
        if (vipCardCustInfo == null || StringUtils.isEmpty(vipCardCustInfo.getCardNo())) {
            logger.info("车牌={}用户没有购买会员卡", request.getCarNumber());
            carNumIsFreeDTO = this.getCarNumIsFree(request.getCarNumber(), isFreeFlg, null);
        } else {
            /**2通过会员卡编码查询会员卡信息.*/
            TVipCard vipCard = vipCardDao.queryVipCardByOnlyCardNo(vipCardCustInfo.getCardNo());
            if (null == vipCard) {
                throw new BizException(ErrorType.PARAMM_NULL, "获取vip卡对象为null");
            }
            //不限制
            if (HolidayEnum.EVERY_TIME.value().equals(vipCard.getSpecialDayType())) {
                logger.info("车牌号{}购买会员卡没有时间限制", request.getCarNumber());
                isFreeFlg = 1;
                carNumIsFreeDTO = this.getCarNumIsFree(request.getCarNumber(), isFreeFlg, vipCard.getCardType());
            } else {
                /**是否节假日(非工作日) true:非工作日(放假)，false：工作日.*/
                Boolean flg = this.queryDaysInfoOfSolar(currentDate);
                String currentDateHHMMSS = com.clouds.common.utils.DateUtil.getDateString(new Date(), "HH:mm:ss");
                //工作日
                if (HolidayEnum.IS_NOT_HOLIDAY.value().equals(vipCard.getSpecialDayType())) {
                    if (!flg) {//工作日
                        if (format.parse(currentDateHHMMSS).getTime() >= vipCard.getValidStartTime().getTime() &&
                            format.parse(currentDateHHMMSS).getTime() <= vipCard.getValidEndTime().getTime()) {
                            logger.info("适用工作日时间限制,当前时间={},会员卡开始时间={},会员卡结束时间={}", currentDateHHMMSS,
                                com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidStartTime(), "HH:mm:ss"),
                                com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidEndTime(), "HH:mm:ss"));
                            isFreeFlg = 1;
                            carNumIsFreeDTO = this.getCarNumIsFree(request.getCarNumber(), isFreeFlg,
                                vipCard.getCardType());
                        } else {
                            logger.info("适用工作日时间限制不满足,当前时间={},会员卡开始时间={},会员卡结束时间={}", currentDateHHMMSS,
                                com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidStartTime(), "HH:mm:ss"),
                                com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidEndTime(), "HH:mm:ss"));
                            carNumIsFreeDTO = this.getCarNumIsFree(request.getCarNumber(), isFreeFlg, null);
                        }
                    } else {
                        logger.info("会员卡适用于工作日（免费）,但是当前天【{}】为节假日，因此不免费..", currentDate);
                        carNumIsFreeDTO = this.getCarNumIsFree(request.getCarNumber(), isFreeFlg, null);
                    }
                }
                //非工作日(节假日)
                if (HolidayEnum.IS_HOLIDAY.value().equals(vipCard.getSpecialDayType())) {
                    //if(format.parse(currentDateHHMMSS).getTime() >= vipCard.getValidStartTime().getTime() &&
                    //format.parse(currentDateHHMMSS).getTime() <= vipCard.getValidEndTime().getTime()){
                    if (flg) {//非工作日(放假)
                        if (com.clouds.common.utils.DateUtil.isInTime(format.parse(currentDateHHMMSS),
                            vipCard.getValidStartTime(), vipCard.getValidEndTime())) {
                            logger.info("适用非工作日(节假日)时间限制,当前时间={},会员卡开始时间={},会员卡结束时间={}", currentDateHHMMSS,
                                com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidStartTime(), "HH:mm:ss"),
                                com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidEndTime(), "HH:mm:ss"));
                            isFreeFlg = 1;
                            carNumIsFreeDTO = this.getCarNumIsFree(request.getCarNumber(), isFreeFlg,
                                vipCard.getCardType());
                        } else {
                            logger.info("适用非工作日时间限制不满足,当前时间={},会员卡开始时间={},会员卡结束时间={}", currentDateHHMMSS,
                                com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidStartTime(), "HH:mm:ss"),
                                com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidEndTime(), "HH:mm:ss"));
                            carNumIsFreeDTO = this.getCarNumIsFree(request.getCarNumber(), isFreeFlg, null);
                        }
                    } else {//工作日(不放假)
                        logger.info("适用非工作日时间限制不满足,当前时间={},会员卡开始时间={},会员卡结束时间={}", currentDateHHMMSS,
                            com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidStartTime(), "HH:mm:ss"),
                            com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidEndTime(), "HH:mm:ss"));
                        carNumIsFreeDTO = this.getCarNumIsFree(request.getCarNumber(), isFreeFlg, null);
                    }
                }
                //每日
                if (HolidayEnum.EVERY_DAY.value().equals(vipCard.getSpecialDayType())) {
                    //if(format.parse(currentDateHHMMSS).getTime() >= vipCard.getValidStartTime().getTime() &&
                    //format.parse(currentDateHHMMSS).getTime() <= vipCard.getValidEndTime().getTime()){
                    if (com.clouds.common.utils.DateUtil.isInTime(format.parse(currentDateHHMMSS),
                        vipCard.getValidStartTime(), vipCard.getValidEndTime())) {
                        logger.info("适用每日时间限制,当前时间={},会员卡开始时间={},会员卡结束时间={}", currentDateHHMMSS,
                            com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidStartTime(), "HH:mm:ss"),
                            com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidEndTime(), "HH:mm:ss"));
                        isFreeFlg = 1;
                        carNumIsFreeDTO = this.getCarNumIsFree(request.getCarNumber(), isFreeFlg,
                            vipCard.getCardType());
                    } else {
                        logger.info("适用每日时间限制不满足,当前时间={},会员卡开始时间={},会员卡结束时间={}", currentDateHHMMSS,
                            com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidStartTime(), "HH:mm:ss"),
                            com.clouds.common.utils.DateUtil.getDateString(vipCard.getValidEndTime(), "HH:mm:ss"));
                        carNumIsFreeDTO = this.getCarNumIsFree(request.getCarNumber(), isFreeFlg, null);
                    }
                }

            }
        }
        logger.info("end查询用户是否购买会员卡,结果={}", JSONObject.toJSON(carNumIsFreeDTO));

        return new BizResult<CarNumIsFreeDTO>(carNumIsFreeDTO);
    }

    /**
     * 获取会员卡是否免费对象
     *
     * @param carNum
     * @param isFreeFlg
     * @param cardType
     *     2017年11月21日  wangfs.<br/>
     */
    private CarNumIsFreeDTO getCarNumIsFree(String carNum, int isFreeFlg, Integer cardType) {
        CarNumIsFreeDTO carNumIsFreeDTO = new CarNumIsFreeDTO();
        carNumIsFreeDTO.setCarNum(carNum);
        carNumIsFreeDTO.setIsFree(isFreeFlg);
        carNumIsFreeDTO.setFreeReason(cardType != null ? this.getCardType(cardType) : null);
        return carNumIsFreeDTO;
    }

    /**
     * 查询制定日期是否为节假日.<b>
     *
     * @param parkOutTime
     * @return
     */
    private Boolean queryDaysInfoOfSolar(String parkOutTime) {
        logger.info("begin查询给定日期是否节假日,入参={}", parkOutTime);
        Boolean flg = false;
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        /**查询是否为节假日.*/
        DaysInfoQueryReq req = new DaysInfoQueryReq();
        List<Date> dataList = new ArrayList<>();
        try {
            dataList.add(format.parse(parkOutTime));
            req.setQueryDates(dataList);
            BizResult<List<SpHolidaysDTO>> holidaysRestlt = holidayService.queryDaysInfoOfSolar(req);
            if (holidaysRestlt != null && CollectionUtils.isNotEmpty(holidaysRestlt.getData())) {
                for (SpHolidaysDTO holidaysDTO : holidaysRestlt.getData()) {
                    if (holidaysDTO != null && HolidayEnum.IS_HOLIDAY.value().equals(
                        holidaysDTO.getIsHolidays())) {//**是否节假日 1-否 2-是.*/
                        flg = true;
                        break;
                    }
                }
            }
        } catch (ParseException e) {
            e.printStackTrace();
            throw new BizException(ErrorType.BIZ_ERROR, "查询是否是节假日");
        }
        logger.info("begin查询给定日期是否节假日,结果=【{}】 true=非工作日,false=工作日", flg);
        return flg;

    }

    /**
     * 会员卡名称
     *
     * @param cardType
     * @return 2017年11月20日  wangfs.<br/>
     */
    private ParkDetailTypeEnum getCardType(Integer cardType) {
        ParkDetailTypeEnum cardTypeValue = null;
        if (cardType != null) {
            switch (cardType) {
                case 1:
                    cardTypeValue = ParkDetailTypeEnum.PackYearCar;
                    break;
                case 2:
                    cardTypeValue = ParkDetailTypeEnum.PackHalfYearCar;
                    break;
                case 3:
                    cardTypeValue = ParkDetailTypeEnum.PackQuarterCar;
                    break;
                case 4:
                    cardTypeValue = ParkDetailTypeEnum.PackMonthCar;
                    break;
                case 5:
                    cardTypeValue = ParkDetailTypeEnum.PackDayCar;
                    break;
                default:
                    break;
            }
        }
        return cardTypeValue;
    }

    /**
     * 通过车牌号+开始结束时间查询是否已经办理.<br/>
     *
     * @param request
     * @return 2017年12月30日  wangfs.<br/>
     */
    @Override
    public BizResult<Integer> queryNoPustVipCardCustInfoByCarNum(VipCardCustInfoForPageQueryRequest request) {
        logger.info("beig重复办理校验,入参={}", JSONObject.toJSON(request));
        int counts = 0;
        if (request == null) {
            logger.info("入参为空");
            throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
        }
        TVipCardCustInfo record = new TVipCardCustInfo();
        record.setCarNumber(request.getCarNum());
        record.setEffDate(request.getBeginTime());
        record.setExpDate(request.getEndTime());
        record.setCreateDate(request.getCreateDate());
        if (CollectionUtils.isNotEmpty(request.getPlNos())) {
            record.setPlNo(request.getPlNos().get(0) + "");
        }

        counts = vipCardCustInfoDao.queryNoPustVipCardCustInfoByCarNum(record);
        logger.info("end重复办理校验");
        return new BizResult<Integer>(counts);
    }

    /**
     * 账单管理-会员卡统计.<br/>
     * 步骤：
     * 1.查询会员卡购买信息.<br/>
     * 2.查询会员卡支付方式.<br/>
     * 3.合并1，2数据.<br/>
     * 4.按照停车场汇总.<br/>
     *
     * @param request
     * @return 2018年1月23日  wangfs.<br/>
     */
    @Override
    public BizResult<List<TdBCheckDayDTO>> queryVipCardIncome(QueryVipCardIncomeRequest request) {
        List<String> custCardNosList = new ArrayList<String>();
        List<String> plNos = new ArrayList<String>();
        if (request == null) {
            logger.info("入参为空");
            throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
        }
        /**1.查询会员卡信息.*/
        List<TdBVipCardInfoCheckDayDO> list = vipCardCustInfoDao.queryVipCardForPerson(request.getBeginTime(),
            request.getEndTime());
        if (CollectionUtils.isNotEmpty(list)) {
            for (TdBVipCardInfoCheckDayDO checkDayDO : list) {
                if (checkDayDO == null) {
                    continue;
                }
                custCardNosList.add(checkDayDO.getCustCardNo());
                plNos.add(checkDayDO.getPlNo());
            }
        }
        //QueryVipCardBuyPayTypeRequest request
        QueryVipCardBuyPayTypeRequest requestPayType = new QueryVipCardBuyPayTypeRequest();
        requestPayType.setSysCode("1001");
        requestPayType.setCustCardNos(custCardNosList);
        /**2.查询会员卡支付方式.*/
        BizResult<List<VipCardBuyPayTypeDTO>> result = vipCardOrderQueryService.queryVipCardPayType(requestPayType);
        /**3.合并数据.*/
        this.megerVipCardAndPayType(list, result);
        /**3.1.回填停车场数据.*/
        List<ParkingLotDTO> parkingLots = ParkingLotCacheUtil.getParkLotByPlNos(plNos);
        this.addParkingLotInfo(parkingLots, list);
        Map<String, TdBVipCardInfoCheckDayDO> map = new HashMap<>();
        /**4.按照停车场汇总.*/
        if (!CollectionUtils.isEmpty(list)) {
            for (TdBVipCardInfoCheckDayDO checkDayDO : list) {
                if (checkDayDO == null) {
                    continue;
                }
                String key = checkDayDO.getPlNo() + "_" + checkDayDO.getCheckFeeType();
                if (!map.containsKey(key)) {
                    map.put(key, checkDayDO);
                } else {
                    TdBVipCardInfoCheckDayDO dayDO = map.get(key);
                    dayDO.setDicountFee(checkFee(dayDO.getDicountFee()) + checkFee(checkDayDO.getDicountFee()));
                    dayDO.setActFee(checkFee(dayDO.getActFee()) + checkFee(checkDayDO.getActFee()));
                    dayDO.setTotalFee(checkFee(dayDO.getTotalFee()) + checkFee(checkDayDO.getTotalFee()));

                    if (checkDayDO.getAliChargeNum() > 0) {
                        dayDO.setAliFee(checkFee(dayDO.getAliFee()) + checkFee(checkDayDO.getActFee()));
                        dayDO.setAliChargeNum(checknum(dayDO.getAliChargeNum()) + 1);
                    }

                    if (checkDayDO.getWxChargeNum() > 0) {
                        dayDO.setWxChargeNum(checknum(dayDO.getWxChargeNum()) + 1);
                        dayDO.setWxFee(checkFee(dayDO.getWxFee()) + checkFee(checkDayDO.getWxFee()));
                    }

                    if (checkDayDO.getCashChargeNum() > 0) {
                        dayDO.setCashChargeNum(checknum(dayDO.getCashChargeNum()) + 1);
                        dayDO.setCashFee(checkFee(dayDO.getCashFee()) + checkFee(checkDayDO.getCashFee()));
                    }

                    if (checkDayDO.getBalanceChargeNum() > 0) {
                        dayDO.setBalanceChargeNum(checknum(dayDO.getBalanceChargeNum()) + 1);
                        dayDO.setBalanceFee(checkFee(dayDO.getBalanceFee()) + checkFee(checkDayDO.getBalanceFee()));
                    }
                    map.replace(key, dayDO);

                }

            }

        }
        //拷贝到结果list中
        List<TdBCheckDayDTO> listDTO = new ArrayList<>();
        if (map != null && map.size() > 0) {
            Iterator<Entry<String, TdBVipCardInfoCheckDayDO>> iterator = map.entrySet().iterator();
            while (iterator.hasNext()) {
                Entry<String, TdBVipCardInfoCheckDayDO> entry = iterator.next();
                TdBVipCardInfoCheckDayDO dayDO = entry.getValue();
                if (dayDO != null) {
                    TdBCheckDayDTO tdBCheckDayDTO = new TdBCheckDayDTO();
                    BeanUtils.copyProperties(dayDO, tdBCheckDayDTO);
                    listDTO.add(tdBCheckDayDTO);
                }
            }

        }
        return new BizResult<List<TdBCheckDayDTO>>(listDTO);
    }

    private int checknum(Integer num) {
        int returnInt = 0;
        if (num != null) {
            returnInt = num;
        }
        return returnInt;
    }

    private Long checkFee(Long fee) {
        Long returnFee = 0L;
        if (fee != null) {
            returnFee = fee;
        }
        return returnFee;
    }

    private void addParkingLotInfo(List<ParkingLotDTO> parkingLots, List<TdBVipCardInfoCheckDayDO> list) {
        for (TdBVipCardInfoCheckDayDO checkDayDO : list) {
            if (checkDayDO == null) {
                continue;
            }
            for (ParkingLotDTO parkingLotDTO : parkingLots) {
                if (parkingLotDTO == null) {
                    continue;
                }
                if (checkDayDO.getPlNo().equals(parkingLotDTO.getPlNo())) {
                    checkDayDO.setPlName(parkingLotDTO.getPlName());
                    checkDayDO.setAreaId(parkingLotDTO.getPlAreaBlockId() + "");
                    checkDayDO.setAreaName(parkingLotDTO.getPlAreaBlockName());
                }
            }
        }
    }

    /**
     * 合并会员记录与支付方式.<br/>
     *
     * @param list
     * @param result
     *     2018年1月23日  wangfs.<br/>
     */
    private void megerVipCardAndPayType(List<TdBVipCardInfoCheckDayDO> list,
        BizResult<List<VipCardBuyPayTypeDTO>> result) {
        if (result != null && CollectionUtils.isNotEmpty(result.getData())) {
            List<VipCardBuyPayTypeDTO> vipCardBuyPayTypeList = result.getData();
            for (VipCardBuyPayTypeDTO payTypeDO : vipCardBuyPayTypeList) {
                if (payTypeDO == null) {
                    continue;
                }
                for (TdBVipCardInfoCheckDayDO checkDayDO : list) {
                    if (checkDayDO == null) {
                        continue;
                    }
                    if (checkDayDO.getCustCardNo().equals(payTypeDO.getPersonCardId())) {
                        switch (payTypeDO.getPayType()) {
                            case 1:
                                checkDayDO.setAliFee(checkDayDO.getActFee());
                                checkDayDO.setAliChargeNum(1);
                                break;
                            case 2:
                                checkDayDO.setWxFee(checkDayDO.getActFee());
                                checkDayDO.setWxChargeNum(1);
                                break;
                            case 4:
                                checkDayDO.setWxFee(checkDayDO.getActFee());
                                checkDayDO.setWxChargeNum(1);
                                break;
                            case 5:
                                checkDayDO.setBalanceFee(checkDayDO.getActFee());
                                checkDayDO.setBalanceChargeNum(1);
                                break;
                            case 6:
                                checkDayDO.setCashFee(checkDayDO.getActFee());
                                checkDayDO.setCashChargeNum(1);
                                break;

                        }

                    }
                }
            }
        }
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public BizResult<List<String>> SyncVipCardData(VipCardDataInfoRequest requestObject) {
        // if (0 < vipCardCustInfoDao.selectVipCardCustInfoByCustCardNo(custCardNo))
        List<String> successCardIdList = new ArrayList<String>();
        String appId = requestObject.getAppId();
        String parkCode = requestObject.getParkCode();
        String sysCode = requestObject.getSysCode();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        List<VipCardAndCarInfo> vipCardAndCarInfoList = requestObject.getCars();
        for (VipCardAndCarInfo item : vipCardAndCarInfoList) {
            // 防止get异常
            VipCardAndCarInfo vipCardAndCarInfo = new VipCardAndCarInfo();
            BeanUtils.copyProperties(item, vipCardAndCarInfo);

            // 个人会员卡编码 （个人会员卡id）
            String custCardNo = vipCardAndCarInfo.getCardId();
            // 同步类型 1/301/302    修改信息/会员卡购买/会员卡续费
            Integer orderType = vipCardAndCarInfo.getOrderType();
            // 优惠金额
            Long discountFee = Long.valueOf(vipCardAndCarInfo.getDicountFee());
            // 单价
            Long price = Long.valueOf(vipCardAndCarInfo.getPrice());
            // 实收金额
            Long actFee = Long.valueOf(vipCardAndCarInfo.getActFee());
            // 总金额
            Long totalFee = discountFee + actFee;
            // 购卡数量
            Integer num = vipCardAndCarInfo.getNum();
            // 卡类型 1-年卡；2-半年卡；3-季卡；4-月卡；5-日卡；
            Integer cardType = vipCardAndCarInfo.getCardType();
            // 购卡来源: 1:App购买 2:公众号购买 3:线下购买
            Integer cardRes = vipCardAndCarInfo.getCardRes();
            // 会员卡规则ID
            String cardNo = vipCardAndCarInfo.getCardNo();
            // 支付类型
            Integer payType = null;
            if (null == vipCardAndCarInfo.getPayType()) {
                payType = PayTypeEnum.XIANJIN.getValue();
            } else {
                payType = vipCardAndCarInfo.getPayType();
            }
            // 车辆类型 1:大型车 2:小型车
            Integer carType = Integer.valueOf(vipCardAndCarInfo.getCarType());
            // 车牌
            String carNumber = vipCardAndCarInfo.getCarNumber();
            // 当前时间
            Date curDate = com.clouds.common.utils.DateUtil.getDate();
            // personCustId t_c_car
            String custId = SequenceUtil.getNextId(SequenceTypeEnum.SYNCDATA_TEMP);

            long lEffDate = Long.valueOf(vipCardAndCarInfo.getEffDate());
            long lExpDate = Long.valueOf(vipCardAndCarInfo.getExpDate());
            // 生效时间
            String sEffDate = format.format(lEffDate);
            Date effDate = null;
            try {
                effDate = format.parse(sEffDate);
            } catch (ParseException e1) {
                e1.printStackTrace();
            }

            // 过期时间
            String sExpDate = format.format(lExpDate);
            Date expDate = null;
            try {
                expDate = format.parse(sExpDate);
            } catch (ParseException e) {
                e.printStackTrace();
            }

            /** 数据同步处理开始 **/
            // 1/301/302    修改信息/会员卡购买/会员卡续费
            // 修改信息
            if (1 == orderType) {
                /*更新个人会员卡表*/
                TVipCardCustInfo tVipCardCustInfo = new TVipCardCustInfo();
                tVipCardCustInfo.setCustCardNo(custCardNo);
                tVipCardCustInfo.setEffDate(effDate);
                tVipCardCustInfo.setExpDate(expDate);
                tVipCardCustInfo.setCardRes(cardRes);
                tVipCardCustInfo.setPrice(price);
                tVipCardCustInfo.setNum(num);
                tVipCardCustInfo.setDiscountAmount(discountFee);
                tVipCardCustInfo.setTotalAmount(totalFee);
                tVipCardCustInfo.setModifyDate(curDate);
                vipCardCustInfoDao.updateVipCardCustInfoByCustCardNo(tVipCardCustInfo);

                /* 更新会员卡订单表 */
                QueryOrderIDByPersonCardNoRequest queryOrderIDByPersonCardNoReq
                    = new QueryOrderIDByPersonCardNoRequest();
                queryOrderIDByPersonCardNoReq.setSysCode(sysCode);
                queryOrderIDByPersonCardNoReq.setPersonCardNo(custCardNo);
                BizResult<String> bizResult = vipCardOrderOperService.queryOrderIDByPersonCardNo(
                    queryOrderIDByPersonCardNoReq);
                String orderId = null;
                if (null != bizResult) {
                    orderId = bizResult.getData();
                }
                UpdateOrderVipcardRequest updateOrderVipcardReq = new UpdateOrderVipcardRequest();
                updateOrderVipcardReq.setSysCode(sysCode);
                updateOrderVipcardReq.setOrderId(orderId);
                updateOrderVipcardReq.setOrderDicountFee(discountFee);
                updateOrderVipcardReq.setOrderActFee(actFee);
                updateOrderVipcardReq.setOrderTotalFee(totalFee);
                updateOrderVipcardReq.setOrderType(orderType);
                updateOrderVipcardReq.setModfiyDate(curDate);
                vipCardOrderOperService.updateOrderVipCardByOrderId(updateOrderVipcardReq);

                /* 更新会员卡订单明细表 */
                UpdateVipcardDetailReq updateVipcardDetailReq = new UpdateVipcardDetailReq();
                updateVipcardDetailReq.setSysCode(sysCode);
                updateVipcardDetailReq.setEffDate(effDate);
                updateVipcardDetailReq.setExpDate(expDate);
                updateVipcardDetailReq.setPrice(price);
                updateVipcardDetailReq.setBuyNum(num);
                updateVipcardDetailReq.setCardType(cardType);
                updateVipcardDetailReq.setOrderDicountFee(discountFee);
                updateVipcardDetailReq.setModifyDate(curDate);
                updateVipcardDetailReq.setPersonCardNo(custCardNo);
                vipCardOrderOperService.updateVipcardDetailByPersonCardNo(updateVipcardDetailReq);

                // 更新支付订单
                UpdatePayOrderRequest updatePayOrderReq = new UpdatePayOrderRequest();
                updatePayOrderReq.setSysCode(sysCode);
                updatePayOrderReq.setOrderDicountFee(discountFee);
                updatePayOrderReq.setOrderActFee(actFee);
                updatePayOrderReq.setOrderTotalFee(totalFee);
                updatePayOrderReq.setModfiyDate(curDate);
                updatePayOrderReq.setRltOrderId(orderId);
                vipCardOrderOperService.updatePayOrderByRltOrderId(updatePayOrderReq);
            }

            // 会员卡购买 (新增)
            if (301 == orderType) {
                // 新增订单会员卡, 订单会员卡详情
                OrderVipcardAndDetailRequest newOrderVipcardAndDetailReq = new OrderVipcardAndDetailRequest();
                newOrderVipcardAndDetailReq.setSysCode(sysCode);
                newOrderVipcardAndDetailReq.setPersonCardNo(custCardNo);
                newOrderVipcardAndDetailReq.setOrderType(orderType);
                newOrderVipcardAndDetailReq.setBuyNum(num);
                newOrderVipcardAndDetailReq.setPrice(price);
                newOrderVipcardAndDetailReq.setCardActAmount(actFee);
                newOrderVipcardAndDetailReq.setOrderDicountFee(discountFee);
                newOrderVipcardAndDetailReq.setOrderTotalFee(totalFee);
                newOrderVipcardAndDetailReq.setPersonCustId(custId);
                newOrderVipcardAndDetailReq.setEffDate(effDate);
                newOrderVipcardAndDetailReq.setExpDate(expDate);
                newOrderVipcardAndDetailReq.setPlNo(parkCode);
                newOrderVipcardAndDetailReq.setVipCardNo(cardNo);
                newOrderVipcardAndDetailReq.setCarNumber(carNumber);
                newOrderVipcardAndDetailReq.setCardType(cardType);
                BizResult<String> bizRltOrderId = vipCardOrderOperService.syncDataNewVipCardAndDetailRecord(
                    newOrderVipcardAndDetailReq);

                // 新增支付订单
                NewPayOrderRecordRequest newPayOrderRecordRe = new NewPayOrderRecordRequest();
                newPayOrderRecordRe.setSysCode(sysCode);
                newPayOrderRecordRe.setRltOrderId(bizRltOrderId.getData());
                newPayOrderRecordRe.setPayType(null == payType ? 33 : payType);
                newPayOrderRecordRe.setOrderBigType(OrderBigTypeEnum.VIP_ORDER.value());
                newPayOrderRecordRe.setPayOrderType(orderType);
                newPayOrderRecordRe.setTerminalSource(TerminalSourceEnum.DZ.value());
                newPayOrderRecordRe.setPayFinishTime(curDate);
                newPayOrderRecordRe.setPayOrderState(OrderStateEnum.COMPLETED.value());
                newPayOrderRecordRe.setPlNo(parkCode);
                newPayOrderRecordRe.setAppId(appId);
                newPayOrderRecordRe.setOrderDicountFee(discountFee);
                newPayOrderRecordRe.setOrderActFee(actFee);
                newPayOrderRecordRe.setOrderTotalFee(totalFee);
                newPayOrderRecordRe.setCreateDate(curDate);
                newPayOrderRecordRe.setModfiyDate(curDate);
                newPayOrderRecordRe.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
                vipCardOrderOperService.synDataNewPayOrderRecord(newPayOrderRecordRe);

                // 新增个人会员卡记录 custCardNo
                TVipCardCustInfo newVipCardCustInfo = new TVipCardCustInfo();
                newVipCardCustInfo.setCustId(custId);
                newVipCardCustInfo.setCustCardNo(custCardNo);
                newVipCardCustInfo.setCardNo(cardNo);
                newVipCardCustInfo.setCarNumber(carNumber);
                newVipCardCustInfo.setCardRes(cardRes);
                newVipCardCustInfo.setCarType(carType);
                newVipCardCustInfo.setIsSupportRenew(1); // 是否支持续费1：是，0否
                newVipCardCustInfo.setEffDate(effDate);
                newVipCardCustInfo.setExpDate(expDate);
                newVipCardCustInfo.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
                newVipCardCustInfo.setPrice(price);
                newVipCardCustInfo.setNum(num);
                newVipCardCustInfo.setDiscountAmount(discountFee);
                newVipCardCustInfo.setTotalAmount(totalFee);
                newVipCardCustInfo.setCreateDate(curDate);
                newVipCardCustInfo.setModifyDate(curDate);
                vipCardCustInfoDao.saveVipCardCustInfo(newVipCardCustInfo);

                // 新增个人用户购买会员卡适用停车场记录
                TVipCardParkCustRel newVipCardParkCustRel = new TVipCardParkCustRel();
                newVipCardParkCustRel.setCustId(custId);
                newVipCardParkCustRel.setCustCardNo(custCardNo);
                newVipCardParkCustRel.setPlNo(parkCode);
                newVipCardParkCustRel.setCarNumber(carNumber);
                newVipCardParkCustRel.setPushState(0); // 推送状态 1:已推送 0:未推送
                newVipCardParkCustRel.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
                newVipCardParkCustRel.setCreateDate(curDate);
                newVipCardParkCustRel.setModifyDate(curDate);
                newVipCardParkCustRel.setCardBuyType(1); // 个人会员卡购买类型：1:购卡  2:续费
                vipCardParkCustRelDao.saveVipCardParkCustRel(newVipCardParkCustRel);
            }

            // 会员卡续费
            if (302 == orderType) {
                /*更新个人会员卡表*/
                TVipCardCustInfo tVipCardCustInfo = new TVipCardCustInfo();
                tVipCardCustInfo.setCustCardNo(custCardNo);
                tVipCardCustInfo.setEffDate(effDate);
                tVipCardCustInfo.setExpDate(expDate);
                tVipCardCustInfo.setCardRes(cardRes);
                tVipCardCustInfo.setPrice(price);
                tVipCardCustInfo.setNum(num);
                tVipCardCustInfo.setDiscountAmount(discountFee);
                tVipCardCustInfo.setTotalAmount(totalFee);
                tVipCardCustInfo.setModifyDate(curDate);
                vipCardCustInfoDao.updateVipCardCustInfoByCustCardNo(tVipCardCustInfo);

                // 新增订单会员卡, 订单会员卡详情
                OrderVipcardAndDetailRequest newOrderVipcardAndDetailReq = new OrderVipcardAndDetailRequest();
                newOrderVipcardAndDetailReq.setSysCode(sysCode);
                newOrderVipcardAndDetailReq.setPersonCardNo(custCardNo);
                newOrderVipcardAndDetailReq.setOrderType(orderType);
                newOrderVipcardAndDetailReq.setBuyNum(num);
                newOrderVipcardAndDetailReq.setPrice(price);
                newOrderVipcardAndDetailReq.setCardActAmount(actFee);
                newOrderVipcardAndDetailReq.setOrderDicountFee(discountFee);
                newOrderVipcardAndDetailReq.setOrderTotalFee(totalFee);
                newOrderVipcardAndDetailReq.setPersonCustId(custId);
                newOrderVipcardAndDetailReq.setEffDate(effDate);
                newOrderVipcardAndDetailReq.setExpDate(expDate);
                newOrderVipcardAndDetailReq.setPlNo(parkCode);
                newOrderVipcardAndDetailReq.setVipCardNo(cardNo);
                newOrderVipcardAndDetailReq.setCarNumber(carNumber);
                newOrderVipcardAndDetailReq.setCardType(cardType);
                BizResult<String> bizRltOrderId = vipCardOrderOperService.syncDataNewVipCardAndDetailRecord(
                    newOrderVipcardAndDetailReq);

                // 新增支付订单
                NewPayOrderRecordRequest newPayOrderRecordRe = new NewPayOrderRecordRequest();
                newPayOrderRecordRe.setSysCode(sysCode);
                newPayOrderRecordRe.setRltOrderId(bizRltOrderId.getData());
                newPayOrderRecordRe.setPayType(null == payType ? 33 : payType);
                newPayOrderRecordRe.setOrderBigType(OrderBigTypeEnum.VIP_ORDER.value());
                newPayOrderRecordRe.setPayOrderType(orderType);
                newPayOrderRecordRe.setTerminalSource(TerminalSourceEnum.DZ.value());
                newPayOrderRecordRe.setPayFinishTime(curDate);
                newPayOrderRecordRe.setPayOrderState(OrderStateEnum.COMPLETED.value());
                newPayOrderRecordRe.setPlNo(parkCode);
                newPayOrderRecordRe.setAppId(appId);
                newPayOrderRecordRe.setOrderDicountFee(discountFee);
                newPayOrderRecordRe.setOrderActFee(actFee);
                newPayOrderRecordRe.setOrderTotalFee(totalFee);
                newPayOrderRecordRe.setCreateDate(curDate);
                newPayOrderRecordRe.setModfiyDate(curDate);
                newPayOrderRecordRe.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
                vipCardOrderOperService.synDataNewPayOrderRecord(newPayOrderRecordRe);
            }

            successCardIdList.add(custCardNo);
        }
        logger.info("SyncVipCardData 已同步会员卡id列表：" + JSON.toJSONString(successCardIdList, false));
        return new BizResult<List<String>>(successCardIdList);
    }

    @Override
    public BizResult<List<TVipCardLogsDTO>> queryVipCardLogsList(TVipCardLogsRequest request) {
        List<TVipCardLogsDTO> dtoList = new ArrayList<>();
        List<TVipCardLogs> tVipCardLogsList = tVipCardLogsDao.queryVipCardLogsList(request);
        if (CollectionUtils.isNotEmpty(tVipCardLogsList)) {
            for (TVipCardLogs tVipCardLogs : tVipCardLogsList) {
                TVipCardLogsDTO tVipCardLogsDTO = new TVipCardLogsDTO();
                BeanUtils.copyProperties(tVipCardLogs, tVipCardLogsDTO);
                dtoList.add(tVipCardLogsDTO);
            }
        }
        return new BizResult<>(dtoList);
    }

    @Override
    public BizResult<List<String>> queryCustCardNosByCustCardNo(QueryVipCardCustInfoByCustIdRequest request) {

        List<String> custCardNos = new ArrayList<>();
        custCardNos = this.getCustCardNos(request, custCardNos);
        return new BizResult<>(custCardNos);
    }

    @Override
    public BizResult<Boolean> vipCardPayByCustCardNo(VipCardPayByCustCardNoRequest request) {
        //判断个人卡券是否存在
        QueryVipCardCustInfoByCustIdRequest queryvipcardRequest = new QueryVipCardCustInfoByCustIdRequest();
        queryvipcardRequest.setCustCardNo(request.getCustCardNo());
        List<TVipCardCustInfo> vipCardCustInfos = vipCardCustInfoDao.queryVipCardCustInfoByCustId(queryvipcardRequest);
        if (CollectionUtils.isEmpty(vipCardCustInfos)) {
            throw new BizException(ErrorType.NOT_FOUND_VIP_CARD);
        }
        TVipCardCustInfo vipCardCustInfo = vipCardCustInfos.get(0);
        //判断是否有效
        Date now = new Date();
        if (vipCardCustInfo.getEffDate().after(now) || vipCardCustInfo.getExpDate().before(now)) {
            throw new BizException(ErrorType.NOT_FOUND_VIP_CARD);
        }
        //判断是否余额充足
        if ((vipCardCustInfo.getTotalAmount() - vipCardCustInfo.getDiscountAmount() < request.getActTotalFee())) {
            throw new BizException(ErrorType.VIP_CARD_NO_MONEY);
        }
        //扣减支付金额，即将该支付金额累加到优惠金额上，目前先这么干
        TVipCardCustInfo vipcardinfo = new TVipCardCustInfo();
        vipcardinfo.setId(vipCardCustInfo.getId());
        vipcardinfo.setDiscountAmount(vipCardCustInfo.getDiscountAmount() + request.getActTotalFee());
        vipcardinfo.setModifyDate(new Date());
        vipCardCustInfoDao.updateVipCardCustInfoById(vipcardinfo);
        return new BizResult<>(true);
    }

    /**
     * 通过个人卡编码查询个人会员卡信息
     *
     * @param req
     * @return
     */
    @Override
    public BizResult<VipCardCustInfoDTO> queryCardCustInfoBycustCardNo(QueryCardCustInfoBycustCardNoReq req) {
        VipCardCustInfoDTO vipCardCustInfoDTO = new VipCardCustInfoDTO();
        TVipCardCustInfo tVipCardCustInfo = vipCardCustInfoDao.queryCardCustInfoBycustCardNo(req.getCustCardNo());
        if (null != tVipCardCustInfo) {
            BeanUtils.copyProperties(tVipCardCustInfo, vipCardCustInfoDTO);
        }
        return new BizResult<VipCardCustInfoDTO>(vipCardCustInfoDTO);
    }

    /**
     * 通过失效时间查询会员卡信息
     *
     * @param request
     * @return 2019-10-10 wangfs
     */
    @Override
    public BizResult<List<VipCardExpireWarnPushDTO>> queryVipCardByExpireDate(VipCardExpireWarnPushRequest request) {
        List<VipCardExpireWarnPushDTO> list = vipCardCustInfoDao.queryVipCardByExpireDate(request.getBeginTime(),
            request.getEndTime());
        return new BizResult<List<VipCardExpireWarnPushDTO>>(list);
    }

    /**
     * 根据停车场编号与车牌号码查询当前有效的会员车信息
     *
     * @param request
     * @return
     * @author: zegnqc
     */
    /**
     * 根据停车场编号与车牌号码查询当前有效的会员车信息
     *
     * @return
     * @author: zegnqc
     */
    @Override
    public BizResult<VipCardCustInfoDTO> queryCardCustInfoByParkcodeAndCarnumber(VipCardInfoReq request) {
        TVipCardCustInfo entity = vipCardCustInfoDao.queryCardCustInfoByParkcodeAndCarnumber(request);
        if (entity == null) {
            return new BizResult<>();
        }
        VipCardCustInfoDTO dto = new VipCardCustInfoDTO();

        BeanUtils.copyProperties(entity, dto);
        return new BizResult<>(dto);
    }

    /**
     * 据停车场编号与车牌号码查询该车所有有效的会员卡记录,包括已过期数据
     *
     * @author zegnqc
     */
    @Override
    public BizResult<List<VipCardCustInfoDTO>> queryAllCardCustInfoByParkcodeAndCarnumber(VipCardInfoReq request) {
        List<VipCardCustInfoDTO> list = vipCardCustInfoDao.queryAllCardCustInfoByParkcodeAndCarnumber(request.getPlNo(),
            request.getCarNumber());
        return new BizResult<>(list);
    }

    @Override
    public BizResult<VipCardCustInfoDTO> queryVipCardCustInfoByCardNoAndCarNumber(VipCardCustInfoReq req) {

        VipCardCustInfoDTO vipCardCustInfoDTO = vipCardCustInfoDao.queryVipCardCustInfoByCardNoAndCarNumber(
            req.getCardNo(), req.getCarNumber());
        return new BizResult<>(vipCardCustInfoDTO);

    }

    /**
     * 递归查询个人会员卡编码
     */
    public List<String> getCustCardNos(QueryVipCardCustInfoByCustIdRequest request, List<String> custCardNos) {
        List<TVipCardCustInfo> tVipCardCustInfos = vipCardCustInfoDao.queryVipCardCustInfoByCustId(request);
        if (CollectionUtils.isNotEmpty(tVipCardCustInfos)) {
            String custCardNo = tVipCardCustInfos.get(0).getCustCardNo();
            custCardNos.add(custCardNo);
            if (StringUtils.isNotEmpty(tVipCardCustInfos.get(0).getParentCustCardNo())) {
                request.setCustCardNo(tVipCardCustInfos.get(0).getParentCustCardNo());
                return getCustCardNos(request, custCardNos);
            } else {
                return custCardNos;
            }
        } else {
            return custCardNos;
        }
    }

    @Override
    public BizResult<List<VipCardCustInfoDTO>> queryAllCardCustInfoByCardNoAndCarnumber(VipCardInfoReq request) {
        List<VipCardCustInfoDTO> list = vipCardCustInfoDao.queryAllCardCustInfoByCardNoAndCarnumber(request.getCardNo(),
                request.getCarNumber());
        return new BizResult<>(list);
    }

    @Override
    public BizResult<CheckVipCarBuyNumDTO> checkVipCarBuyNum(CheckVipCarBuyNumReq req) {
        CheckVipCarBuyNumDTO checkVipCarBuyNumDTO = new CheckVipCarBuyNumDTO();
        List<VipCardInfoBuyNumDTO> buyNumList = new ArrayList<>();
        logger.debug("begin校验会员卡购买数量限制,入参={}", JSONObject.toJSON(req));
        if (req == null || StringUtils.isBlank(req.getCardNo()) || null == req.getStartTime() || null == req.getEndTime()) {
            logger.debug("入参为空");
            throw new BizException(ErrorType.PARAMM_NULL, "入参为空!");
        }
        /**1.查询卡规则数量*/
        TVipCard tVipCard = vipCardDao.queryVipCardByOnlyCardNo(req.getCardNo());
        logger.debug("卡规则数量为={}", JSONObject.toJSON(tVipCard));
        if (null == tVipCard || null == tVipCard.getValidNum() || tVipCard.getValidNum().equals(0)) {
            checkVipCarBuyNumDTO.setCarRulsLimitNum(0); //不限制
            checkVipCarBuyNumDTO.setBuyNumList(buyNumList);
            return new BizResult<CheckVipCarBuyNumDTO>(checkVipCarBuyNumDTO);
        }
        checkVipCarBuyNumDTO.setCarRulsLimitNum(tVipCard.getValidNum());

        /** 2.将开始结束时间拆分成月份、分别查询购买数量*/
        SimpleDateFormat timeformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        long timeDifference = DateUtil.between(req.getEndTime(), req.getStartTime(), DateUnit.WEEK) / 4;
        logger.debug("本次查询日期相差月份为=" + timeDifference);
        Date beginTime = null;
        Date endTime = null;
        try {
            for (int i = 0; i <= timeDifference; i++) {
                beginTime = DateUtil.beginOfMonth(DateUtil.offsetMonth(req.getStartTime(), i));
                endTime = DateUtil.endOfMonth(DateUtil.offsetMonth(req.getStartTime(), i));
                logger.debug("开始时间={},结束时间={}", timeformat.format(beginTime), timeformat.format(endTime));
                VipCardInfoBuyNumDTO vipCardInfoBuyNumDTO;
                /*跨度第一个月开始日期取用户的选择日期，后面的月份取当月第一天*/
                /*跨度最后一个月结束日期取到期日期，其它取月末*/
                if (i == 0) {
                    vipCardInfoBuyNumDTO = vipCardCustInfoDao.checkVipCarBuyNum(req.getCardNo(), req.getStartTime(), endTime);
                } else if (i == timeDifference) {
                    vipCardInfoBuyNumDTO = vipCardCustInfoDao.checkVipCarBuyNum(req.getCardNo(), beginTime, req.getEndTime());
                } else {
                    vipCardInfoBuyNumDTO = vipCardCustInfoDao.checkVipCarBuyNum(req.getCardNo(), beginTime, endTime);
                }
                if (null != vipCardInfoBuyNumDTO) {
                    vipCardInfoBuyNumDTO.setShowDate(DateUtil.format(DateUtil.offsetMonth(req.getStartTime(), i), "M"));
                    buyNumList.add(vipCardInfoBuyNumDTO);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

//        /**3.校验list*/
//        if (CollectionUtils.isNotEmpty(buyNumListDO)) {
//            buyNumListDO.forEach(a -> {
//                if (null != a.getAlreadyBuyNum() && a.getAlreadyBuyNum() > 0 && a.getAlreadyBuyNum() >= checkVipCarBuyNumDTO.getCarRulsLimitNum()) {
//                    buyNumList.add(a);
//                }
//            });
//        }
        checkVipCarBuyNumDTO.setBuyNumList(buyNumList);

        logger.debug("end校验会员卡购买数量限制....");
        return new BizResult<CheckVipCarBuyNumDTO>(checkVipCarBuyNumDTO);
    }


    /**
     * 检查某个停车场某种会员卡剩余的数量
     * 剩余数量 = 总数-正在生效数量-将要生效的数量
     * @req
     * @return
     */
    @Override
    public BizResult<List<String>> queryAllActiveCarNumberInfo(VipCardInfoReq request) {
        List<String> carNumberList = new ArrayList<>();
        List<TVipCardCustInfo> list = vipCardCustInfoDao.queryAllActiveInfo(request);
        list.forEach(entity -> carNumberList.add(entity.getCarNumber()));

        return new BizResult<>(carNumberList);
    }

    @Override
    public BizResult<Long> checkRemainingVipCardNumByCardNo(CheckVipCarBuyNumReq req){

        // 1.查询卡规则数量
        TVipCard tVipCard = vipCardDao.queryVipCardByOnlyCardNo(req.getCardNo());
        logger.info("卡规则数量为={}", JSONObject.toJSON(tVipCard));
        if(null == tVipCard || null == tVipCard.getValidNum()){
            return new BizResult<>(ErrorType.NOT_VIP_CARD,"该会员卡不存在");
        }
        // 2.查询正在生效和将要生效会员卡数量
        long validNum = vipCardCustInfoDao.queryValidCardNum(req.getCardNo());
        // 3.剩余会员卡数量
        long remainingNum = tVipCard.getValidNum() - validNum;
        return new BizResult<>(remainingNum < 0 ? 0: remainingNum );
    }

    /**
     * 某个车牌号码和会员卡卡号查询正在生效或者将要生效的某个会员卡
     * @param req
     * @return
     */
    @Override
    public BizResult<List<VipCardCustInfoDTO>> queryVipCardInEffectByCardNoAndCarNum(AppPayCardOrderRequest req) {
        List<TVipCardCustInfo> list = vipCardCustInfoDao.queryVipCardInEffectByCardNoAndCarNum(req.getCardNo(), req.getCarNumber());
        List<VipCardCustInfoDTO> dtoList = list.stream().map(item -> {
            VipCardCustInfoDTO dto = new VipCardCustInfoDTO();
            BeanUtils.copyProperties(item, dto);
            return dto;
        }).collect(Collectors.toList());
        return new BizResult<>(dtoList);
    }

    /**
     * 查询购买停车场集合
     * @param req
     * @return
     */
    @Override
    public BizResult<List<String>> queryVipPlNosByCustCardNo(QueryCardCustInfoBycustCardNoReq req) {
        List<String> strings = vipCardParkCustRelDao.queryVipPlNosByCustCardNo(req.getCustCardNo());
        return new BizResult<List<String>>(strings);
    }


}