111

k94314517

2025-03-04 bfd4f08b4304cac2822db86de3712e1c6b37f6ab

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

@@ -13,6 +13,8 @@
import com.doumee.core.model.PageData;
import com.doumee.core.model.PageWrap;
import com.doumee.core.utils.DateUtil;
import com.doumee.core.utils.HttpsUtil;
import com.doumee.core.utils.StringTools;
import com.doumee.core.utils.Utils;
import com.doumee.dao.business.ActionLogMapper;
import com.doumee.dao.business.BikesMapper;
@@ -25,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;
@@ -244,6 +247,8 @@
                Arrays.asList(Constants.MEMBER_RIDES_STATUS.RIDES_RUNNING.getKey(),Constants.MEMBER_RIDES_STATUS.BACK_CYCLING.getKey()));
        queryWrapper
                .selectAs(MemberRides::getId,MemberRidesDTO::getId)
                .selectAs(MemberRides::getDiscountPrice,MemberRidesDTO::getDiscountPrice)
                .selectAs(MemberRides::getType,MemberRidesDTO::getType)
                .selectAs(Member::getOpenid,MemberRidesDTO::getOpenid)
                .selectAs(MemberRides::getBikeCode,MemberRidesDTO::getBikeCode)
                .selectAs(MemberRides::getCloseStatus,MemberRidesDTO::getCloseStatus)
@@ -369,8 +374,33 @@
        update.setBackUserid(user.getId());
        update.setBackType(Constants.ONE);
        update.setStatus(Constants.MEMBER_RIDES_STATUS.BACK_CYCLING.getKey());
        update.setBackSiteId(collect.get(Constants.FORCE_BACK_SITE).getCode());
        update.setBackLockId(Constants.formatIntegerFromStr(collect.get(Constants.FORCE_BACK_LOCK).getCode()));
        String logInfo = null;
        Bikes bike =null;
        if(Constants.equalsInteger(model.getType(),Constants.ZERO)){
            //如果是自行车，绑定到虚拟站点和锁头
            update.setBackSiteId(collect.get(Constants.FORCE_BACK_SITE).getCode());
            update.setBackLockId(Constants.formatIntegerFromStr(collect.get(Constants.FORCE_BACK_LOCK).getCode()));
            //插入虚拟锁头和站点上-------
            bike = new Bikes();
            bike.setIsdeleted(Constants.ZERO);
            bike.setCode(model.getBikeCode());
            bike.setType(model.getType());
            bike.setSiteId(update.getBackSiteId());
            bike.setLockId(update.getBackLockId());
            if(bikesMapper.selectCount(new QueryWrapper<>(bike)) == 0){
                bike.setId(Constants.getUUID());
                bike.setParamId(model.getParamId());
                bike.setLastBackDate(model.getRentDate());
                bike.setStatus(Constants.ZERO);
                bike.setType(Constants.ZERO);
                bike.setForceBackInfo("强制还车绑定");
                bikesMapper.insert(bike);
            }
        }else{
            //如果是电车，请求web端接口关闭车辆信息
            bike  = sendCloseElecBikeRequest(model.getOrdreId(),memberRides.getBikeCode());
        }
        logInfo = bike!=null?bike.getForceBackInfo():null;
        Integer freeRentTime = Integer.valueOf(collect.get(Constants.FREE_RENT_TIME).getCode());
        Integer rideTime = DateUtil.betweenMin(model.getRentDate(), update.getBackDate());
        //计算骑行计费时长
@@ -381,23 +411,6 @@
        String beforeContent = JSONObject.toJSONString(model);
        //修改后
        String after = JSONObject.toJSONString(update);

        //插入虚拟锁头和站点上-------
        Bikes bike = new Bikes();
        bike.setIsdeleted(Constants.ZERO);
        bike.setCode(model.getBikeCode());
        bike.setType(model.getType());
        bike.setSiteId(update.getBackSiteId());
        bike.setLockId(update.getBackLockId());
        if(bikesMapper.selectCount(new QueryWrapper<>(bike)) == 0){
            bike.setId(Constants.getUUID());
            bike.setParamId(model.getParamId());
            bike.setLastBackDate(model.getRentDate());
            bike.setStatus(Constants.ZERO);
            bike.setType(Constants.ZERO);
            bike.setInfo("强制还车绑定");
            bikesMapper.insert(bike);
        }

        ActionLog log = new ActionLog();
        log.setId(Constants.getUUID());
@@ -412,6 +425,7 @@
        log.setObjType(Constants.ActionLogObjType.memberrides);
        log.setResult(Constants.ZERO);
        log.setObjId(model.getId());
        log.setInfo(logInfo);
        log.setType(Constants.ACTIONLOG_TYPE.FORCE_BACK.getKey());
        log.setContent(Constants.ACTIONLOG_TYPE.FORCE_BACK.getInfo());
        log.setTitle(Constants.ACTIONLOG_TYPE.FORCE_BACK.getName());
@@ -421,7 +435,84 @@
        actionLogMapper.insert(log);

    }
    /**
     *  如果是电车，请求web端接口关闭车辆信息
     */
    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)
                .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("id", goodOrderId);
                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！");
        }
        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";
        JSONObject param = new JSONObject();
        param.put("clientId",StringTools.leftTrip("0067244400211",'0'));
        param.put("type",0);//0开锁 1关锁
        String res = HttpsUtil.postJsonString(url,param.toJSONString());
        System.out.println(res);
    }
    public ConcurrentMap<String,Integer> cacheOpenLock = new ConcurrentReferenceHashMap<>();

    @Override
@@ -438,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"));
@@ -451,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("/");
@@ -461,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(), "扫码无效，该站点锁头暂不支持借出业务哦！");
            }
            //查询锁头是否存在车辆 以及是否正常
@@ -515,7 +603,6 @@
        }finally {
            cacheOpenLock.remove(code);
        }

    }

    private boolean isValidePricingType(Locks locks,MemberRides memberRides ) {
@@ -580,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);
@@ -591,6 +726,107 @@
        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());
        memberRidesResponse.setRidesType(bikeType);
        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