111

k94314517

2025-02-28 04dba6a17f836b5fbdf0eedff8a129c6785fd8a2

 server/services/src/main/java/com/doumee/service/business/impl/MemberRidesServiceImpl.java

@@ -27,6 +27,7 @@
import com.doumee.dao.business.web.response.BikeLogDTO;
import com.doumee.dao.business.web.response.MemberRidesDTO;
import com.doumee.dao.business.web.response.MemberRidesDetailResponse;
import com.doumee.dao.business.web.response.MemberRidesResponse;
import com.doumee.dao.system.SystemDictDataMapper;
import com.doumee.dao.system.model.SystemDictData;
import com.doumee.service.business.DeviceService;
@@ -397,7 +398,7 @@
            }
        }else{
            //如果是电车，请求web端接口关闭车辆信息
            bike =   sendCloseElecBikeRequest(memberRides.getBikeCode(),Constants.ONE);
            bike  = sendCloseElecBikeRequest(model.getOrdreId(),memberRides.getBikeCode());
        }
        logInfo = bike!=null?bike.getForceBackInfo():null;
        Integer freeRentTime = Integer.valueOf(collect.get(Constants.FREE_RENT_TIME).getCode());
@@ -437,7 +438,7 @@
    /**
     *  如果是电车，请求web端接口关闭车辆信息
     */
    private Bikes sendCloseElecBikeRequest(String bikeCode,int type) {
    private Bikes sendCloseElecBikeRequest(String goodOrderId,String bikeCode) {
        Bikes  bike = bikesMapper.selectOne(new QueryWrapper<Bikes>().lambda()
                .eq(Bikes::getType,Constants.ONE)
                .eq(Bikes::getIsdeleted,Constants.ZERO)
@@ -447,30 +448,62 @@
            return null;
        }
        bike.setForceBackInfo("强制还车关闭车锁失败！");
        if(StringUtils.isNotBlank(bike.getDeviceSn())){
        if(StringUtils.isNotBlank(bike.getDeviceSn())) {
            try {
                //请求地址
                String url = systemDictDataBiz.queryByCode(Constants.SYSTEM,Constants.ELEC_BIKE_CONTRIL_API_URL).getCode();
                String url = systemDictDataBiz.queryByCode(Constants.SYSTEM, Constants.ELEC_BIKE_CONTRIL_API_URL).getCode();
                JSONObject param = new JSONObject();
                param.put("clientId",StringTools.leftTrip(bike.getDeviceSn(),'0'));
                param.put("type",type);//0开锁 1关锁
                String res = HttpsUtil.postJsonString(url,param.toJSONString());
                param.put("id", goodOrderId);
                String res = HttpsUtil.postJsonString(url, param.toJSONString());
                JSONObject json = JSONObject.parseObject(res);
                if(json.get("code").equals("200")){
                if (json.get("code").equals("200")) {
                    //发起指令成功
                    bike.setForceBackInfo("强制还车关闭车锁成功！");
                }else{
                    bike.setForceBackInfo("强制还车关闭车锁失败！"+json.get("msg"));
                } else {
                    bike.setForceBackInfo("强制还车关闭车锁失败！" + json.get("msg"));
                }
            }catch (Exception e){
            } catch (Exception e) {
                e.printStackTrace();
            }
        }else{
            bike.setForceBackInfo("强制还车关闭车锁失败,未绑定控制器sn！");
        }
        bikesMapper.updateById(bike);
        return bike;
    }
//    private Bikes sendCloseElecBikeRequest(String bikeCode,int type) {
//        Bikes  bike = bikesMapper.selectOne(new QueryWrapper<Bikes>().lambda()
//                .eq(Bikes::getType,Constants.ONE)
//                .eq(Bikes::getIsdeleted,Constants.ZERO)
//                .eq(Bikes::getCode,bikeCode)
//        );
//        if(bike == null){
//            return null;
//        }
//        bike.setForceBackInfo("强制还车关闭车锁失败！");
//        if(StringUtils.isNotBlank(bike.getDeviceSn())){
//            try {
//                //请求地址
//                String url = systemDictDataBiz.queryByCode(Constants.SYSTEM,Constants.ELEC_BIKE_CONTRIL_API_URL).getCode();
//                JSONObject param = new JSONObject();
//                param.put("clientId",StringTools.leftTrip(bike.getDeviceSn(),'0'));
//                param.put("type",type);//0开锁 1关锁
//                String res = HttpsUtil.postJsonString(url,param.toJSONString());
//                JSONObject json = JSONObject.parseObject(res);
//                if(json.get("code").equals("200")){
//                    //发起指令成功
//                    bike.setForceBackInfo("强制还车关闭车锁成功！");
//                }else{
//                    bike.setForceBackInfo("强制还车关闭车锁失败！"+json.get("msg"));
//                }
//            }catch (Exception e){
//                e.printStackTrace();
//            }
//        }else{
//            bike.setForceBackInfo("强制还车关闭车锁失败,未绑定控制器sn！");
//        }
//        bikesMapper.updateById(bike);
//        return bike;
//    }

    public static void main(String[] args) {
        String url = "http://localhost:10025/jtt808/device/8500";
@@ -496,6 +529,7 @@
            Goodsorder goodsorder = goodsorderService.findOneByWrapper(new QueryWrapper<Goodsorder>()
                    .eq("isdeleted", Constants.ZERO)
                    .eq("status", Constants.goodsorderStatus.pay)
                    .eq("type", Constants.ZERO)
                    .eq("member_id", memberId)
                    .orderByDesc("create_date")
                    .last("limit 1"));
@@ -509,7 +543,7 @@
            //判断是否处于营业时间
            goodsorderService.checkBusiness();
            //查询是否处于骑行中
            if (memberRidesMapper.selectCount(new QueryWrapper<MemberRides>().eq("member_id", memberId).in("status", 0, 1)) > Constants.ZERO) {
            if (memberRidesMapper.selectCount(new QueryWrapper<MemberRides>().eq("member_id", memberId).in("status", 0, 1, 4)) > Constants.ZERO) {
                throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "存在骑行中车辆，无法扫码");
            }
            String[] codes = code.split("/");
@@ -519,10 +553,6 @@
                    .eq(Locks::getIsdeleted, Constants.ZERO)
                    .last("limit 1"));
            if (Objects.isNull(locks)) {
//            locks =new Locks();
//            locks.setCode(codes[1]);
//            locks.setSiteId(codes[0]);
//            deviceService.getLockInfo(locks);
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "扫码无效，该站点锁头暂不支持借出业务哦！");
            }
            //查询锁头是否存在车辆 以及是否正常
@@ -573,7 +603,6 @@
        }finally {
            cacheOpenLock.remove(code);
        }

    }

    private boolean isValidePricingType(Locks locks,MemberRides memberRides ) {
@@ -638,6 +667,54 @@
        return true;
    }


    public void dealMemberRidesData(String paramId,MemberRides memberRides){
        Date date =new Date();
        QueryWrapper<PricingParam> param = new QueryWrapper<>();
        param.lambda().eq(PricingParam::getStatus,Constants.ZERO);
        param.lambda().eq(PricingParam::getIsdeleted,Constants.ZERO);
        param.lambda().le(PricingParam::getStartDate,date);
        param.lambda().ge(PricingParam::getEndDate,date);
        param.lambda().last(" limit 1" ) ;
        param.lambda().orderByAsc(PricingParam::getSortnum);
        //查询优先级最高（排序码最小的）可用配价方案
        PricingParam pp = pricingParamMapper.selectOne(param);
        if(pp == null){
            //如果车辆未设置配价方案，提示开锁失败！
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), " 该车型暂时不能借车操作哦，请更换其他车型重试哦！");
        }
        QueryWrapper<PricingDetail> detail = new QueryWrapper<>();
        detail.lambda().eq(PricingDetail::getBikeTypeId,paramId);
        detail.lambda().eq(PricingDetail::getPricePramId,pp.getId());
        detail.lambda().eq(PricingDetail::getIsdeleted,Constants.ZERO);
        detail.lambda().last(" limit 1" ) ;
        //查询优先级最高（排序码最小的）可用配价方案
        PricingDetail pricingDetail = pricingDetailMapper.selectOne(detail);
        if(pricingDetail == null){
            throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), " 该车型暂时不能借车操作哦，请更换其他车型重试哦~");
        }
        String nowDate = DateUtil.getDateLong(date);
        Holidays holidays = new Holidays();
        holidays.setHoliday(nowDate);
        holidays.setIsdeleted(Constants.ZERO);
        //检查是否节假日
        if(holidaysMapper.selectCount(new QueryWrapper<>(holidays)) >0){
            //如果是节假日
            memberRides.setBasePrice(pricingDetail.getHolidayBasePrice());
            memberRides.setBaseTime(pricingDetail.getHolidayBaseTime());
            memberRides.setUnitPrice(pricingDetail.getHolidayUnitPrice());
            memberRides.setUnitTime(pricingDetail.getHolidayUnitTime());
            memberRides.setIsHoliday(Constants.ONE);
        }else{
            //如果是工作日
            memberRides.setBasePrice(pricingDetail.getBasePrice());
            memberRides.setBaseTime(pricingDetail.getBaseTime());
            memberRides.setUnitPrice(pricingDetail.getUnitPrice());
            memberRides.setUnitTime(pricingDetail.getUnitTime());
            memberRides.setIsHoliday(Constants.ZERO);
        }
    }

    @Override
    public MemberRidesDetailResponse refreshLock(String id){
        MemberRides memberRides = memberRidesMapper.selectById(id);
@@ -649,6 +726,106 @@
        return memberRidesDetailResponse;
    }


    /**
     * 获取车辆车型等数据信息
     */
    @Override
    public MemberRidesResponse getBikeChargingRule(String code,String memberId){
        if(StringUtils.isBlank(code)){
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"请扫描正确的车辆码");
        }
        //查询是否处于骑行中
        if (memberRidesMapper.selectCount(new QueryWrapper<MemberRides>().eq("member_id", memberId).in("status", 0, 1 ,4 )) > Constants.ZERO) {
            throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "存在骑行中车辆，无法扫码");
        }
        Integer bikeType = Constants.ZERO;
        //根据前缀区分是否为电车二维码
        if(code.startsWith(Constants.EBIKE_PREFIX)){
            bikeType = Constants.ONE;
            code = code.replaceFirst(Constants.EBIKE_PREFIX,"");
        }
        MemberRidesResponse memberRidesResponse = new MemberRidesResponse();
        Bikes bike= new Bikes();
        if(Constants.equalsInteger(bikeType,Constants.ZERO)){
            if(StringUtils.isBlank(code) ||  code.split("/").length != 2){
                throw  new BusinessException(ResponseStatus.BAD_REQUEST.getCode(), "对不起，该站点编号不存在，请尝试更换车辆！");
            }
            //判断是否处于营业时间
            goodsorderService.checkBusiness();
            String[] codes = code.split("/");

            Locks locks = locksMapper.selectOne(new QueryWrapper<Locks>()
                    .lambda().eq(Locks::getCode, codes[1])
                    .eq(Locks::getSiteId, codes[0])
                    .eq(Locks::getIsdeleted, Constants.ZERO)
                    .last("limit 1"));
            if (Objects.isNull(locks)) {
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "扫码无效，该站点锁头暂不支持借出业务哦！");
            }
            //查询锁头是否存在车辆 以及是否正常
            if (Constants.formatIntegerNum(locks.getStatus())!=Constants.ZERO) {
                locks =new Locks();
                locks.setCode(Constants.formatIntegerFromStr(codes[1]));
                locks.setSiteId(codes[0]);
                deviceService.getLockInfo(locks);
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(), "当前车辆暂时无法使用，请稍后重试或更换其它车辆~");
            }
            if (StringUtils.isBlank(locks.getBikeCode())) {
                locks =new Locks();
                locks.setCode(Constants.formatIntegerFromStr(codes[1]));
                locks.setSiteId(codes[0]);
                locks.setId(codes[1]);
                deviceService.getLockInfo(locks);
                throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "当前车辆暂时无法使用，请稍后重试或更换其它车辆！");
            }
            bike.setLockId(locks.getCode());
            bike.setSiteId(locks.getSiteId());
            //查询车辆信息
            bike = bikesMapper.selectOne(new QueryWrapper<>(bike).last("limit 1"));
            if(bike == null && StringUtils.isBlank(bike.getParamId())){
                //如果车辆类型是空
                throw  new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), " 该车型暂时不能借车操作哦，请更换其他车型重试！");
            }
        }else{
            //查询车辆类型
            bike = bikesMapper.selectOne(new QueryWrapper<Bikes>().lambda().eq(Bikes::getCode,code).eq(Bikes::getIsdeleted,Constants.ZERO).last(" limit 1 "));
            if(Objects.isNull(bike)){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"请扫描正确的车辆码：【未查询到车辆信息】");
            }
            if(!Constants.equalsInteger(bike.getStatus(),Constants.ZERO)){
                throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"对不起，该车辆已被锁定借用，请尝试更换其他车辆！");
            }
            if(StringUtils.isBlank(bike.getParamId())){
                throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"车辆类型异常，请联系管理员！");
            }
            memberRidesResponse.setVoltageStatus(goodsorderService.getVoltageStatus(bike));
        }
        BaseParam baseParam = baseParamMapper.selectById(bike.getParamId());
        if(Objects.isNull(baseParam)){
            throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"当前车辆类型无法租赁，请联系管理员！");
        }
        memberRidesResponse.setBikeCode(bike.getCode());
        memberRidesResponse.setBikeType(baseParam.getName());
        MemberRides memberRides = new MemberRides();
        this.dealMemberRidesData(baseParam.getId(),memberRides);
        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()));
        //查询当前的骑行套餐
        memberRidesResponse.setDiscountMember(goodsorderService.getUseDiscount(memberId,Constants.ZERO,bikeType));
        return memberRidesResponse;
    }





    /**
     * 锁头信息上报
     * @param locks