productDev/parkBike.git

			@@ -1,9 +1,12 @@
			package com.doumee.service.business.impl;

			import com.alibaba.fastjson.JSON;
			import com.alibaba.fastjson.JSONObject;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
			import com.baomidou.mybatisplus.core.metadata.IPage;
			import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
			import com.doumee.core.annotation.excel.ExcelExporter;
			import com.doumee.core.constants.Constants;
			import com.doumee.biz.system.SystemDictDataBiz;
			import com.doumee.core.constants.Constants;
			@@ -17,35 +20,39 @@
			import com.doumee.core.utils.Utils;
			import com.doumee.core.wx.WxMiniConfig;
			import com.doumee.core.wx.WxMiniUtilService;
			import com.doumee.core.wx.WxPayProperties;
			import com.doumee.dao.business.*;
			import com.doumee.dao.business.MemberRidesMapper;
			import com.doumee.dao.business.join.GoodsorderJoinMapper;
			import com.doumee.dao.business.join.RefundJoinMapper;
			import com.doumee.dao.business.model.Bikes;
			import com.doumee.dao.business.model.Goodsorder;
			import com.doumee.dao.business.model.Member;
			import com.doumee.dao.business.model.MemberRides;
			import com.doumee.dao.business.vo.BikeIncomeDetailReportVO;
			import com.doumee.dao.business.vo.BikeIncomeReportVO;
			import com.doumee.dao.business.vo.GoodsorderExportVO;
			import com.doumee.dao.business.vo.GoodsorderTotalDataVO;
			import com.doumee.dao.business.web.request.BikeRepairDTO;
			import com.doumee.dao.business.web.request.GoodsorderCanBanlanceDTO;
			import com.doumee.dao.business.web.request.MemberRidesQuery;
			import com.doumee.dao.business.web.request.RefundDTO;
			import com.doumee.dao.business.web.request.*;
			import com.doumee.dao.business.web.response.*;
			import com.doumee.dao.business.join.MemberRidesJoinMapper;
			import com.doumee.dao.business.model.*;
			import com.doumee.dao.system.model.SystemUser;
			import com.doumee.service.business.GoodsorderService;
			import com.doumee.service.business.MemberRidesService;
			import com.doumee.service.business.PricingRuleService;
			import com.doumee.service.business.RefundService;
			import com.github.binarywang.wxpay.bean.notify.WxPayNotifyResponse;
			import com.github.binarywang.wxpay.bean.request.BaseWxPayRequest;
			import com.github.binarywang.wxpay.bean.request.WxPayUnifiedOrderRequest;
			import com.github.binarywang.wxpay.exception.WxPayException;
			import com.github.yulichang.wrapper.MPJLambdaWrapper;
			import com.wechat.pay.java.service.partnerpayments.jsapi.JsapiServiceExtension;
			import com.wechat.pay.java.service.partnerpayments.jsapi.model.*;
			import com.wechat.pay.java.service.refund.model.RefundNotification;
			import com.wechat.pay.java.service.refund.model.Status;
			import lombok.extern.slf4j.Slf4j;
			import org.apache.commons.lang3.StringUtils;
			import org.apache.shiro.SecurityUtils;
			import org.checkerframework.checker.units.qual.A;
			import org.checkerframework.checker.units.qual.C;
			import org.springframework.beans.BeanUtils;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.stereotype.Service;
			import org.springframework.transaction.annotation.Transactional;
			@@ -54,23 +61,35 @@
			import org.springframework.web.context.request.ServletRequestAttributes;

			import javax.servlet.http.HttpServletRequest;
			import javax.servlet.http.HttpServletResponse;
			import java.io.IOException;
			import java.math.BigDecimal;
			import java.net.InetAddress;
			import java.net.URLEncoder;
			import java.net.UnknownHostException;

			import java.nio.charset.Charset;
			import java.sql.Ref;
			import java.time.LocalTime;
			import java.time.format.DateTimeFormatter;
			import java.util.*;
			import java.util.stream.Collectors;
			import java.util.stream.Stream;

			@Service
			@Slf4j
			public class GoodsorderServiceImpl implements GoodsorderService {



			@Autowired
			private GoodsorderMapper goodsorderMapper;

			@Autowired
			private DiscountMemberMapper discountMemberMapper;

			@Autowired
			private DiscountLogMapper discountLogMapper;
			@Autowired
			private DiscountMapper discountMapper;

			@Autowired
			GoodsorderJoinMapper goodsorderJoinMapper;
			@@ -78,14 +97,20 @@
			@Autowired
			private SystemDictDataBiz systemDictDataBiz;

			@Autowired
			private BikesMapper bikesMapper;



			@Autowired
			private MemberMapper memberMapper;
			@Autowired
			private BaseParamMapper baseParamMapper;

			@Autowired
			private RefundMapper refundMapper;

			@Autowired
			private RefundJoinMapper refundJoinMapper;

			@Autowired
			private MemberRidesJoinMapper memberRidesJoinMapper;
			@@ -104,6 +129,10 @@

			@Autowired
			RefundService refundService;

			@Autowired
			private HolidaysMapper holidaysMapper;


			@Override
			public String create(Goodsorder goodsorder) {
			@@ -170,55 +199,124 @@
			public PageData<GoodsorderExportVO> findAccountDetailPage(PageWrap<Goodsorder> pageWrap) {
			IPage<Goodsorder> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
			pageWrap.getModel().setPayStatus(Constants.ONE); //只查询支付成功的
			MPJLambdaWrapper<Goodsorder> queryWrapper = initQueryParamByModel(pageWrap.getModel());
			IPage<GoodsorderExportVO> goodsorderExportVOIPage = goodsorderJoinMapper.selectJoinPage(page, GoodsorderExportVO.class, queryWrapper);
			Goodsorder model = pageWrap.getModel();
			Utils.MP.blankToNull(model);
			IPage<GoodsorderExportVO> goodsorderExportVOIPage = null;
			if (Constants.formatIntegerNum(model.getType())==Constants.ZERO){
			MPJLambdaWrapper<Goodsorder> queryWrapper = new MPJLambdaWrapper<>();
			queryWrapper.selectAll(Goodsorder.class);
			queryWrapper.selectAs(Member::getOpenid, Goodsorder::getOpenid);
			queryWrapper.selectAs(BaseParam::getType, Goodsorder::getBikeType);
			queryWrapper.leftJoin(Member.class, Member::getId ,Goodsorder::getMemberId);
			queryWrapper.leftJoin(BaseParam.class, BaseParam::getId ,Goodsorder::getParamId);
			queryWrapper.select("(select max(r.done_date) from refund r where r.obj_id=t.id and r.status=2 ) as refund_date");
			queryWrapper.select("(select sum(r.money) from refund r where r.obj_id=t.id and r.status=2) as refund_money");
			//时间段筛选
			if (Objects.nonNull(model.getStartDate())){
			queryWrapper.ge(Goodsorder::getPayDate, Utils.Date.getStart(model.getStartDate()));
			}
			if (Objects.nonNull(model.getEndDate())){
			queryWrapper.le( Goodsorder::getPayDate, Utils.Date.getEnd(model.getEndDate()));
			}
			queryWrapper.eq(Goodsorder::getIsdeleted,Constants.ZERO);
			queryWrapper.eq(Goodsorder::getPayStatus,Constants.ONE);
			queryWrapper.orderByAsc(Goodsorder::getPayDate);
			goodsorderExportVOIPage = goodsorderJoinMapper.selectJoinPage(page, GoodsorderExportVO.class, queryWrapper);



			}else{
			MPJLambdaWrapper<Refund> queryWrapper = new MPJLambdaWrapper<>();
			queryWrapper.selectAs(Refund::getMoney,GoodsorderExportVO::getRefundMoney);
			queryWrapper.selectAs(Refund::getDoneDate,GoodsorderExportVO::getRefundDate);
			queryWrapper.selectAs(Goodsorder::getCloseMoney,GoodsorderExportVO::getCloseMoney);
			queryWrapper.selectAs(Goodsorder::getMoney,GoodsorderExportVO::getMoney);
			queryWrapper.selectAs(Goodsorder::getId,GoodsorderExportVO::getId);
			queryWrapper.selectAs(Goodsorder::getCode,GoodsorderExportVO::getCode);
			queryWrapper.selectAs(Goodsorder::getPayDate,GoodsorderExportVO::getPayDate);
			queryWrapper.selectAs(Member::getOpenid, GoodsorderExportVO::getOpenid);
			queryWrapper.leftJoin(Goodsorder.class, Goodsorder::getId ,Refund::getObjId);
			queryWrapper.leftJoin(Goodsorder.class, Goodsorder::getId ,Refund::getObjId);
			queryWrapper.leftJoin(Member.class, Member::getId ,Goodsorder::getMemberId);
			//时间段筛选
			if (Objects.nonNull(model.getStartDate())){
			queryWrapper.ge(Refund::getDoneDate, Utils.Date.getStart(model.getStartDate()));
			}
			if (Objects.nonNull(model.getEndDate())){
			queryWrapper.le( Refund::getDoneDate, Utils.Date.getEnd(model.getEndDate()));
			}
			queryWrapper.eq(Refund::getStatus,Constants.TWO);//退款完成
			queryWrapper.orderByAsc(Refund::getDoneDate);
			goodsorderExportVOIPage = refundJoinMapper.selectJoinPage(page, GoodsorderExportVO.class, queryWrapper);
			}

			if (!CollectionUtils.isEmpty(goodsorderExportVOIPage.getRecords())){
			goodsorderExportVOIPage.getRecords().forEach(s->{
			s.setBikeType(s.getType()==Constants.ZERO?s.getBikeType():Constants.ONE);
			s.setMoney(Constants.translateMoney(s.getMoney()));
			s.setRefundMoney(Constants.translateMoney(s.getRefundMoney()));
			s.setCloseMoney(Constants.translateMoney(s.getCloseMoney()));
			s.setCloseMoney(Constants.translateMoney(s.getCloseMoney()).compareTo(s.getMoney()) > 0 ? s.getMoney() : Constants.translateMoney(s.getCloseMoney()));
			});
			}
			return PageData.from(goodsorderExportVOIPage);
			}


			@Override
			public List<GoodsorderExportVO> findExportAccountDetailPage(Goodsorder model){
			model.setPayStatus(Constants.ONE); //只查询支付成功的
			MPJLambdaWrapper<Goodsorder> queryWrapper = initQueryParamByModel(model);
			List<GoodsorderExportVO> goodsorderList = goodsorderJoinMapper.selectJoinList(GoodsorderExportVO.class,queryWrapper);
			List<GoodsorderExportVO> goodsorderList = null;
			if(Constants.formatIntegerNum(model.getType())==Constants.ZERO){
			MPJLambdaWrapper<Goodsorder> queryWrapper = initQueryParamByModel(model);
			queryWrapper.orderByAsc(Goodsorder::getPayDate);
			goodsorderList = goodsorderJoinMapper.selectJoinList(GoodsorderExportVO.class,queryWrapper);
			}else{
			MPJLambdaWrapper<Refund> queryWrapper = new MPJLambdaWrapper<>();
			queryWrapper.selectAs(Refund::getMoney,GoodsorderExportVO::getRefundMoney);
			queryWrapper.selectAs(Refund::getDoneDate,GoodsorderExportVO::getRefundDate);
			queryWrapper.selectAs(Goodsorder::getCode,GoodsorderExportVO::getCode);
			queryWrapper.selectAs(Goodsorder::getId,GoodsorderExportVO::getId);
			queryWrapper.selectAs(Goodsorder::getPayDate,GoodsorderExportVO::getPayDate);
			queryWrapper.selectAs(Goodsorder::getCloseMoney,GoodsorderExportVO::getCloseMoney);
			queryWrapper.selectAs(Goodsorder::getMoney,GoodsorderExportVO::getMoney);
			queryWrapper.selectAs(Member::getOpenid, GoodsorderExportVO::getOpenid);
			queryWrapper.leftJoin(Goodsorder.class, Goodsorder::getId ,Refund::getObjId);
			queryWrapper.leftJoin(Goodsorder.class, Goodsorder::getId ,Refund::getObjId);
			queryWrapper.leftJoin(Member.class, Member::getId ,Goodsorder::getMemberId);
			//时间段筛选
			if (Objects.nonNull(model.getStartDate())){
			queryWrapper.ge(Refund::getDoneDate, Utils.Date.getStart(model.getStartDate()));
			}
			if (Objects.nonNull(model.getEndDate())){
			queryWrapper.le( Refund::getDoneDate, Utils.Date.getEnd(model.getEndDate()));
			}
			queryWrapper.eq(Refund::getStatus,Constants.TWO);//退款完成
			queryWrapper.orderByAsc(Refund::getDoneDate);;
			goodsorderList = refundJoinMapper.selectJoinList(GoodsorderExportVO.class,queryWrapper);
			}
			if (!CollectionUtils.isEmpty(goodsorderList)){
			goodsorderList.forEach(s->{
			s.setBikeType(s.getType()==Constants.ZERO?s.getBikeType():Constants.ONE);
			s.setMoney(Constants.translateMoney(s.getMoney()));
			s.setCloseMoney(Constants.translateMoney(s.getCloseMoney()));
			s.setCloseMoney(Constants.translateMoney(s.getCloseMoney()).compareTo(s.getMoney()) > 0 ? s.getMoney() : Constants.translateMoney(s.getCloseMoney()));
			s.setRefundMoney(Constants.translateMoney(s.getRefundMoney()));
			});
			}
			/* List<GoodsorderExportVO> list = new ArrayList<>();
			if(goodsorderList!=null){
			for(Goodsorder order : goodsorderList){
			GoodsorderExportVO vo = new GoodsorderExportVO();
			vo.setId(order.getId());
			vo.setCode(order.getCode());
			vo.setOpenid(order.getMemberOpenid());
			vo.setPayDate(order.getPayDate());
			vo.setCloseDate(order.getCloseDate());
			vo.setMoney(Constants.translateMoney(order.getMoney()));
			vo.setCloseMoney(Constants.translateMoney(order.getCloseMoney()));
			vo.setRefundDate(order.getRefundDate());
			vo.setRefundMoney(Constants.translateMoney(order.getRefundMoney()));
			list.add(vo);
			}
			}*/
			return goodsorderList;
			}
			private MPJLambdaWrapper<Goodsorder> initQueryParamByModel(Goodsorder model) {
			MPJLambdaWrapper<Goodsorder> queryWrapper = new MPJLambdaWrapper<>();
			Utils.MP.blankToNull(model);
			MPJLambdaWrapper<Goodsorder> queryWrapper = new MPJLambdaWrapper<>();
			queryWrapper.selectAll(Goodsorder.class);
			queryWrapper.selectAs(Member::getOpenid, Goodsorder::getOpenid);
			queryWrapper.selectAs(DiscountMember::getName, Goodsorder::getDiscountName);
			queryWrapper.selectAs(BaseParam::getType, Goodsorder::getBikeType);
			queryWrapper.leftJoin(Member.class, Member::getId ,Goodsorder::getMemberId);
			queryWrapper.select("(select max(r.done_date) from refund r where r.obj_id=t.id and r.status=2 ) as refund_date");
			queryWrapper.select("(select sum(r.money) from refund r where r.obj_id=t.id and r.status=2) as refund_money");
			queryWrapper.leftJoin(DiscountMember.class, DiscountMember::getGoodsorderId ,Goodsorder::getId);
			queryWrapper.leftJoin(BaseParam.class, BaseParam::getId ,Goodsorder::getParamId);
			queryWrapper.select("(select max(r.done_date) from refund r where r.obj_id=t.id and r.status in(0,2)) as refund_date");
			queryWrapper.select("(select sum(r.money) from refund r where r.obj_id=t.id and r.status in(0,2)) as refund_money");
			queryWrapper.select("(select sum(d.ride_price) from discount_log d where d.goodsorder_id=t.id and d.type = 0) as discountMoney");
			//时间段筛选
			if (Objects.nonNull(model.getStartDate())){
			queryWrapper.ge(Goodsorder::getPayDate, Utils.Date.getStart(model.getStartDate()));
			@@ -226,16 +324,19 @@
			if (Objects.nonNull(model.getEndDate())){
			queryWrapper.le( Goodsorder::getPayDate, Utils.Date.getEnd(model.getEndDate()));
			}

			queryWrapper.eq(model.getPayStatus() !=null,Goodsorder::getPayStatus,model.getPayStatus());
			queryWrapper.eq(Objects.nonNull(model.getBikeType()),BaseParam::getType,model.getBikeType());
			queryWrapper.eq(Constants.equalsInteger(model.getType(),Constants.ONE)&&model.getPayStatus() !=null,Goodsorder::getPayStatus,model.getPayStatus());
			queryWrapper.like(model.getCode() !=null,Goodsorder::getCode,model.getCode());
			queryWrapper.like(model.getId() !=null,Goodsorder::getId,model.getId());
			queryWrapper.eq(model.getStatus() !=null,Goodsorder::getStatus,model.getStatus());
			queryWrapper.eq(model.getPayWay() !=null,Goodsorder::getPayWay,model.getPayWay());
			queryWrapper.like(model.getOnlineOrderid() !=null,Goodsorder::getOnlineOrderid,model.getOnlineOrderid());
			queryWrapper.like(model.getOpenid() !=null,Member::getOpenid,model.getOpenid());
			queryWrapper.eq(Goodsorder::getIsdeleted,Constants.ZERO);
			queryWrapper.eq(Goodsorder::getPayStatus,Constants.ONE);
			queryWrapper.orderByDesc(Goodsorder::getPayDate);
			//如果是骑行订单只显示支付成功的
			queryWrapper.eq(Constants.equalsInteger(model.getType(),Constants.ZERO),Goodsorder::getPayStatus,Constants.ONE);
			queryWrapper.in(Constants.equalsInteger(model.getType(),Constants.ONE),Goodsorder::getStatus,Constants.ONE,Constants.ZERO);

			return queryWrapper;
			}

			@@ -244,32 +345,38 @@
			public PageData<Goodsorder> findPage(PageWrap<Goodsorder> pageWrap) {
			IPage<Goodsorder> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
			MPJLambdaWrapper<Goodsorder> queryWrapper = initQueryParamByModel(pageWrap.getModel());
			queryWrapper.select("(select er.status from member_rides er where er.ordre_id=t.id order by er.create_date desc limit 1) as memberRidesStatus");
			queryWrapper.orderByDesc(Goodsorder::getPayDate);
			queryWrapper.eq(Objects.nonNull(pageWrap.getModel().getType()),Goodsorder::getType,pageWrap.getModel().getType());

			queryWrapper.select("(select sum(er.discount_price) from member_rides er where er.ordre_id=t.id and er.isdeleted=0) as discountMoney," +
			"(select er.status from member_rides er where er.ordre_id=t.id order by er.create_date desc limit 1) as memberRidesStatus");


			queryWrapper.select("( select s.realname from refund r left join system_user s on r.creator = s.id where r.obj_id = t.id order by r.id desc limit 1 ) ",Goodsorder::getRefundUserName);
			if(Objects.nonNull(pageWrap.getModel().getCloseStatus()) && pageWrap.getModel().getCloseStatus().equals(Constants.ZERO)){
			queryWrapper.ne(Goodsorder::getStatus,Constants.GOODSORDER_STATUS.CLOSE.getKey());
			}
			if(Objects.nonNull(pageWrap.getModel().getCloseStatus()) && pageWrap.getModel().getCloseStatus().equals(Constants.ONE)){
			queryWrapper.eq(Goodsorder::getStatus,Constants.GOODSORDER_STATUS.CLOSE.getKey());
			}
			queryWrapper.like(StringUtils.isNotBlank(pageWrap.getModel().getDiscountName()),DiscountMember::getName,pageWrap.getModel().getDiscountName());
			IPage<Goodsorder> goodsorderIPage = goodsorderJoinMapper.selectJoinPage(page, Goodsorder.class, queryWrapper);
			if (!CollectionUtils.isEmpty(goodsorderIPage.getRecords())){
			goodsorderIPage.getRecords().forEach(s->{
			s.setMoney(Constants.translateMoney(s.getMoney()));
			s.setCloseMoney(Constants.translateMoney(s.getCloseMoney()));
			s.setRefundMoney(Constants.translateMoney(s.getRefundMoney()));
			s.setDiscountMoney(Constants.translateMoney(s.getDiscountMoney()));
			});
			}
			return PageData.from(goodsorderIPage);
			}


			@Override
			public long count(Goodsorder goodsorder) {
			QueryWrapper<Goodsorder> wrapper = new QueryWrapper<>(goodsorder);
			return goodsorderMapper.selectCount(wrapper);
			}



			@Override
			public HomeResponse getHome(String memberId){
			@@ -287,11 +394,27 @@
			homeResponse.setIsStopServe(this.checkTemporaryStop()?1:0);
			homeResponse.setIsBusiness(this.checkBusiness()?0:1);
			homeResponse.setUnBusinessTips("营业时间为"+ systemDictDataBiz.queryByCode(Constants.MINI_PROGRAMME,Constants.BUSINESS_STARTTIME).getCode() +" ~ "+systemDictDataBiz.queryByCode(Constants.MINI_PROGRAMME,Constants.BUSINESS_ENDTIME).getCode()+"，请在营业时间内使用本系统");
			homeResponse.setEleBusinessArea(systemDictDataBiz.queryByCode(Constants.MINI_PROGRAMME,Constants.PARK_LAT_LNG_LIST).getCode());

			homeResponse.setAdList(adMapper.selectList(new QueryWrapper<Ad>()
			.eq("isdeleted",Constants.ZERO)
			.eq("status",Constants.ZERO)
			.orderByDesc("create_date")
			.orderByAsc("sortnum")
			));;
			homeResponse.setDiscountList(
			discountMapper.selectList(new QueryWrapper<Discount>().lambda()
			.eq(Discount::getIsdeleted,Constants.ZERO)
			.eq(Discount::getStatus,Constants.ZERO)
			.apply(" now() BETWEEN start_date and ( end_date + INTERVAL '1 day' ) ")
			.orderByDesc(Discount::getId)
			.last(" limit 3 ")
			)
			);
			if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isNotEmpty(homeResponse.getDiscountList())){
			for (Discount discount:homeResponse.getDiscountList()) {
			discount.setDayPrice(discount.getPrice().divide(new BigDecimal(Integer.toString(discount.getUseDays())),2));
			}
			}
			if(!Objects.isNull(homeResponse.getAdList())&&homeResponse.getAdList().size()>Constants.ZERO){
			homeResponse.getAdList().forEach(i->{
			i.setImgfullurl(fullPath + i.getImgurl());
			@@ -302,49 +425,78 @@
			Goodsorder goodsorder = this.goodsorderMapper.selectOne(new QueryWrapper<Goodsorder>()
			.eq("member_id",memberId)
			.eq("status",Constants.goodsorderStatus.pay)
			.eq("type",0)
			.last(" limit 1 "));
			if(!Objects.isNull(goodsorder)&&goodsorder.getStatus().equals(Constants.goodsorderStatus.pay)){
			homeResponse.setDepositStatus(Constants.goodsorderStatus.pay);
			homeResponse.setGoodsOrderId(goodsorder.getId());
			//查询当前骑行状态
			MemberRides memberRides = memberRidesJoinMapper.selectOne(new QueryWrapper<MemberRides>().lambda()
			.eq(MemberRides::getMemberId, memberId)
			.eq(MemberRides::getOrdreId,goodsorder.getId())
			.ne(MemberRides::getStatus,Constants.MEMBER_RIDES_STATUS.LOCKING_DEFEAT.getKey())
			.orderByDesc(MemberRides::getCreateDate)
			.last(" limit 1 "));
			if (!Objects.isNull(memberRides)) {
			homeResponse.setRideStatus(memberRides.getStatus());
			MemberRidesResponse memberRidesResponse = new MemberRidesResponse();
			BaseParam baseParam = baseParamMapper.selectById(memberRides.getParamId());
			if(!Objects.isNull(baseParam)){
			memberRidesResponse.setBikeType(baseParam.getName());
			homeResponse.setDepositStatus(Constants.ZERO);
			if(goodsorder!=null){
			Refund r = this.refundMapper.selectOne(new QueryWrapper<Refund>().lambda()
			.eq(Refund::getObjId,goodsorder.getId())
			.eq(Refund::getIsdeleted,Constants.ZERO)
			.eq(Refund::getStatus,Constants.ZERO)
			.last("limit 1" ));
			if(r!=null){
			homeResponse.setDepositStatus(Constants.TWO);
			}else{
			homeResponse.setDepositStatus(Constants.ONE);
			}
			if( goodsorder.getStatus().equals(Constants.goodsorderStatus.pay)){
			homeResponse.setGoodsOrderId(goodsorder.getId());
			//查询当前骑行状态
			MemberRides memberRides = memberRidesJoinMapper.selectOne(new QueryWrapper<MemberRides>().lambda()
			.eq(MemberRides::getMemberId, memberId)
			.eq(MemberRides::getOrdreId,goodsorder.getId())
			.ne(MemberRides::getStatus,Constants.MEMBER_RIDES_STATUS.LOCKING_DEFEAT.getKey())
			.orderByDesc(MemberRides::getCreateDate)
			.last(" limit 1 "));
			if (Objects.nonNull(memberRides)) {
			homeResponse.setRideStatus(memberRides.getStatus());
			MemberRidesResponse memberRidesResponse = new MemberRidesResponse();
			BaseParam baseParam = baseParamMapper.selectById(memberRides.getParamId());
			if(!Objects.isNull(baseParam)){
			memberRidesResponse.setBikeType(baseParam.getName());
			}
			memberRidesResponse.setRidesType(memberRides.getType());
			memberRidesResponse.setRideId(memberRides.getId());
			memberRidesResponse.setRideStartTime(memberRides.getRentDate());
			memberRidesResponse.setRideStartTimeStr(DateUtil.DateToStr(memberRides.getRentDate(),"HH:mm"));
			memberRidesResponse.setRideEndTime(memberRides.getBackDate());
			memberRidesResponse.setRideEndTimeStr(DateUtil.DateToStr(memberRides.getBackDate(),"HH:mm"));
			memberRidesResponse.setRideTime(DateUtil.betweenMin(memberRides.getRentDate(),memberRides.getBackDate()));
			memberRidesResponse.setBikeCode(memberRides.getBikeCode());
			memberRidesResponse.setBasePrice(memberRides.getBasePrice());
			memberRidesResponse.setBaseTime(memberRides.getBaseTime());
			memberRidesResponse.setUnitTime(memberRides.getUnitTime());
			memberRidesResponse.setUnitPrice(memberRides.getUnitPrice());
			memberRidesResponse.setPriceRole(PricingDetailServiceImpl.getRoleNameByParam(
			memberRidesResponse.getBasePrice(),memberRidesResponse.getBaseTime(),
			memberRidesResponse.getUnitPrice()
			,memberRidesResponse.getUnitTime()));
			if(Constants.equalsInteger(memberRides.getType(),Constants.ONE)){
			Bikes bikes = bikesMapper.selectOne(new QueryWrapper<Bikes>().lambda().eq(Bikes::getCode,memberRides.getBikeCode()).eq(Bikes::getType,Constants.ONE).last("limit 1"));
			memberRidesResponse.setVoltageStatus(this.getVoltageStatus(bikes));
			}
			//查询当前的骑行套餐
			memberRidesResponse.setDiscountMember(this.getUseDiscount(memberId,Constants.ZERO,memberRides.getType()));
			homeResponse.setMemberRidesResponse(memberRidesResponse);
			}
			memberRidesResponse.setRideId(memberRides.getId());
			memberRidesResponse.setRideStartTime(memberRides.getRentDate());
			memberRidesResponse.setRideStartTimeStr(DateUtil.DateToStr(memberRides.getRentDate(),"HH:mm"));
			memberRidesResponse.setRideEndTime(memberRides.getBackDate());
			memberRidesResponse.setRideEndTimeStr(DateUtil.DateToStr(memberRides.getBackDate(),"HH:mm"));
			memberRidesResponse.setRideTime(DateUtil.betweenMin(memberRides.getRentDate(),memberRides.getBackDate()));
			memberRidesResponse.setBikeCode(memberRides.getBikeCode());
			memberRidesResponse.setBasePrice(memberRides.getBasePrice());
			memberRidesResponse.setBaseTime(memberRides.getBaseTime());
			memberRidesResponse.setUnitTime(memberRides.getUnitTime());
			memberRidesResponse.setUnitPrice(memberRides.getUnitPrice());
			memberRidesResponse.setPriceRole(PricingDetailServiceImpl.getRoleNameByParam(
			memberRidesResponse.getBasePrice(),memberRidesResponse.getBaseTime(),
			memberRidesResponse.getUnitPrice()
			,memberRidesResponse.getUnitTime()));
			homeResponse.setMemberRidesResponse(memberRidesResponse);
			}
			}
			return homeResponse;
			}

			@Override
			public Integer getVoltageStatus(Bikes bikes){
			//低电量电压
			BigDecimal lowVoltage = new BigDecimal(systemDictDataBiz.queryByCode(Constants.MINI_PROGRAMME, Constants.LOW_BIKE_VOLTAGE).getCode());
			if(Objects.isNull(bikes)\|\|Objects.isNull(bikes.getVoltage())\|\|Objects.isNull(lowVoltage)){
			return 0;
			}
			return bikes.getVoltage().compareTo(lowVoltage)>=0?0:1;
			}


			@Override
			public GoodsorderDetailDTO getGoodsorderDetailDTO(String id) {

			List<PayOrderDTO> payOrderDTOList = new ArrayList<>();
			Goodsorder goodsorder = goodsorderMapper.selectById(id);
			if(goodsorder == null){
			@@ -384,9 +536,64 @@
			GoodsorderDetailDTO goodsorderDetailDTO = new GoodsorderDetailDTO();
			goodsorderDetailDTO.setPayOrderDTOList(payOrderDTOList);//交易明细
			goodsorderDetailDTO.setMemberRidesList(memberRides);//骑行记录
			if(memberRides!=null){
			for(BikeLogDTO dd: memberRides){
			goodsorder.setDiscountMoney(Constants.formatDecimalNum(goodsorder.getDiscountMoney()).add(Constants.formatDecimalNum(dd.getDiscountPrice())));
			}
			goodsorder.setDiscountMoney(Constants.translateMoney(goodsorder.getDiscountMoney()));
			}
			goodsorderDetailDTO.setModel(goodsorder);//订单对象
			return goodsorderDetailDTO;
			}



			@Override
			public GoodsorderDetailVO getGoodsorderDetailForDisCount(String id){
			GoodsorderDetailVO goodsorderDetailVO = new GoodsorderDetailVO();
			Goodsorder goodsorder = goodsorderMapper.selectById(id);
			if(goodsorder == null){
			throw new BusinessException(ResponseStatus.DATA_EMPTY );
			}
			if(Constants.equalsInteger(goodsorder.getType(),Constants.ZERO)){
			throw new BusinessException(ResponseStatus.NOT_ALLOWED);
			}
			goodsorder.setMoney(Constants.translateMoney(goodsorder.getMoney()));
			goodsorderDetailVO.setGoodsOrder(goodsorder);
			Member member = memberMapper.selectById(goodsorder.getMemberId());
			if(Objects.nonNull(member)){
			goodsorderDetailVO.setMember(member);
			}
			//查询商品信息
			DiscountMember discountMember = discountMemberMapper.selectOne(new QueryWrapper<DiscountMember>().lambda()
			.eq(DiscountMember::getIsdeleted,Constants.ZERO)
			.eq(DiscountMember::getGoodsorderId,goodsorder.getId()));
			if(Objects.nonNull(discountMember)){
			goodsorderDetailVO.setDiscountMember(discountMember);
			}
			//查询所有有退款记录
			List<Refund> refunds = refundJoinMapper.selectJoinList(Refund.class,
			new MPJLambdaWrapper<Refund>()
			.selectAll(Refund.class)
			.selectAs(SystemUser::getRealname,Refund::getCreatorName)
			.leftJoin(SystemUser.class,SystemUser::getId,Refund::getCreator)
			.eq(Refund::getObjId,goodsorder.getId())
			.orderByDesc(Refund::getId)
			);
			if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isNotEmpty(refunds)){
			for (Refund refund:refunds) {
			if(Objects.nonNull(refund.getMoney())){
			refund.setMoney(Constants.translateMoney(refund.getMoney()));
			}
			}
			}
			goodsorderDetailVO.setRefundList(refunds);

			return goodsorderDetailVO;
			}



			@Override
			public void forceCloseGoodsorder(String orderId) {
			//查询订单信息
			@@ -408,19 +615,73 @@
			closeGoodsorder( goodsorder,Constants.REFUND_TYPE.PLAT_FORCE.getKey());
			}

			/**
			* 发起退款申请
			* @param goodsorder
			* @param type
			*/
			@Transactional(rollbackFor = {Exception.class,BusinessException.class})
			@Override
			public void closeGoodsorder( Goodsorder goodsorder ,int type ) {

			//
			List<MemberRides> memberRides = getMemberRidesForClose(goodsorder.getId());
			Refund r = refundMapper.selectOne(new QueryWrapper<Refund>().lambda()
			.eq(Refund::getObjId,goodsorder.getId())
			.eq(Refund::getIsdeleted,Constants.ZERO)
			.eq(Refund::getStatus,Constants.ZERO)
			.last("limit 1" ));
			if(r != null){
			throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "该订单存在退款申请正在处理中，请稍后查看订单信息哦~");
			}
			List<MemberRides> memberRides = getMemberRidesForClose(goodsorder.getId());//打车骑行记录
			dealCloseGoodsorderBiz(goodsorder,type,memberRides);
			}
			@Override
			public void dealCloseGoodsorderBiz(Goodsorder goodsorder, int type, List<MemberRides> memberRides) {
			//默认结算为押金金额
			BigDecimal closeMoney = new BigDecimal(0.00);
			if (!CollectionUtils.isEmpty(memberRides)){
			//骑行总时长
			closeMoney = getCloseMoneyByRides(memberRides,true).getAmount();
			//预计结算价格和计算时长
			int freeTime = 0;
			try {
			freeTime = Integer.parseInt(systemDictDataBiz.queryByCode(Constants.MINI_PROGRAMME, Constants.FREE_RENT_TIME).getCode());
			}catch (Exception e){
			}

			closeMoney = getCloseMoneyByRides(memberRides,freeTime,true,goodsorder.getMoney(),goodsorder.getMemberId(),true).getAmount();
			//实际结算价格，记录在最高车型记录上
			memberRides.get(0).setActualPrice(closeMoney);
			// memberRides.get(0).setActualPrice(closeMoney);
			}
			int refundMoney =( Constants.formatDecimalNum(goodsorder.getMoney()).subtract(closeMoney)).intValue();//计算价格
			if(refundMoney>0){
			RefundDTO refundDTO = new RefundDTO();
			refundDTO.setOrderId(goodsorder.getId());
			refundDTO.setCanBalance(goodsorder.getMoney());
			refundDTO.setRefundAmount(new BigDecimal(refundMoney));
			refundDTO.setTotalAmount(goodsorder.getMoney());
			refundDTO.setMemberId(goodsorder.getMemberId());
			refundDTO.setReason(Constants.REFUND_TYPE.get(type).getName());
			refundDTO.setCreator(goodsorder.getEditor());
			refundDTO.setType(type);
			boolean res = wxMiniUtilService.wxRefund(refundDTO);
			}else{
			//无退款结算
			closeGoodsorderDoneNoRefund(goodsorder,type,new BigDecimal(0),null,memberRides);
			}
			}

			public void closeGoodsorderDoneNoRefund(Goodsorder goodsorder,int type,BigDecimal refundMoney,String closeId,List<MemberRides> memberRides) {
			log.error("========================================"+JSONObject.toJSONString(goodsorder));
			if(goodsorder ==null \|\| Constants.formatIntegerNum(goodsorder.getStatus()) != Constants.GOODSORDER_STATUS.HAVING_PAY.getKey()){
			return;
			}
			BigDecimal closeMoney =( Constants.formatDecimalNum(goodsorder.getMoney()).subtract(refundMoney));
			//进行订单结算业务处理
			if(memberRides == null){
			memberRides = getMemberRidesForClose(goodsorder.getId());
			}
			//默认结算为押金金额
			if (!CollectionUtils.isEmpty(memberRides)){
			//骑行总时长
			for(MemberRides model :memberRides){
			MemberRides up = new MemberRides();
			up.setId(model.getId());
			@@ -433,18 +694,33 @@
			memberRidesJoinMapper.updateById(up);
			}
			}
			int durationSum = 0;
			int freeTime = 0;
			try {
			freeTime = Integer.parseInt(systemDictDataBiz.queryByCode(Constants.MINI_PROGRAMME, Constants.FREE_RENT_TIME).getCode());
			}catch (Exception e){
			}
			//最高价格车型的骑行记录
			MemberRides topRides = this.getMaxRides(memberRides,durationSum,freeTime,true);

			// BigDecimal closeMoney =( Constants.formatDecimalNum(goodsorder.getMoney()).subtract(refund.getMoney()));
			//退款乐行
			// int type =Constants.formatIntegerNum(refund.getType());
			Goodsorder update = new Goodsorder();
			update.setId(goodsorder.getId());
			update.setStatus(Constants.GOODSORDER_STATUS.CLOSE.getKey());
			update.setCloseMoney(closeMoney);
			update.setParamId(Objects.nonNull(topRides)?topRides.getParamId():null);
			update.setCloseStatus(Constants.ONE);
			update.setCloseDate(new Date());
			update.setCloseInfo(Constants.REFUND_TYPE.get(type).getInfo());
			update.setCloseUserId(goodsorder.getEditor());
			update.setType(Constants.ZERO);
			if(Constants.REFUND_TYPE.PLAT_FORCE.getKey() == type){
			//如果是强制结算
			update.setCloseType(Constants.ONE);
			LoginUserInfo principal = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
			update.setEditor(principal.getId());
			// LoginUserInfo principal = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
			// update.setEditor(principal.getId());
			}else if(Constants.REFUND_TYPE.NORMAL.getKey() == type){
			//如果是自行結算
			update.setCloseType(Constants.ZERO);
			@@ -452,21 +728,7 @@
			//如果是平台自动结算
			update.setCloseType(Constants.TWO);
			}
			int refundMoney =( Constants.formatDecimalNum(goodsorder.getMoney()).subtract(closeMoney)).intValue();//计算价格
			if(refundMoney > 0){
			//如果有退款，申请微信退款，记录退款交易流水
			RefundDTO refundDTO = new RefundDTO();
			refundDTO.setOrderId(goodsorder.getId());
			refundDTO.setCanBalance(goodsorder.getMoney());
			refundDTO.setRefundAmount(new BigDecimal(refundMoney));
			refundDTO.setTotalAmount(goodsorder.getMoney());
			refundDTO.setMemberId(goodsorder.getMemberId());
			refundDTO.setReason(Constants.REFUND_TYPE.get(type).getName());
			refundDTO.setCreator(update.getEditor());
			refundDTO.setType(type);
			Refund refund = wxMiniUtilService.wxRefund(refundDTO);
			update.setCloseId(refund.getId());
			}
			update.setCloseId(closeId);
			//存储消费交易流水
			Transactions transactions = new Transactions();
			transactions.setId(Constants.getUUID());
			@@ -474,7 +736,7 @@
			transactions.setCreateDate(new Date());
			transactions.setIsdeleted(Constants.ZERO);
			transactions.setOrderId(goodsorder.getId());
			transactions.setMoney(goodsorder.getMoney().subtract(new BigDecimal(refundMoney)));
			transactions.setMoney(closeMoney);
			transactions.setType(Constants.TRANSACTIONS_TYPE.CONSUMPTION.getKey());
			transactions.setDoneDate(new Date());
			transactions.setTitle(Constants.TRANSACTIONS_TYPE.CONSUMPTION.getName());
			@@ -487,19 +749,106 @@
			goodsorderMapper.updateById(update);
			}

			private RidesDetailResponse getCloseMoneyByRides(List<MemberRides> memberRides,boolean isClose) {
			RidesDetailResponse ridesDetailResponse = new RidesDetailResponse();
			BigDecimal closeMoney = new BigDecimal(0.00);
			int durationSum = 0;
			//取最高车型计算方案结算订单
			public MemberRides getMaxRides(List<MemberRides> memberRides,Integer durationSum,Integer freeTime,boolean isClose){
			MemberRides topRides =null;
			for(MemberRides rides : memberRides){
			if ( isClose && Constants.MEMBER_RIDES_STATUS.BACK_CYCLING.getKey()!=(Constants.formatIntegerNum(rides.getStatus()))){
			throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"当前订单有未完成的骑行，无法强制结算");
			}
			durationSum += Constants.formatIntegerNum(rides.getDuration());//累计骑行（计费）时长
			if(durationSum-freeTime > 0 ){//只算超出免费时长的数据
			if(topRides == null \|\|( Constants.formatIntegerNum(topRides.getSortnum())<Constants.formatIntegerNum(rides.getSortnum())
			&& Constants.formatIntegerNum(rides.getDuration())>0)){
			topRides = rides;
			}
			}
			}
			MemberRides topRides =memberRides.get(0);
			if(durationSum > 0 && topRides != null){
			return topRides;
			}
			/**
			* 退款成功回调
			*/
			@Transactional(rollbackFor = {Exception.class,BusinessException.class})
			@Override
			public void closeGoodsorderDone(RefundNotification param) {
			//查询退款申请订单
			Refund refund = refundMapper.selectById(param.getOutRefundNo());
			if(refund == null
			\|\| Constants.formatIntegerNum(refund.getIsdeleted()) == Constants.ONE
			\|\| Constants.formatIntegerNum(refund.getStatus()) == Constants.TWO){
			return;
			}
			if (!"SUCCESS".equals(param.getRefundStatus().name())) {
			// 如果退款状态不正确，修改退款单状态
			refund.setStatus(Constants.ONE);
			refund.setEditDate(new Date());
			refund.setOnlineOrderid(param.getTransactionId());
			refund.setDoneDate(refund.getEditDate());
			//更新退款单状态
			refundMapper.updateById(refund);
			return;
			}
			refund.setOnlineOrderid(param.getTransactionId());
			doRefundTransactions(refund);
			//退款乐行
			int type =Constants.formatIntegerNum(refund.getType());
			if(type == 0\|\| type ==1 \|\| type==2){
			//如果是阶段退款
			Goodsorder goodsorder = goodsorderMapper.selectById(refund.getObjId());
			closeGoodsorderDoneNoRefund(goodsorder,type,refund.getMoney(),refund.getId(),null);
			}
			}

			private void doRefundTransactions(Refund refund ) {
			//存储交易流水表
			refund.setStatus(Constants.TWO);
			refund.setEditDate(new Date());
			refund.setDoneDate(refund.getEditDate());
			//更新退款单状态
			refundMapper.updateById(refund);

			Transactions transactions = new Transactions();
			transactions.setId(Constants.getUUID());
			transactions.setMemberId(refund.getMemberId());
			transactions.setCreateDate(new Date());
			transactions.setIsdeleted(Constants.ZERO);
			transactions.setOrderId(refund.getObjId());
			transactions.setMoney(refund.getMoney());
			transactions.setPreOrderid(refund.getObjId());
			transactions.setOnlineOrderid(refund.getId());
			transactions.setDoneDate(new Date());
			if(refund.getType().equals(Constants.REFUND_TYPE.PLAT_AUTO.getKey())\|\|refund.getType().equals(Constants.REFUND_TYPE.PLAT_FORCE.getKey())){
			//平台自动退款或强制退款
			transactions.setType(Constants.TRANSACTIONS_TYPE.REFUND.getKey());
			transactions.setTitle(Constants.REFUND_TYPE.PLAT_AUTO.getInfo());
			transactions.setContent(Constants.REFUND_TYPE.PLAT_AUTO.getInfo());
			}else if(refund.getType().equals(Constants.REFUND_TYPE.NORMAL.getKey())){
			//用户主动退款
			transactions.setType(Constants.TRANSACTIONS_TYPE.REFUND.getKey());
			transactions.setTitle(Constants.REFUND_TYPE.NORMAL.getInfo());
			transactions.setContent(Constants.REFUND_TYPE.NORMAL.getInfo());
			}else if(refund.getType().equals(Constants.REFUND_TYPE.BACK.getKey())){
			//结算后退款
			transactions.setType(Constants.TRANSACTIONS_TYPE.REFUND.getKey());
			transactions.setTitle(Constants.REFUND_TYPE.BACK.getInfo());
			transactions.setContent(Constants.REFUND_TYPE.BACK.getInfo());
			}
			transactions.setBalance(BigDecimal.ZERO);
			transactions.setObjId(refund.getId());
			transactions.setObjType(Constants.ONE);
			transactionsMapper.insert(transactions);
			}

			private RidesDetailResponse getCloseMoneyByRides(List<MemberRides> memberRides,int freeTime,boolean isClose,BigDecimal yjMoney,String memberId,Boolean unOver) {
			RidesDetailResponse ridesDetailResponse = new RidesDetailResponse();
			ridesDetailResponse.setHaveDisCount(Constants.ZERO);
			BigDecimal closeMoney = new BigDecimal(0.00);
			int durationSum = 0;
			//最高价格车型的骑行记录
			MemberRides topRides = this.getMaxRides(memberRides,durationSum,freeTime,isClose);

			//计算应付金额
			if( topRides != null){
			int baseTime =Constants.formatIntegerNum(topRides.getBaseTime());
			closeMoney = Constants.formatDecimalNum(topRides.getBasePrice());
			//如果是一口价方式，价格直接为一口价baseMoney,如果不是计算正常价格
			@@ -511,58 +860,161 @@
			closeMoney = closeMoney.add(unit.multiply(Constants.formatDecimalNum(topRides.getUnitPrice())));
			}
			}
			topRides.setActualPrice(closeMoney);
			//2025年3月18日11:28:38 返回骑行价格最高的车型
			ridesDetailResponse.setParamId(topRides.getParamId());
			}
			//查询是否存在套餐信息
			DiscountMember discountMember = this.getUseDiscount(memberId,durationSum,Objects.nonNull(topRides)?topRides.getType():null);
			//计算抵扣金额
			//unOver 是否未结算未结算的订单根据当前套餐查询已结算的订单根据已生成的数据进行查询
			if(Objects.nonNull(discountMember) && Objects.nonNull(topRides) && unOver){
			//存储抵扣记录
			DiscountLog discountLog = new DiscountLog();
			discountLog.setIsdeleted(Constants.ZERO);
			discountLog.setCreator(memberId);
			discountLog.setCreateDate(new Date());
			discountLog.setDiscountMemberId(discountMember.getId());
			discountLog.setType(Constants.ZERO);
			discountLog.setInfo("骑行抵扣");
			discountLog.setEditInfo("骑行抵扣");
			discountLog.setGoodsorderId(topRides.getOrdreId());
			//如果骑行时间小于等于剩余时间则直接添加骑行卡使用数据修正实际支付金额
			if(Constants.equalsInteger(discountMember.getLimitType(),Constants.ZERO) \|\| discountMember.getSurplusTime() >= durationSum){
			discountLog.setRideTime(durationSum);
			discountLog.setRidePrice(closeMoney);
			topRides.setActualPrice(BigDecimal.ZERO);
			closeMoney = BigDecimal.ZERO;
			}else{
			int baseTime =Constants.formatIntegerNum(topRides.getBaseTime());
			BigDecimal closeDisCountMoney = Constants.formatDecimalNum(topRides.getBasePrice());
			//减去优惠时长剩余时长
			Integer durationDisCountSum = durationSum - discountMember.getSurplusTime();
			discountLog.setRideTime(durationDisCountSum<=Constants.ZERO?discountMember.getSurplusTime():Constants.ZERO);
			//如果是一口价方式，价格直接为一口价baseMoney,如果不是计算正常价格
			if(baseTime != -1){//不是一口价
			if(durationDisCountSum > baseTime && Constants.formatIntegerNum(topRides.getUnitTime())>0){
			//如果超出了起步价格，计算超出价格
			BigDecimal unit = new BigDecimal(durationSum-baseTime).divide(new BigDecimal(topRides.getUnitTime()), 0, BigDecimal.ROUND_UP);
			//计算金额累计超出部门价格（超出时间单位*超出单位时间价格）
			closeDisCountMoney = closeDisCountMoney.add(unit.multiply(Constants.formatDecimalNum(topRides.getUnitPrice())));
			}
			discountLog.setRidePrice(durationDisCountSum<=Constants.ZERO?closeMoney.subtract(closeDisCountMoney):BigDecimal.ZERO);
			}else{
			discountLog.setRidePrice(BigDecimal.ZERO);
			}
			}
			if(isClose&&discountLog.getRideTime()>Constants.ZERO){
			discountLogMapper.insert(discountLog);
			}
			ridesDetailResponse.setHaveDisCount(discountLog.getRideTime()>Constants.ZERO?Constants.ONE:Constants.ZERO);
			ridesDetailResponse.setDisCountMoney(discountLog.getRidePrice());
			}else if(Objects.nonNull(discountMember) && Objects.nonNull(topRides)
			&& !unOver ){
			//已还车则查询是否有套餐卡使用记录
			List<DiscountLog> discountLogList = discountLogMapper.selectList(new QueryWrapper<DiscountLog>().lambda().eq(DiscountLog::getGoodsorderId,topRides.getOrdreId()).eq(DiscountLog::getType,Constants.ZERO)
			.eq(DiscountLog::getIsdeleted,Constants.ZERO));
			if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isNotEmpty(discountLogList)){
			ridesDetailResponse.setHaveDisCount(Constants.ONE);
			ridesDetailResponse.setDisCountMoney(discountLogList.stream().map(i->i.getRidePrice()).reduce(BigDecimal.ZERO,BigDecimal::add));
			}
			}
			//如果订单价格封顶了，取订单价格
			if(Constants.compareBigdecimal(closeMoney, yjMoney) ==1){
			closeMoney = yjMoney;
			}
			ridesDetailResponse.setDuration(durationSum);
			ridesDetailResponse.setAmount(closeMoney);
			ridesDetailResponse.setBikeType(topRides.getParamName());
			ridesDetailResponse.setBikeType(topRides!=null?topRides.getParamName():"-");
			return ridesDetailResponse;
			}

			private List<MemberRides> getMemberRidesForClose(String id) {

			@Override
			public List<MemberRides> getMemberRidesForClose(String id) {
			MPJLambdaWrapper<MemberRides> wrapper = new MPJLambdaWrapper<>();
			wrapper.eq(MemberRides::getOrdreId,id);
			wrapper.ne(MemberRides::getStatus,Constants.MEMBER_RIDES_STATUS.LOCKING_DEFEAT.getKey());
			wrapper.selectAll(MemberRides.class).selectAs(BaseParam::getName, MemberRides::getParamName);
			wrapper.selectAll(MemberRides.class)
			.selectAs(BaseParam::getSortnum, MemberRides::getSortnum)
			.selectAs(BaseParam::getName, MemberRides::getParamName);
			wrapper.leftJoin(BaseParam.class, BaseParam::getId, MemberRides::getParamId);
			wrapper.orderByDesc(BaseParam::getSortnum);
			//取最高车型作为计价方案
			//查询所有骑行记录
			List<MemberRides> memberRides = memberRidesJoinMapper.selectList(wrapper);
			List<MemberRides> memberRides = memberRidesJoinMapper.selectJoinList(MemberRides.class,wrapper);
			return memberRides;
			}

			@Override
			public void backGoodsorder(String orderId, BigDecimal money,String reason) {
			public void backGoodsorder(GoodsorderBackDTO goodsorderBackDTO) {
			LoginUserInfo principal = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
			Goodsorder goodsorder = goodsorderMapper.selectById(orderId);
			if(Objects.isNull(goodsorderBackDTO)
			\|\| StringUtils.isBlank(goodsorderBackDTO.getOrderId())
			\|\| Objects.isNull(goodsorderBackDTO.getBackType())
			\|\| Objects.isNull(goodsorderBackDTO.getMoney())){
			throw new BusinessException(ResponseStatus.BAD_REQUEST);
			}
			Goodsorder goodsorder = goodsorderMapper.selectById(goodsorderBackDTO.getOrderId());
			if(goodsorder == null){
			throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "对不起，订单信息不存在，请刷新页面重试！");
			}
			if (Constants.formatIntegerNum(goodsorder.getStatus()) != Constants.GOODSORDER_STATUS.CLOSE.getKey()){
			if (Constants.equalsInteger(goodsorder.getType(),Constants.ZERO) &&
			Constants.formatIntegerNum(goodsorder.getStatus()) != Constants.GOODSORDER_STATUS.CLOSE.getKey()){
			throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，该订单请结算后再退款~");
			}
			if (Constants.equalsInteger(goodsorder.getType(),Constants.ONE) &&
			Constants.formatIntegerNum(goodsorder.getStatus()) != Constants.GOODSORDER_STATUS.HAVING_PAY.getKey()){
			throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，该订单请支付后再退款~");
			}
			QueryWrapper<Refund> wrapper = new QueryWrapper<>();
			wrapper.lambda()
			.eq(Refund::getObjId,orderId)
			.eq(Refund::getStatus,Constants.TWO)
			.eq(Refund::getObjId,goodsorderBackDTO.getOrderId())
			.in(Refund::getStatus,Constants.TWO,Constants.ZERO)
			.eq(Refund::getIsdeleted,Constants.ZERO) ;
			wrapper.select("sum(money) as money").last(" limit 1");
			Refund total = refundMapper.selectOne(wrapper);
			BigDecimal refundMoney = total == null?new BigDecimal(0):Constants.formatDecimalNum(total.getMoney());
			//可退剩余单位元
			BigDecimal canBalance =Constants.translateMoney(Constants.formatDecimalNum(goodsorder.getMoney()).subtract(refundMoney));
			if(canBalance.compareTo(money) >= Constants.ZERO){
			if(canBalance.compareTo(goodsorderBackDTO.getMoney()) >= Constants.ZERO){
			RefundDTO refundDTO = new RefundDTO();
			refundDTO.setOrderId(orderId);
			refundDTO.setOrderId(goodsorderBackDTO.getOrderId());
			refundDTO.setCanBalance(canBalance.multiply(new BigDecimal(100)));
			refundDTO.setRefundAmount(money.multiply(new BigDecimal(100)));
			refundDTO.setRefundAmount(goodsorderBackDTO.getMoney().multiply(new BigDecimal(100)));
			refundDTO.setTotalAmount(goodsorder.getMoney());
			refundDTO.setMemberId(goodsorder.getMemberId());
			refundDTO.setCreator(principal.getId());
			refundDTO.setReason(reason);
			refundDTO.setReason(goodsorderBackDTO.getReason());
			refundDTO.setType(Constants.REFUND_TYPE.BACK.getKey());
			Refund refund = wxMiniUtilService.wxRefund(refundDTO);
			//退货退款查看套餐订单状态更新订单信息
			if(Constants.equalsInteger(goodsorderBackDTO.getBackType(),Constants.ZERO)&&Constants.equalsInteger(goodsorder.getType(),Constants.ONE)){
			DiscountMember discountMember = discountMemberMapper.selectOne(new QueryWrapper<DiscountMember>().lambda().
			eq(DiscountMember::getGoodsorderId,goodsorder.getId())
			.eq(DiscountMember::getIsdeleted,Constants.ZERO)
			.last("limit 1"));
			if(Objects.isNull(discountMember)){
			throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"未查询到套餐卡信息");
			}
			if(Constants.equalsInteger(discountMember.getStatus(),Constants.ZERO)){
			discountMemberMapper.update(null,new UpdateWrapper<DiscountMember>().lambda()
			.set(DiscountMember::getStatus,Constants.ONE)
			.eq(DiscountMember::getId,discountMember.getId())
			);
			//操作日志
			DiscountLog discountLog = new DiscountLog();
			discountLog.setIsdeleted(Constants.ZERO);
			discountLog.setCreator(principal.getId());
			discountLog.setCreateDate(new Date());
			discountLog.setDiscountMemberId(discountMember.getId());
			discountLog.setType(Constants.ONE);
			discountLog.setEditInfo("退货退卡");
			discountLog.setGoodsorderId(goodsorderBackDTO.getOrderId());
			discountLogMapper.insert(discountLog);
			}
			}
			//发起退款申请
			wxMiniUtilService.wxRefund(refundDTO);

			}else {
			throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),"对不起，退款金额不允许超过"+canBalance+"元");
			}
			@@ -578,7 +1030,7 @@
			QueryWrapper<Refund> wrapper = new QueryWrapper<>();
			wrapper.lambda()
			.eq(Refund::getObjId,orderId)
			.eq(Refund::getStatus,Constants.TWO)
			.in(Refund::getStatus,Constants.TWO,Constants.ZERO)
			.eq(Refund::getIsdeleted,Constants.ZERO) ;
			wrapper.select("sum(money) as money").last(" limit 1");
			Refund total = refundMapper.selectOne(wrapper);
			@@ -600,6 +1052,7 @@
			model.setPayMoney(new BigDecimal(0.00));
			model.setRefundMoney(new BigDecimal(0.00));
			model.setClosedMoney(new BigDecimal(0.00));
			model.setDiscountMoney(new BigDecimal(0.00));
			model.setUnClosedMoney(new BigDecimal(0.00));
			model.setClosedNum(0);
			model.setUnClosedNum(0);
			@@ -614,27 +1067,36 @@
			}
			queryWrapper.lambda().eq(Goodsorder::getPayStatus, Constants.ONE);//已支付
			queryWrapper.lambda().eq(Goodsorder::getIsdeleted, Constants.ZERO);
			queryWrapper.lambda().groupBy(Goodsorder::getStatus);
			queryWrapper.select( "status ","count(id) as count_num"
			queryWrapper.lambda().groupBy(Goodsorder::getStatus,Goodsorder::getType);
			queryWrapper.select( "type","status ","count(id) as count_num"
			,"sum(money) as money","sum(close_money) as close_money" );
			//按订单状态分组统计
			List<Goodsorder> detailList = goodsorderMapper.selectList(queryWrapper);
			for(Goodsorder goodsorder : detailList){
			if(Constants.formatIntegerNum(goodsorder.getStatus()) == Constants.GOODSORDER_STATUS.CLOSE.getKey()){
			//已结算
			model.setClosedNum(model.getClosedNum()+goodsorder.getCountNum());
			model.setClosedMoney(model.getClosedMoney().add(Constants.translateMoney(goodsorder.getCloseMoney())));
			if(Constants.equalsInteger(goodsorder.getType(),Constants.ZERO)){
			//如果是骑行订单押金，计算骑行收入
			if(Constants.formatIntegerNum(goodsorder.getStatus()) == Constants.GOODSORDER_STATUS.CLOSE.getKey()){
			//已结算
			model.setClosedNum(model.getClosedNum()+goodsorder.getCountNum());
			//修改bug 结算收入 = 支付金额-退款-未结算
			// model.setClosedMoney(model.getClosedMoney().add(Constants.translateMoney(goodsorder.getCloseMoney())));

			model.setPayNum(model.getPayNum()+goodsorder.getCountNum());
			model.setPayMoney(model.getPayMoney().add(Constants.translateMoney(goodsorder.getMoney())));
			}else if(Constants.formatIntegerNum(goodsorder.getStatus()) == Constants.GOODSORDER_STATUS.HAVING_PAY.getKey()){
			//已支付未结算
			model.setUnClosedNum(model.getUnClosedNum()+goodsorder.getCountNum());
			model.setUnClosedMoney(model.getUnClosedMoney().add(Constants.translateMoney(goodsorder.getMoney())));
			model.setPayNum(model.getPayNum()+goodsorder.getCountNum());
			model.setPayMoney(model.getPayMoney().add(Constants.translateMoney(goodsorder.getMoney())));
			}else if(Constants.formatIntegerNum(goodsorder.getStatus()) == Constants.GOODSORDER_STATUS.HAVING_PAY.getKey()){
			//已支付未结算
			model.setUnClosedNum(model.getUnClosedNum()+goodsorder.getCountNum());
			model.setUnClosedMoney(model.getUnClosedMoney().add(Constants.translateMoney(goodsorder.getMoney())));

			model.setPayNum(model.getPayNum()+goodsorder.getCountNum());
			model.setPayMoney(model.getPayMoney().add(Constants.translateMoney(goodsorder.getMoney())));
			model.setPayNum(model.getPayNum()+goodsorder.getCountNum());
			model.setPayMoney(model.getPayMoney().add(Constants.translateMoney(goodsorder.getMoney())));
			}
			}else{
			//套餐卡收入累计 (交易笔数和交易金额）
			model.setDiscountNum(model.getDiscountNum()+goodsorder.getCountNum());
			model.setDiscountMoney(model.getDiscountMoney().add(Constants.translateMoney(goodsorder.getMoney())));
			}

			}
			QueryWrapper<Refund> queryWrapper2 = new QueryWrapper<>();
			if(Objects.nonNull(param.getStartDate())) {
			@@ -652,6 +1114,7 @@
			model.setRefundNum(Constants.formatIntegerNum(refund.getCountNum()));
			model.setRefundMoney(Constants.translateMoney(Constants.formatDecimalNum(refund.getMoney())));
			}
			model.setClosedMoney(model.getPayMoney().subtract(model.getRefundMoney()).subtract(model.getUnClosedMoney()));
			return model;
			}
			@Override
			@@ -664,9 +1127,11 @@
			List<MemberRides> memberRides = memberRidesJoinMapper.selectJoinList(MemberRides.class,new MPJLambdaWrapper<MemberRides>()
			.selectAll(MemberRides.class)
			.selectAs(BaseParam::getName,MemberRides::getParamName)
			.selectAs(BaseParam::getSortnum,MemberRides::getSortnum)
			.leftJoin(BaseParam.class,BaseParam::getId,MemberRides::getParamId)
			.eq(MemberRides::getOrdreId,id)
			.in(MemberRides::getStatus,Constants.MEMBER_RIDES_STATUS.RIDES_RUNNING.getKey(),Constants.MEMBER_RIDES_STATUS.BACK_CYCLING.getKey())
			.in(MemberRides::getStatus,Constants.MEMBER_RIDES_STATUS.RIDES_RUNNING.getKey()
			,Constants.MEMBER_RIDES_STATUS.BACK_CYCLING.getKey(),Constants.MEMBER_RIDES_STATUS.RIDES_PAUSING.getKey())
			.orderByDesc(MemberRides::getCreateDate));
			if (!CollectionUtils.isEmpty(memberRides)){
			//预计结算价格和计算时长
			@@ -702,7 +1167,8 @@
			return memberRidesResponse;
			}).collect(Collectors.toList());
			//累计和预算结算金额
			RidesDetailResponse ridesDetailResponse = getCloseMoneyByRides(memberRides,false);;
			RidesDetailResponse ridesDetailResponse = getCloseMoneyByRides(memberRides,freeTime,false,goodsorder.getMoney(),goodsorder.getMemberId(),
			Constants.equalsInteger(goodsorder.getStatus(),Constants.GOODSORDER_STATUS.CLOSE.getKey())?false:true);
			if(Constants.formatIntegerNum(goodsorder.getStatus())!= Constants.goodsorderStatus.pay){
			//如果非已支付但未结算，使用订单金额
			ridesDetailResponse.setAmount(goodsorder.getCloseMoney());
			@@ -724,6 +1190,7 @@
			qry.setStatus(Constants.goodsorderStatus.pay);
			qry.setMemberId(memberId);
			qry.setIsdeleted(Constants.ZERO);
			qry.setType(Constants.ZERO);
			if(goodsorderMapper.selectCount(new QueryWrapper<>(qry))>Constants.ZERO){
			throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"已支付过定金，无法重复该操作");
			}
			@@ -740,6 +1207,7 @@
			goodsorder.setCreateDate(new Date());
			goodsorder.setIsdeleted(Constants.ZERO);
			goodsorder.setCode(goodsorder.getId());
			goodsorder.setType(Constants.ZERO);
			goodsorder.setMemberId(memberId);
			goodsorder.setMoney(new BigDecimal(systemDictDataBiz.queryByCode(Constants.MINI_PROGRAMME,Constants.RENT_DEPOSIT).getCode()).multiply(new BigDecimal(100)));
			goodsorder.setStatus(Constants.goodsorderStatus.waitPay);
			@@ -748,23 +1216,132 @@
			goodsorder.setPayWay(Constants.ZERO);
			this.goodsorderMapper.insert(goodsorder);
			//调起支付
			Object response = null;
			try {
			Object response = null;
			WxPayUnifiedOrderRequest request = new WxPayUnifiedOrderRequest();
			request.setBody("骑行押金");
			request.setAttach("createGoodsOrder");
			request.setOutTradeNo(goodsorder.getId());
			request.setTotalFee(goodsorder.getMoney().intValue());
			request.setSpbillCreateIp(this.getIpAddr());
			request.setTimeStart(DateUtil.DateToString(new Date(), "yyyyMMddHHmmss"));
			request.setOpenid(member.getOpenid());
			response = WxMiniConfig.wxPayService.createOrder(request);
			return response;
			} catch (WxPayException e) {
			e.printStackTrace();
			throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),e.getMessage());
			response = getWxPayResponse(goodsorder,member.getOpenid());
			} catch (Exception e) {
			throw new BusinessException(ResponseStatus.SERVER_ERROR.getCode(),"对不起，发起支付失败~");
			}
			return response;
			}


			@Override
			public Object createDiscountOrderPay(String memberId,String discountId){
			Member member = memberMapper.selectById(memberId);
			if(Objects.isNull(member)){
			throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到用户对象信息");
			}
			Discount discount = discountMapper.selectById(discountId);
			this.checkDiscountSaleDate(discount);
			String discountMemberId = Constants.getUUID();
			String goodsorderId = Constants.getUUID();
			DiscountMember discountMember = new DiscountMember();
			BeanUtils.copyProperties(discount,discountMember);
			discountMember.setCreator(null);
			discountMember.setId(discountMemberId);
			discountMember.setCreateDate(new Date());
			discountMember.setEditDate(new Date());
			discountMember.setEditor(null);
			discountMember.setMemberId(memberId);
			discountMember.setStatus(Constants.TWO);
			discountMember.setGoodsorderId(goodsorderId);
			if(!Constants.equalsInteger(discountMember.getUseType(),Constants.ZERO)){
			if(Constants.equalsInteger(discountMember.getUseType(),Constants.ONE)){
			discountMember.setUseStartDate(DateUtil.StringToDateFormat(DateUtil.getCurrDate(),"yyyy-MM-dd"));
			}
			discountMember.setUseEndDate( DateUtil.StringToDateFormat(DateUtil.getXDaysAfter(discountMember.getUseStartDate(),discountMember.getUseDays()-1),"yyyy-MM-dd"));
			}
			discountMemberMapper.insert(discountMember);
			Goodsorder goodsorder = new Goodsorder();
			goodsorder.setId(goodsorderId);
			goodsorder.setCreateDate(new Date());
			goodsorder.setIsdeleted(Constants.ZERO);
			goodsorder.setCode(goodsorder.getId());
			goodsorder.setMemberId(memberId);
			goodsorder.setType(Constants.ONE);
			goodsorder.setMoney(discount.getPrice().multiply(new BigDecimal(100)));
			goodsorder.setStatus(Constants.goodsorderStatus.waitPay);
			goodsorder.setPreOrderid(goodsorder.getId());
			goodsorder.setPayStatus(Constants.goodsorderPayStatus.waitPay);
			goodsorder.setPayWay(Constants.ZERO);
			goodsorder.setObjType(Constants.ZERO);
			goodsorder.setObjId(discount.getId());
			this.goodsorderMapper.insert(goodsorder);
			//调起支付
			Object response = null;
			try {
			response = getWxPayResponse(goodsorder,member.getOpenid());
			} catch (Exception e) {
			throw new BusinessException(ResponseStatus.SERVER_ERROR.getCode(),"对不起，发起支付失败~");
			}
			return response;

			}

			public void checkDiscountSaleDate(Discount discount){
			if(Objects.isNull(discount)){
			throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到套餐信息");
			}
			if(!(Constants.equalsInteger(discount.getIsdeleted(),Constants.ZERO)
			&& Constants.equalsInteger(discount.getStatus(),Constants.ZERO))){
			throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"套餐已下架，无法进行购买，请刷新查看");
			}
			if(!(discount.getStartDate().getTime() < System.currentTimeMillis()
			&& Utils.Date.getEnd(discount.getEndDate()).getTime() > System.currentTimeMillis() )){
			throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"套餐开放时间未到,无法进行购买");
			}
			//验证是否超过今日可售卖数量
			if(Objects.nonNull(discount.getSaleDayLimit())&&discount.getSaleDayLimit()>Constants.ZERO){
			if(goodsorderMapper.selectCount(new QueryWrapper<Goodsorder>().lambda()
			.eq(Goodsorder::getType,Constants.ONE)
			.eq(Goodsorder::getObjId,discount.getId())
			.in(Goodsorder::getStatus,Constants.ZERO,Constants.ONE)
			.apply(" EXTRACT(DAY FROM create_date) = EXTRACT(DAY FROM CURRENT_DATE) ")
			)>=discount.getSaleDayLimit()){
			throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"套餐今日发行量已售罄，请明日查看！");
			}
			}
			if(Objects.nonNull(discount.getSaleLimit())&&discount.getSaleLimit()>Constants.ZERO){
			if(goodsorderMapper.selectCount(new QueryWrapper<Goodsorder>().lambda()
			.eq(Goodsorder::getType,Constants.ONE)
			.eq(Goodsorder::getObjId,discount.getId())
			.in(Goodsorder::getStatus,Constants.ZERO,Constants.ONE)
			)>=discount.getSaleLimit()){
			throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"套餐发行量已售罄！");
			}
			}
			}



			private Object getWxPayResponse(Goodsorder goodsorder,String openid){
			Object response = null;
			//调起支付
			PrepayRequest request = new PrepayRequest();
			request.setAttach("createGoodsOrder");
			request.setDescription(Constants.equalsInteger(goodsorder.getType(),Constants.ZERO)?"森林公园自行车骑行押金支付":"森林公园自行车购买骑行套餐支付");
			request.setSpMchid(WxMiniConfig.wxProperties.getMchId());
			request.setSpAppid(WxMiniConfig.wxProperties.getAppId());
			request.setSubMchid(WxMiniConfig.wxProperties.getSubMchId());
			request.setSubAppid(WxMiniConfig.wxProperties.getSubAppId());
			Payer payer = new Payer();
			payer.setSubOpenid(openid);
			request.setPayer(payer);
			request.setOutTradeNo(goodsorder.getId());
			request.setNotifyUrl(WxMiniConfig.wxProperties.getNotifyUrl());//这个回调url必须是https开头的
			Amount amount = new Amount();
			amount.setTotal(goodsorder.getMoney().intValue());
			request.setAmount(amount);
			// PrepayResponse res = WxMiniConfig.wxPayService.prepay(request);
			// 跟之前下单示例一样，填充预下单参数
			PrepayWithRequestPaymentResponse resParam = WxMiniConfig.jsapiExtService.prepayWithRequestPayment(request,WxMiniConfig.wxProperties.getSubAppId());
			response =resParam;
			return response;
			}




			/**
			* 验证营业时间
			@@ -806,11 +1383,45 @@
			}


			@Override
			public void autoCancelRefunOrder(){
			Date date = new Date(System.currentTimeMillis()-560L1000L);
			List<Refund> list = refundMapper.selectList(new QueryWrapper<Refund>().lambda()
			.eq(Refund::getStatus,Constants.ZERO)
			.lt(Refund::getCreateDate,date));
			if(list !=null && list.size()>0){
			List<String> cancelIds = new ArrayList<>();
			for(Refund r:list){
			com.wechat.pay.java.service.refund.model.Refund res =wxMiniUtilService.isSuucessRefund(r.getId());
			if(res !=null){
			//如果退款成功
			RefundNotification param = new RefundNotification();
			param.setRefundStatus(Status.SUCCESS);
			param.setOutRefundNo(r.getId());
			param.setTransactionId(res.getTransactionId());
			//执行关闭订单业务
			closeGoodsorderDone(param);
			}else{
			//放入取消集合中
			cancelIds.add(r.getId());
			}
			}
			if(cancelIds.size()>0){
			refundMapper.update(null, new UpdateWrapper<Refund>().lambda()
			.in(Refund::getId,cancelIds)
			.set(Refund::getStatus,Constants.ONE)
			.set(Refund::getEditDate,new Date())
			.set(Refund::getInfo,"超时未回调，自动取消")
			);
			}
			}
			}

			@Override
			public void autoCloseOrder( ) {
			Goodsorder goodsorder = new Goodsorder();
			goodsorder.setIsdeleted(Constants.ZERO);
			goodsorder.setType(Constants.ZERO);
			goodsorder.setStatus(Constants.goodsorderStatus.pay);
			List<Goodsorder> list = findList(goodsorder);
			if (!CollectionUtils.isEmpty(list)){
			@@ -820,28 +1431,24 @@
			s.setEditDate(date);
			s.setEditor(null);
			s.setCloseDate(date);

			closeGoodsorder(s,Constants.REFUND_TYPE.PLAT_AUTO.getKey());
			}catch (BusinessException e){

			}catch (Exception e){

			}
			});
			}

			}

			@Override
			public void goodsOrderSettlement(String memberId) {
			Goodsorder goodsorder = this.goodsorderMapper.selectOne(new QueryWrapper<Goodsorder>()
			.eq("member_id",memberId)
			.eq("status",Constants.goodsorderStatus.pay)
			.eq("type",Constants.ZERO)
			.last(" limit 1 "));
			if(Objects.isNull(goodsorder)){
			throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"无骑行订单记录");
			}
			if(goodsorder == null ){
			throw new BusinessException(ResponseStatus.DATA_EMPTY );
			throw new BusinessException(ResponseStatus.NO_UNCLOSEED_ORDER.getCode(),"无骑行订单记录");
			}
			if(Constants.formatIntegerNum(goodsorder.getStatus()) != Constants.GOODSORDER_STATUS.HAVING_PAY.getKey() ){
			throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该订单当前状态不支持结算操作，请尝试刷新列表重试！" );
			@@ -858,9 +1465,53 @@
			public String payNotify(String preOrderId,String paymentNo){
			Goodsorder goodsorder = this.goodsorderMapper.selectById(preOrderId);
			if(goodsorder.getStatus()==Constants.goodsorderStatus.pay){
			return WxPayNotifyResponse.success("处理成功!");
			return ("处理成功!");
			}
			goodsorder.setOnlineOrderid(paymentNo);
			if(Constants.equalsInteger(goodsorder.getType(),Constants.ZERO)){
			this.dealGoodsOrderCallBack(goodsorder);
			}else{
			this.dealDiscountOrderCallBack(goodsorder);
			}
			return ("处理成功!");
			}

			public void dealDiscountOrderCallBack(Goodsorder goodsorder){
			goodsorder.setPayStatus(Constants.goodsorderPayStatus.pay);
			goodsorder.setStatus(Constants.goodsorderStatus.pay);
			goodsorder.setPayDate(new Date());
			goodsorder.setEditDate(new Date());
			goodsorderMapper.updateById(goodsorder);

			DiscountMember discountMember = discountMemberMapper.selectOne(new QueryWrapper<DiscountMember>().lambda()
			.eq(DiscountMember::getGoodsorderId,goodsorder.getId()).last(" limit 1 "));
			discountMemberMapper.update(null,new UpdateWrapper<DiscountMember>().lambda()
			.set(DiscountMember::getStatus,Constants.ZERO)
			.eq(DiscountMember::getId,discountMember.getId())
			);
			Constants.TRANSACTIONS_TYPE discountConstants = Constants.TRANSACTIONS_TYPE.DISCOUNT;
			//存储交易流水表
			Transactions transactions = new Transactions();
			transactions.setMemberId(goodsorder.getMemberId());
			transactions.setCreateDate(new Date());
			transactions.setIsdeleted(Constants.ZERO);
			transactions.setOrderId(goodsorder.getId());
			transactions.setMoney(goodsorder.getMoney());
			transactions.setType(discountConstants.getKey());
			transactions.setPreOrderid(goodsorder.getPreOrderid());
			transactions.setOnlineOrderid(goodsorder.getOnlineOrderid());
			transactions.setDoneDate(new Date());
			transactions.setTitle(discountConstants.getName());
			transactions.setContent(discountConstants.getInfo());
			//transactions.setContent(discountMember.getName() +" 有效期" + DateUtil.dateToString(discountMember.getUseStartDate(),"yyyy-MM-dd") +"-"+DateUtil.dateToString(discountMember.getUseEndDate(),"yyyy-MM-dd"));
			transactions.setBalance(goodsorder.getMoney());
			transactions.setObjId(discountMember.getId());
			transactions.setObjType(Constants.TWO);
			transactionsMapper.insert(transactions);
			}


			public void dealGoodsOrderCallBack(Goodsorder goodsorder){
			goodsorder.setPayStatus(Constants.goodsorderPayStatus.pay);
			goodsorder.setStatus(Constants.goodsorderStatus.pay);
			goodsorder.setPayDate(new Date());
			@@ -883,9 +1534,7 @@
			transactions.setObjId(goodsorder.getId());
			transactions.setObjType(Constants.ZERO);
			transactionsMapper.insert(transactions);
			return WxPayNotifyResponse.success("处理成功!");
			}



			/**
			@@ -938,4 +1587,176 @@
			}


			/**
			* 获取当前可使用的套餐
			* @param memberId
			*/
			@Override
			public DiscountMember getUseDiscount(String memberId,Integer driveTime,Integer type){
			if(Objects.isNull(type)){
			return null;
			}
			String today = DateUtil.getToday();
			//判断今天是否为节假日
			Holidays holidays = new Holidays();
			holidays.setHoliday(today);
			holidays.setIsdeleted(Constants.ZERO);
			//是否是节假日 1=是；0=否
			Integer holiday = holidaysMapper.selectCount(new QueryWrapper<>(holidays))>0?1:0;
			List<DiscountMember> discountMemberList = discountMemberMapper.selectJoinList(DiscountMember.class,new MPJLambdaWrapper<DiscountMember>()
			.selectAll(DiscountMember.class)
			.select(" ( select sum(d.ride_time) from discount_log d where d.discount_member_id = t.id " +
			"and d.isdeleted = 0 and d.type = 0 and EXTRACT(DAY FROM d.create_date) = EXTRACT(DAY FROM CURRENT_DATE) ) " , DiscountMember::getUseTime)//查询今日已使用时间
			.eq(DiscountMember::getStatus,Constants.ZERO)
			.eq(DiscountMember::getMemberId,memberId)
			.apply(" t.use_start_date <= '"+today+"' and t.use_end_date >= '"+today+"' ")

			.eq(Constants.equalsInteger(holiday,Constants.ZERO),DiscountMember::getUseWorkday,Constants.ONE)
			.eq(Constants.equalsInteger(holiday,Constants.ONE),DiscountMember::getUseHoliday,Constants.ONE)

			.eq(Constants.equalsInteger(type,Constants.ZERO),DiscountMember::getIsbike,Constants.ONE)
			.eq(Constants.equalsInteger(type,Constants.ONE),DiscountMember::getIselecbike,Constants.ONE)
			.orderByDesc(DiscountMember::getLimitType)
			.orderByDesc(DiscountMember::getLimitTime)
			);
			if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isNotEmpty(discountMemberList)){
			//查看是否有无期限的套餐如果存在则直接返回无期限的套餐
			Optional<DiscountMember> optional = discountMemberList.stream().filter(i->Constants.equalsInteger(i.getLimitType(),Constants.ZERO)).findAny();
			if(optional.isPresent()){
			return optional.get();
			}
			//处理剩余时间
			for (DiscountMember discountMember:discountMemberList) {
			if(Objects.isNull(discountMember.getUseTime())){
			discountMember.setSurplusTime(discountMember.getLimitTime());
			}else if(discountMember.getUseTime()>=discountMember.getLimitTime()){
			discountMember.setSurplusTime(0);
			}else{
			discountMember.setSurplusTime(discountMember.getLimitTime() - discountMember.getUseTime());
			}
			}
			//骑行中显示剩余时间最大的
			if(Constants.equalsInteger(driveTime,Constants.ZERO)){
			List<DiscountMember> list = discountMemberList.stream().filter(i->i.getSurplusTime()>0).collect(Collectors.toList());
			if(list.size()>Constants.ZERO){
			//d1在前则升序反之降序
			list.sort((d1,d2)-> Integer.compare(d2.getSurplusTime(),d1.getSurplusTime()));
			return list.get(Constants.ZERO);
			}
			}else{
			//无无期限的套餐优先查询剩余时长大于骑行时长的信息(取时间最小的套餐) 再查询小于骑行时长的套餐
			List<DiscountMember> list = discountMemberList.stream().filter(i->i.getSurplusTime()>=driveTime).collect(Collectors.toList());
			if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isNotEmpty(list)){
			if(list.size()>Constants.ZERO){
			//d1在前则升序反之降序
			list.sort((d1,d2)-> Integer.compare(d1.getSurplusTime(),d2.getSurplusTime()));
			return list.get(Constants.ZERO);
			}

			}
			list = discountMemberList.stream().filter(i->i.getSurplusTime()<driveTime).collect(Collectors.toList());
			if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isNotEmpty(list)){
			if(list.size()>Constants.ZERO){
			list.sort((d1,d2)-> Integer.compare(d2.getSurplusTime(),d1.getSurplusTime()));
			}
			return list.get(Constants.ZERO);
			}
			}
			}
			return null;
			}



			@Override
			public void autCancel(){
			goodsorderMapper.update(null,new UpdateWrapper<Goodsorder>().lambda()
			.set(Goodsorder::getStatus,Constants.GOODSORDER_STATUS.CANCEL.getKey())
			.set(Goodsorder::getEditDate,DateUtil.getCurrDateTime())
			.eq(Goodsorder::getStatus,Constants.GOODSORDER_STATUS.UN_PAY.getKey())
			.apply(" NOW() >= create_date + INTERVAL '30 min' ")
			);
			}



			@Override
			public List<List<String>> getBikeIncomeReportVOList(Date startDate ,Date endDate){
			if( (Objects.isNull(startDate)\|\|Objects.isNull(endDate))
			\|\| startDate.getTime()>endDate.getTime()
			\|\| DateUtil.daysBetweenDates(endDate,startDate) > 30
			)
			{
			throw new BusinessException(ResponseStatus.BAD_REQUEST);
			}
			System.out.println( DateUtil.daysBetweenDates(endDate,startDate));
			//获取所有车型信息
			List<BaseParam> baseParamList = baseParamMapper.selectList(new QueryWrapper<BaseParam>().lambda().eq(BaseParam::getIsdeleted,Constants.ZERO)
			.in(BaseParam::getType,Constants.THREE,Constants.FOUR)
			.orderByAsc(BaseParam::getType,BaseParam::getSortnum)
			);
			//获取2个日期下所有天数
			List<Date> dateList = DateUtil.getDateList(startDate,endDate);
			//查询日期内的所有数据
			List<Goodsorder> goodsorderList = goodsorderMapper.selectList(new QueryWrapper<Goodsorder>().lambda().eq(Goodsorder::getType,Constants.ZERO)
			.eq(Goodsorder::getIsdeleted,Constants.ZERO)
			.eq(Goodsorder::getStatus,Constants.FOUR)
			.isNotNull(Goodsorder::getParamId)
			.ge(Goodsorder::getPayDate, Utils.Date.getStart(startDate))
			.le( Goodsorder::getPayDate, Utils.Date.getEnd(endDate))
			);

			List<List<String>> parentList = new ArrayList<>();

			for (BaseParam baseParam:baseParamList) {
			List<String> dataChildList = new ArrayList<>();
			dataChildList.add(baseParam.getName()+"(元)");
			BigDecimal totalAmount = BigDecimal.ZERO;
			for (Date date:dateList) {
			BigDecimal amount = goodsorderList.stream()
			.filter(i->StringUtils.isNotBlank(i.getParamId())&&DateUtil.getShortDateStr(date).equals(DateUtil.getShortDateStr(i.getCreateDate()))&&baseParam.getId().equals(i.getParamId()))
			.map(i->i.getCloseMoney()).reduce(BigDecimal.ZERO,BigDecimal::add);
			dataChildList.add(amount.divide(new BigDecimal("100"),2,BigDecimal.ROUND_HALF_UP).toString());
			totalAmount = amount.add(totalAmount);
			}
			BikeIncomeDetailReportVO detail = new BikeIncomeDetailReportVO();
			dataChildList.add("￥"+totalAmount);
			parentList.add(dataChildList);
			}

			List<String> dataStrList = new ArrayList<>();
			dataStrList.add("日期");
			for (Date date:dateList) {
			dataStrList.add(DateUtil.getShortDateStr(date));
			}
			dataStrList.add("总计");
			parentList.add(0,dataStrList);

			return parentList;

			}

			@Override
			public void excel(Date startDate , Date endDate, HttpServletResponse response){
			List<List<String>> data = this.getBikeIncomeReportVOList(startDate,endDate);
			try {
			String fileName = "车型收入分析_"+System.currentTimeMillis();
			String encodeFileName = URLEncoder.encode(fileName, Charset.forName("UTF-8").toString()) + ".xlsx";
			response.setHeader("Content-Disposition","attachment;filename=" + encodeFileName);
			response.setContentType("application/octet-stream");
			response.setHeader("eva-opera-type", "download");
			response.setHeader("eva-download-filename", encodeFileName);
			ExcelExporter.exportList(data, fileName, response.getOutputStream());
			} catch (IOException e) {
			throw new BusinessException(ResponseStatus.EXPORT_EXCEL_ERROR, e);
			}
			}








			}