BJ_ZTEITS-Developers / parking-cloud

package com.zteits.pay.biz;

import cn.hutool.core.collection.CollectionUtil;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.dypnsapi.model.v20170525.GetMobileRequest;
import com.aliyuncs.dypnsapi.model.v20170525.GetMobileResponse;
import com.aliyuncs.profile.DefaultProfile;
import com.clouds.common.cache.sys.SysCodeValueCacheUtil;
import com.clouds.common.constants.CodeValKindEnum;
import com.clouds.common.utils.ListCopyUtil;
import com.clouds.common.utils.SequenceUtil;
import com.github.pagehelper.PageInfo;
import com.google.gson.Gson;
import com.xiaoleilu.hutool.date.DateUtil;
import com.zteits.clouds.api.apibase.bean.BizResult;
import com.zteits.clouds.api.apibase.bean.PageBean;
import com.zteits.clouds.api.apibase.constants.DataStatusEnum;
import com.zteits.clouds.api.apibase.constants.ErrorType;
import com.zteits.clouds.api.apibase.constants.SequenceTypeEnum;
import com.zteits.clouds.api.dto.park.param.SwitchETCstateRequest;
import com.zteits.clouds.api.dto.pay.TdCCarDTO;
import com.zteits.clouds.api.dto.pay.TdCCustPersonDTO;
import com.zteits.clouds.api.dto.pay.custperson.CustPersonStatisticDTO;
import com.zteits.clouds.api.dto.pay.custperson.CustPersonStatisticForHourDTO;
import com.zteits.clouds.api.dto.pay.custperson.CustPersonStatisticForWeekDTO;
import com.zteits.clouds.api.dto.pay.dto.RegisterPresentDTO;
import com.zteits.clouds.api.dto.pay.param.*;
import com.zteits.clouds.api.service.pay.TdCCustPersonService;
import com.zteits.pay.dao.*;
import com.zteits.pay.dao.impl.TdCCouponRuleCustidCarnumRelDaoImpl;
import com.zteits.pay.domain.*;
import com.zteits.pay.pagepager.PageBeanUtil;
import com.zteits.pay.service.presentrule.oper.TdCPresentRuleOperInnerService;
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.util.*;
import java.util.stream.Collectors;

@Service("com.zteits.pay.biz.TdCCustPersonServiceImpl")
public class TdCCustPersonServiceImpl implements TdCCustPersonService {
	private static final Logger logger = LoggerFactory.getLogger(TdCCustPersonServiceImpl.class);
	@Autowired
	private TdCCustPersonDao tdCCustPersonDao;
	@Autowired
	private TdCPresentRuleOperInnerService tdCPresentRuleOperInnerService;
	@Autowired
	private TdCCarDao tdCCarDao;
	@Autowired
	private TdCCustUseDayDao tdCCustUseDayDao;

	@Autowired
	private TdCCustPersonChangeOrgDao tdCCustPersonChangeOrgDao;
	@Autowired
	private TdCCouponRuleDao tdCCouponRuleDao;
	@Autowired
	private TdCCouponRuleCustidCarnumRelDaoImpl tdCCouponRuleCustidCarnumRelDaoImpl;
//	@Autowired
//	private Client client;


	@Override
	public BizResult<PageBean<TdCCustPersonDTO>> queryPersonForPage(TdCCustPersonRequest request) {
		PageInfo<TdCCustPersonDTO> pageInfo = tdCCustPersonDao.queryPersonForPage(request);
		PageBean<TdCCustPersonDTO> pageBean = new PageBean<>();
		PageBeanUtil.copyProperties(pageInfo, pageBean, TdCCustPersonDTO.class);
		if(CollectionUtils.isNotEmpty(pageBean.getDataList())) {
			List<String> custIds = pageBean.getDataList().stream().map(item->item.getCustId()).collect(Collectors.toList());
			/**查询车牌号信息*/
			List<TdCCarDTO> carlistdto = new ArrayList<>();
			List<TdCCar> carlist = tdCCarDao.selectCustInfoBycustIds(custIds);
			if (CollectionUtils.isNotEmpty(carlist)) {
				for (TdCCar car : carlist) {
					TdCCarDTO tdCCarDTO = new TdCCarDTO();
					BeanUtils.copyProperties(car, tdCCarDTO);
					carlistdto.add(tdCCarDTO);
				}
			}
			Map<String, List<TdCCarDTO>> aMap = new HashMap<>();
			aMap = carlistdto.stream().collect(Collectors.groupingBy(TdCCarDTO::getCustId));
			for(TdCCustPersonDTO dto : pageBean.getDataList()){
				dto.setCarDtolist(aMap.get(dto.getCustId()));
			}
		}
		return new BizResult<>(pageBean);
	}

	@Override
	public BizResult<TdCCustPersonDTO> selectByUserPhone(TdCCustPersonRequest request) {
		TdCCustPersonDTO dto  = new TdCCustPersonDTO();
		TdCCustPerson person = tdCCustPersonDao.selectByUserPhone(request.getUserPhone());
		if(person!=null){
			BeanUtils.copyProperties(person, dto);
		}
		return new BizResult<TdCCustPersonDTO>(dto);
	}

	@Override
	public BizResult<String> selectByOperatorToken(TdCCustOperatorRequest request){

		//从缓存字典获取keyid+keysecret
		Map<String,String> map = SysCodeValueCacheUtil.queryCodeValueAndNames(CodeValKindEnum.APP_ACCESSKEY_INFO);
		String accessKeyId = map.get("ACCESS_KEY_ID");
		String accessKeySecret = map.get("ACCESS_KEY_SECRET");
		String endpoint = map.get("ACCESS_ENDPOINT");
		logger.info("从APP_ACCESSKEY_INFO缓存获取：endpoint："+ endpoint);

		DefaultProfile profile = DefaultProfile.getProfile("cn-qingdao", accessKeyId, accessKeySecret);
		IAcsClient client = new DefaultAcsClient(profile);

		GetMobileRequest getMobileRequest = new GetMobileRequest();
		getMobileRequest.setAccessToken(request.getOperatorToken());
		String mobile ="";
		try {
			GetMobileResponse response = client.getAcsResponse(getMobileRequest);
			logger.info("调用阿里接口返回手机号码：" + new Gson().toJson(response));
			mobile = response.getGetMobileResultDTO().getMobile();
		} catch (Exception e) {
			e.printStackTrace();
			logger.error("调用查询手机号接口异常,{}",e.getMessage());
			return null;
		}
		//202302因jar包冲突，替换为1.0版本，原2.0版本代码注释
//		String mobile ="";
//		Config config = new Config()
//				// 您的AccessKey ID
//				.setAccessKeyId(accessKeyId)
//				// 您的AccessKey Secret
//				.setAccessKeySecret(accessKeySecret);
//
//		// 访问的域名
////		config.endpoint = "dypnsapi.aliyuncs.com";
//		config.endpoint = endpoint;
//
//		GetMobileRequest getMobileRequest = new GetMobileRequest();
//		getMobileRequest.setAccessToken(request.getOperatorToken());
//		try {
//			Client client = new Client(config);
//			GetMobileResponse resp = client.getMobile(getMobileRequest);
//			logger.info("调用运营商接口返回：："+ JSONObject.toJSONString(resp));
//
//			mobile = resp.getBody().getGetMobileResultDTO().getMobile();
//		} catch (Exception e) {
//			e.printStackTrace();
//			logger.error("调用查询手机号接口异常,{}",e.getMessage());
//			return null;
//		}

		return new BizResult<String>(mobile);
	}

	@Override
	public BizResult<List<RegisterPresentDTO>> insertSelective(TdCCustPersonRequest request) {
		TdCCustPerson person = new TdCCustPerson();
		BeanUtils.copyProperties(request, person);
		List<RegisterPresentDTO> registerPresentDTOS;
		if(StringUtils.isEmpty(request.getCustId())) {
			String custId = SequenceUtil.getNextId(SequenceTypeEnum.CUST_PERSION_SQE);
			person.setCustId(custId);
		}else{
			person.setCustId(request.getCustId());
		}
		person.setUserPhone(request.getUserPhone());
		person.setCustType(1);
		person.setSex(3);
	    person.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
	    person.setPettyPayAmount(0);
	    person.setCreateDate(new Date());
	    person.setModfiyDate(new Date());
	    person.setCustNickname(request.getCustNickname());
		int i  = tdCCustPersonDao.insertSelective(person);

		registerPresentDTOS = tdCPresentRuleOperInnerService.presentForRegister(person);

		return new BizResult<List<RegisterPresentDTO>>(registerPresentDTOS);
	}

	@Override
	public BizResult<Integer> updateByUserPhone(TdCCustPersonRequest request) {
		TdCCustPerson person = new TdCCustPerson();
		BeanUtils.copyProperties(request, person);
		person.setModfiyDate(new Date());
		int i  = tdCCustPersonDao.updateByUserPhone(person);
		/**将用户的今天的操作信息插入到数据库(每天插入一条信息)**/
		TdCCustPerson tdCCustPerson = tdCCustPersonDao.selectByUserPhone(person.getUserPhone());
		TdCCustUseDay record = new TdCCustUseDay();
		BeanUtils.copyProperties(tdCCustPerson,record);
		int flg = tdCCustUseDayDao.selectCustUseDayByUserPhone(record);
		if(flg == 0){
			tdCCustUseDayDao.saveCustUseDay(record);
		}
		return new BizResult<>(i);
	}

	@Override
	public BizResult<Integer> openPettyPayment(PettyPaymentRequest request) {
		TdCCustPerson person = new TdCCustPerson();
		BeanUtils.copyProperties(request, person);
		int i  = tdCCustPersonDao.updateByUserPhone(person);
		return new BizResult<Integer>(i);
	}

	@Override
	public BizResult<Integer> resetPettyPayPass(PettyPaymentRequest request) {
		TdCCustPerson person = new TdCCustPerson();
		BeanUtils.copyProperties(request,person);
		int i  = tdCCustPersonDao.updateByUserPhone(person);
		return new BizResult<Integer>(i);
	}

	@Override
	public BizResult<Integer> openMsgPush(MsgPushRequest request) {
		TdCCustPerson person = new TdCCustPerson();
		BeanUtils.copyProperties(request,person);
		int i  = tdCCustPersonDao.updateByUserPhone(person);
		return new BizResult<Integer>(i);
	}

	@Override
	public BizResult<String> saveCustPerson(SaveCustPersonRequest request) {
		TdCCustPerson person = new TdCCustPerson();
		BeanUtils.copyProperties(request, person);
		person.setUserPhone(request.getUserPhone());
		person.setCustId(SequenceUtil.getNextId(SequenceTypeEnum.CUST_PERSION_SQE));
		person.setCustType(1);
		person.setSex(3);
	    person.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
	    person.setPettyPayAmount(0);
	    person.setCreateDate(new Date());
	    person.setModfiyDate(new Date());
		int i  = tdCCustPersonDao.insertSelective(person);
		return new BizResult<String>(i > 0 ? person.getCustId() : "");
	}

	@Override
	public BizResult<Integer> updateByCustId(TdCCustPersonByCustIdRequest request) {
		TdCCustPerson person = new TdCCustPerson();
		BeanUtils.copyProperties(request, person);
		person.setModfiyDate(new Date());
		int a= tdCCustPersonDao.updateByCustId(person);
		return new BizResult<Integer>(a);
	}

	@Override
	public BizResult<TdCCustPersonDTO> queryPersonByCustId(TdCCustPersonByCustIdRequest request) {
		TdCCustPersonDTO dto  = new TdCCustPersonDTO();
		TdCCustPerson person = tdCCustPersonDao.queryPersonByCustId(request.getCustId());
		if(person!=null){
			BeanUtils.copyProperties(person, dto);
		}
		return new BizResult<TdCCustPersonDTO>(dto);
	}

	@Override
	public BizResult<Integer> updateCustPersonBaseInfoByCustId(TdCCustPersonByCustIdRequest request) {
		TdCCustPerson person = new TdCCustPerson();
		BeanUtils.copyProperties(request, person);
		int a= tdCCustPersonDao.updateCustPersonBaseInfoByCustId(person);
		return new BizResult<Integer>(a);
	}
	@Override
	public BizResult<List<TdCCustPersonDTO>> queryPersonByCustIds(TdCCustPersonByCustIdRequest request) {
		List<TdCCustPersonDTO> result = new ArrayList<>();
		List<TdCCustPerson> list = new ArrayList<>();
		list = tdCCustPersonDao.queryPersonByCustIds(request.getCustIds());
		if(CollectionUtils.isNotEmpty(list)){
			ListCopyUtil.listCopyProperties(list, result, TdCCustPersonDTO.class);
		}
		return new BizResult<>(result);
	}

	@Override
	public BizResult<CustPersonStatisticDTO> queryUserPersonStatistic(TdCCustPersonQueryStatisticRequest request) {
		CustPersonStatisticDTO custPersonStatisticDTO = tdCCustPersonDao.queryUserPersonStatistic(request);
		return new BizResult<>(custPersonStatisticDTO);
	}

	@Override
	public BizResult<List<CustPersonStatisticForHourDTO>> queryUserPersonStatisticForHour(TdCCustPersonQueryStatisticRequest request) {
		List<CustPersonStatisticForHourDTO> custPersonStatisticForHourDTOs = tdCCustPersonDao.queryUserPersonStatisticForHour(request);
		List<CustPersonStatisticForHourDTO> custPersonStatisticForHourDTOsR = new ArrayList<>();
		//查询一天的数据-按小时统计
		for(int i=0;i<=23;i++){
			CustPersonStatisticForHourDTO custPersonStatisticForHourDTO = new CustPersonStatisticForHourDTO();
			custPersonStatisticForHourDTO.setHour(i);
			custPersonStatisticForHourDTO.setNum(0);
			custPersonStatisticForHourDTOsR.add(custPersonStatisticForHourDTO);
		}
		if(CollectionUtils.isNotEmpty(custPersonStatisticForHourDTOs)) {
			for (CustPersonStatisticForHourDTO dtoQ : custPersonStatisticForHourDTOsR) {
				for (CustPersonStatisticForHourDTO dto : custPersonStatisticForHourDTOs) {
					if (dtoQ.getHour().equals(dto.getHour())) {
						dtoQ.setNum(dto.getNum());
					}
				}
			}
		}
		return new BizResult<>(custPersonStatisticForHourDTOsR);
	}

	@Override
	public BizResult<List<CustPersonStatisticForWeekDTO>> queryUserPersonStatisticForWeek(TdCCustPersonQueryStatisticRequest request) {
		List<CustPersonStatisticForWeekDTO> statisticForWeek = tdCCustPersonDao.queryUserPersonStatisticForWeek(request);
		List<CustPersonStatisticForWeekDTO> statisticForWeekDTOs = new ArrayList<>();
		Long dayNum = DateUtil.betweenDay(request.getEndTime(),request.getStartTime(),true);
		//查询一天的数据-按小时统计
		for(int i=0;i<=dayNum;i++){
			CustPersonStatisticForWeekDTO statisticForWeekDTO = new CustPersonStatisticForWeekDTO();
			statisticForWeekDTO.setCreateDate(DateUtil.format(DateUtil.offsetDay(request.getStartTime(),i),DateUtil.NORM_DATE_PATTERN));
			statisticForWeekDTO.setNum(0);
			statisticForWeekDTOs.add(statisticForWeekDTO);
		}
		if(CollectionUtils.isNotEmpty(statisticForWeek)) {
			for (CustPersonStatisticForWeekDTO dtoQ : statisticForWeekDTOs) {
				for (CustPersonStatisticForWeekDTO dto : statisticForWeek) {
					if (dtoQ.getCreateDate().equals(dto.getCreateDate())) {
						dtoQ.setNum(dto.getNum());
					}
				}
			}
		}
		return new BizResult<>(statisticForWeekDTOs);


	}

	@Override
	public BizResult<Integer> updateUserChangeOrgId(TdCCustPersonByCustIdRequest requestQ) {

		/**1.先查询数据库存的跟要修改的是否相同*/
		TdCCustPerson person = tdCCustPersonDao.queryPersonByCustId(requestQ.getCustId());
		if(person!=null&&!requestQ.getOrgId().equals(person.getOrgId())) {
			BeanUtils.copyProperties(requestQ, person);
			int a = tdCCustPersonDao.updateByCustId(person);
			/**插入用户变更记录*/
			TdCCustPersonChangeOrg changeOrg = new TdCCustPersonChangeOrg();
			changeOrg.setCustId(requestQ.getCustId());
			changeOrg.setOrgId(requestQ.getOrgId());
			changeOrg.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
			changeOrg.setCreateEmpid(requestQ.getCustId());
			changeOrg.setCreateDate(new Date());
			tdCCustPersonChangeOrgDao.insertSelective(changeOrg);
		}
//		/**1.先查询数据库存的跟要修改的是否相同*/
//		TdCCustPerson person = tdCCustPersonDao.queryPersonByCustId(requestQ.getCustId());
//		/**归属地不在进行变更,只能变更一次**/
//		if(person!=null && person.getOrgId() != null){
//			/**插入用户变更记录*/
//			TdCCustPersonChangeOrg changeOrg = new TdCCustPersonChangeOrg();
//			changeOrg.setCustId(requestQ.getCustId());
//			changeOrg.setOrgId(requestQ.getOrgId());
//			changeOrg.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
//			changeOrg.setCreateEmpid(requestQ.getCustId());
//			changeOrg.setCreateDate(new Date());
//			tdCCustPersonChangeOrgDao.insertSelective(changeOrg);
//		}
//		if(person!=null && person.getOrgId() == null ) {
//			BeanUtils.copyProperties(requestQ, person);
//			int a = tdCCustPersonDao.updateByCustId(person);
//			/**插入用户变更记录*/
//			TdCCustPersonChangeOrg changeOrg = new TdCCustPersonChangeOrg();
//			changeOrg.setCustId(requestQ.getCustId());
//			changeOrg.setOrgId(requestQ.getOrgId());
//			changeOrg.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
//			changeOrg.setCreateEmpid(requestQ.getCustId());
//			changeOrg.setCreateDate(new Date());
//			tdCCustPersonChangeOrgDao.insertSelective(changeOrg);
//		}
		return new BizResult<>(1);
	}

	/**
	 * 通过手机号查询个人客户信息
	 * @param
	 * @return
	 * @Author: wangfs
	 * @Date: 2019/11/22 12:04
	 *
	 */
	@Override
	public BizResult<PageBean<TdCCustPersonDTO>> queryPersonForPageByUserPhone(QueryPersonForPageByUserPhoneQReq request) {
		PageBean<TdCCustPersonDTO> pageBean = new PageBean<TdCCustPersonDTO>();
		PageInfo<TdCCustPerson> pageInfo = tdCCustPersonDao.queryPersonForPageByUserPhone(request);
		PageBeanUtil.copyProperties(pageInfo,pageBean,TdCCustPersonDTO.class);
		return new BizResult<PageBean<TdCCustPersonDTO>>(pageBean);
	}

    @Override
    public BizResult<PageBean<TdCCustPersonDTO>> queryPersonAndCarNumForPageByUserPhone(QueryPersonForPageByUserPhoneQReq request) {
        // 查询分页用户信息
        PageBean<TdCCustPersonDTO> pageBean = new PageBean<TdCCustPersonDTO>();
        PageInfo<TdCCustPerson> pageInfo = tdCCustPersonDao.queryPersonForPageByUserPhone(request);
        PageBeanUtil.copyProperties(pageInfo, pageBean, TdCCustPersonDTO.class);
        // 查询优惠券编号-客户编号-车牌号码 关系表
        List<TdCCouponRuleCustidCarnumRel> relList = tdCCouponRuleCustidCarnumRelDaoImpl.getListByCardNo(request.getCardNo());
        // 车牌号码关联分页数据
        if (CollectionUtil.isNotEmpty(relList)) {
            List<TdCCustPersonDTO> dataList = pageBean.getDataList();
            for (TdCCustPersonDTO tdCCustPersonDTO : dataList) {
                for (TdCCouponRuleCustidCarnumRel tdCCouponRuleCustidCarnumRel : relList) {
                    if (tdCCustPersonDTO.getCustId().equals(tdCCouponRuleCustidCarnumRel.getCustId())) {
                        tdCCustPersonDTO.setCarNum(tdCCouponRuleCustidCarnumRel.getCarNum());
                    }
                }
            }
        }
        return new BizResult<PageBean<TdCCustPersonDTO>>(pageBean);
    }

    @Transactional(rollbackFor = Exception.class)
    public BizResult<Boolean> saveCardNoAndCustIdAndCarNum(CouponRuleCustidCarnumRelRequest request) {
        TdCCouponRuleCustidCarnumRel rel = new TdCCouponRuleCustidCarnumRel();
        BeanUtils.copyProperties(request, rel);
        List<TdCCouponRuleCustidCarnumRel> list = tdCCouponRuleCustidCarnumRelDaoImpl.getList(rel);
        List<Long> ids = Optional.ofNullable(list).orElse(null).stream().map(e -> e.getId()).collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(ids)) {
            tdCCouponRuleCustidCarnumRelDaoImpl.delTdCCouponRuleCustidCarnumRel(ids);
        }
        int i = tdCCouponRuleCustidCarnumRelDaoImpl.insertTdCCouponRuleCustidCarnumRel(rel);
        return new BizResult<>(i > 0);
    }

    @Override
    public BizResult<TdCCustPersonDTO> selectByCustId(TdCCustPersonRequest personRequest) {
        TdCCustPerson person = tdCCustPersonDao.selectByCustId(personRequest);
        if (person == null) {
            return null;
        }
        TdCCustPersonDTO dto = new TdCCustPersonDTO();
        BeanUtils.copyProperties(person, dto);
        return new BizResult<>(dto);
    }

	@Override
	public BizResult<Integer> switchETCstate(SwitchETCstateRequest request) {
		int i = tdCCustPersonDao.switchETCstate(request);
		return new BizResult<>(i);
	}

    @Override
    public BizResult<String> insertCustPerson(SaveCustPersonRequest request) {
        if (StringUtils.isEmpty(request.getUserPhone())) {
            return new BizResult<>(ErrorType.PARAMM_NULL, "手机号不能为空");
        }
        // 查询手机号是否注册过
        TdCCustPerson person = tdCCustPersonDao.selectByUserPhone(request.getUserPhone());
        if (person != null) {
			return new BizResult<>(ErrorType.CUST_INFO_HAS_EXISTS, "账户存在");
		}
		// 手机号不存在就插入
		TdCCustPerson newPerson = new TdCCustPerson();
        BeanUtils.copyProperties(request, newPerson);
		newPerson.setUserPhone(request.getUserPhone());
		newPerson.setCustId(SequenceUtil.getNextId(SequenceTypeEnum.CUST_PERSION_SQE));
		newPerson.setCustType(1);
		newPerson.setSex(3);
		newPerson.setDataState(DataStatusEnum.DATA_STATUS_VALID.value());
		newPerson.setPettyPayAmount(0);
		newPerson.setCreateDate(new Date());
		newPerson.setModfiyDate(new Date());
        int i = tdCCustPersonDao.insertSelective(newPerson);
        return new BizResult<>(i > 0 ? newPerson.getUserPhone() : "");
    }


}