4dkankan-center-manage/src/main/java/com/fdkankan/manage/service/impl/SceneProServiceImpl.java

package com.fdkankan.manage.service.impl;

import cn.hutool.core.io.FileUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.common.constant.ConstantFilePath;
import com.fdkankan.common.constant.SceneConstant;
import com.fdkankan.common.constant.UploadFilePath;
import com.fdkankan.manage.common.OssPath;
import com.fdkankan.manage.common.ResultCode;
import com.fdkankan.manage.exception.BusinessException;
import com.fdkankan.common.response.PageInfo;
import com.fdkankan.common.util.*;
import com.fdkankan.manage.httpClient.client.FdKKClient;
import com.fdkankan.manage.httpClient.service.LaserService;
import com.fdkankan.manage.util.CreateObjUtilSelf;
import com.fdkankan.manage.util.MangerUploadToOssUtil;
import com.fdkankan.manage.common.CameraConstant;
import com.fdkankan.manage.entity.*;
import com.fdkankan.manage.mapper.ISceneProMapper;
import com.fdkankan.manage.service.*;
import com.fdkankan.manage.util.SceneStatusUtil;
import com.fdkankan.manage.vo.request.SceneParam;
import com.fdkankan.manage.vo.response.CameraDataVo;
import com.fdkankan.manage.vo.response.GroupByCount;
import com.fdkankan.manage.vo.response.SceneVo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import javax.annotation.Resource;
import java.io.File;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

/**
 * <p>
 * pro场景表 服务实现类
 * </p>
 *
 * @author 
 * @since 2022-06-16
 */
@Service
@Slf4j
public class SceneProServiceImpl extends ServiceImpl<ISceneProMapper, ScenePro> implements ISceneProService {

    @Autowired
    private ICameraService cameraService;
    @Autowired
    ICameraDetailService cameraDetailService;
    @Autowired
    ISceneService sceneService;
    @Autowired
    ISceneCopyLogService copyLogService;
    @Autowired
    IUserIncrementService userIncrementService;
    @Autowired
    ISceneProEditService sceneProEditService;
    @Autowired
    private MangerUploadToOssUtil mangeUploadToOssUtil;
    @Autowired
    IScenePlusService scenePlusService;
    @Autowired
    IScene3dNumService scene3dNumService;
    @Autowired
    ISceneCopyLogService sceneCopyLogService;
    @Autowired
    IScenePlusExtService scenePlusExtService;
    @Autowired
    LaserService laserService;
    @Resource
    FdKKClient fdKKClient;


    @Override
    public ScenePro getByNum(String num) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ScenePro::getNum,num);
        wrapper.eq(ScenePro::getIsUpgrade,0);
        List<ScenePro> list = this.list(wrapper);
        if(list == null || list.size() <=0){
            return null;
        }
        return list.get(0);
    }

    @Override
    public HashMap<Long, Long> getCountGroupByUserId(List<Long> userIdList) {
        HashMap<Long,Long> map = new HashMap<>();
        List<GroupByCount> result = this.getBaseMapper().getCountGroupByUserId(userIdList);
        result.forEach(entity ->map.put(entity.getId(),entity.getCount()));
        return map;
    }

    @Override
    public HashMap<Long, Long> getCountGroupByCameraId(List<Long> cameraIds) {
        HashMap<Long,Long> map = new HashMap<>();
        List<GroupByCount> result = this.getBaseMapper().getCountGroupByCameraId(cameraIds);
        result.forEach(entity ->map.put(entity.getId(),entity.getCount()));
        return map;
    }

    @Override
    public void unbindCamera(Long cameraId) {
        LambdaUpdateWrapper<ScenePro> wrapper = new LambdaUpdateWrapper<>();
        wrapper.set(ScenePro::getUserId,null)
                .eq(ScenePro::getCameraId,cameraId);
        wrapper.eq(ScenePro::getIsUpgrade,0);
        this.update(wrapper);
    }

    @Override
    public List<ScenePro> getListByCameraId(Long cameraId) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ScenePro::getCameraId,cameraId);
        wrapper.eq(ScenePro::getIsUpgrade,0);
        return this.list(wrapper);
    }

    /**
     * @param payStatus -2 封存，为 1 解封
     */
    @Override
    public void lockOrUnLockBySpace(CameraDetail cameraDetail, Long cameraId, Integer payStatus) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        LambdaQueryWrapper<ScenePlus> plusWr = new LambdaQueryWrapper<>();
        Long count = 0L;
        if(payStatus == 1){         //解封，判断用户权益,用户会员权益无限容量
            count = userIncrementService.getValidCountByCameraId(cameraId);
            wrapper.orderByAsc(ScenePro::getCreateTime);
            plusWr.orderByAsc(ScenePlus::getCreateTime);
            wrapper.eq(ScenePro::getPayStatus,-2);
            plusWr.eq(ScenePlus::getPayStatus,-2);
        }else {
            wrapper.orderByDesc(ScenePro::getCreateTime);
            plusWr.orderByDesc(ScenePlus::getCreateTime);
            wrapper.eq(ScenePro::getPayStatus,1);
            plusWr.eq(ScenePlus::getPayStatus,1);
        }

        wrapper.eq(ScenePro::getCameraId,cameraId)
                .eq(ScenePro::getIsUpgrade,0);

        plusWr.eq(ScenePlus::getCameraId,cameraId);

        List<ScenePro> list = this.list(wrapper);
        List<ScenePlus> plusList = scenePlusService.list(plusWr);

        Long beyondSpace = Math.abs(cameraDetail.getUsedSpace() - cameraDetail.getTotalSpace());
        Long accumulateSpace = 0L;
        List<Long> lockedIds = new ArrayList<>();
        if(payStatus == 1){
            getScenePlusLockedIds(lockedIds,plusList,count,beyondSpace,accumulateSpace);
            getSceneLockedIds(lockedIds,list,count,beyondSpace,accumulateSpace);
        }else {
            getSceneLockedIds(lockedIds,list,count,beyondSpace,accumulateSpace);
            getScenePlusLockedIds(lockedIds,plusList,count,beyondSpace,accumulateSpace);
        }

        lockOrUnLockScenes(lockedIds,payStatus);
    }

    private void getSceneLockedIds(List<Long> lockedIds ,List<ScenePro> list,Long count,Long beyondSpace,Long accumulateSpace){
        if (list != null && list.size() > 0){
            for (ScenePro scenePro : list){
                accumulateSpace += scenePro.getSpace();
                if (count ==0 && accumulateSpace.compareTo(beyondSpace) > 0){
                    break;
                }
                lockedIds.add(scenePro.getId());
            }
        }
    }
    private void getScenePlusLockedIds(List<Long> lockedIds ,List<ScenePlus> list,Long count,Long beyondSpace,Long accumulateSpace){
        if (list != null && list.size() > 0){
            List<Long> plusIds = list.parallelStream().map(ScenePlus::getId).collect(Collectors.toList());
            HashMap<Long, ScenePlusExt> byPlusIds = scenePlusExtService.getByPlusIds(plusIds);
            for (ScenePlus scenePlus : list){
                ScenePlusExt scenePlusExt = byPlusIds.get(scenePlus.getId());
                accumulateSpace += scenePlusExt.getSpace();
                if (count ==0 && accumulateSpace.compareTo(beyondSpace) > 0){
                    break;
                }
                lockedIds.add(scenePlus.getId());
            }
        }
    }


    // payStatus 为 -2 封存，为 1 解封
    private void lockOrUnLockScenes(List<Long> lockedIds,Integer payStatus) {
        if (lockedIds == null || lockedIds.size() == 0){
            return;
        }
        LambdaUpdateWrapper<ScenePro> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(ScenePro::getPayStatus,payStatus)
                .eq(ScenePro::getIsUpgrade,0)
                .in(ScenePro::getId,lockedIds);
        this.update(updateWrapper);

        LambdaUpdateWrapper<ScenePlus> updatePlusWrapper = new LambdaUpdateWrapper<>();
        updatePlusWrapper.set(ScenePlus::getPayStatus,payStatus)
                .in(ScenePlus::getId,lockedIds);
        scenePlusService.update(updatePlusWrapper);

        this.updateOssStatus(lockedIds,payStatus);
    }

    /**
     *  修改oss status.json中 payStatus
     */
    private void updateOssStatus(List<Long> lockedIds, Integer payStatus) {
        LambdaQueryWrapper<ScenePro> proWr = new LambdaQueryWrapper<>();
        proWr.eq(ScenePro::getIsUpgrade,0);
        proWr.in(ScenePro::getId,lockedIds);
        List<ScenePro> proList = this.list(proWr);

        LambdaQueryWrapper<ScenePlus> pluWr = new LambdaQueryWrapper<>();
        pluWr.in(ScenePlus::getId,lockedIds);
        List<ScenePlus> plusList = scenePlusService.list(pluWr);
        for (ScenePro scenePro : proList) {
            this.updateOssStatus(String.format(OssPath.v3_statusPath,scenePro.getNum()),payStatus);
        }
        for (ScenePlus scenePlus : plusList) {
            this.updateOssStatus(String.format(OssPath.v4_statusPath,scenePlus.getNum()),payStatus);
        }

    }

    /**
     * 从oss中获取文件，并重写,上传替换
     */
    private void updateOssStatus(String path,Integer payStatus) {
        try {
            if(!mangeUploadToOssUtil.existKey(path)){
                return;
            }
            String data = mangeUploadToOssUtil.getObjectContent("4dkankan",path);
            if(StringUtils.isBlank(data)){
                return;
            }
            JSONObject jsonObject = JSONObject.parseObject(data);
            jsonObject.put("payStatus",payStatus);
            String json = JSONUtil.toJsonStr(jsonObject);
            FileUtils.writeFile(OssPath.localStatusPath ,json);
            log.info("updateOssStatus--localPath:{},ossPath:{}",OssPath.localStatusPath,path);
            mangeUploadToOssUtil.upload(OssPath.localStatusPath,path);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            FileUtil.del(OssPath.localStatusPath);
        }
    }


    @Override
    public PageInfo pageList(SceneParam param) {
        if(param.getType() == 2){  //深时
            if(param.getCompanyId()!= null){ //客户场景
                List<CameraDetail> cameraDetails = cameraDetailService.getListByCompanyId(param.getCompanyId());
                if(cameraDetails.size() >0){
                    Set<Long> cameraIds = cameraDetails.stream()
                            .filter(entity -> entity.getGoodsId() == 10).map(CameraDetail::getCameraId).collect(Collectors.toSet());
                    List<Camera> cameraList = cameraService.listByIds(cameraIds);
                    List<String> snCodes = cameraList.stream().map(Camera::getSnCode).collect(Collectors.toList());
                    param.setSnCodes(snCodes);
                }
            }
            return laserService.pageList(param);
        }
        if(param.getType() == 3){ //双目lite
           return sceneService.pageList(param);
        }
        Page<SceneVo> page = this.getBaseMapper().pageList(new Page<>(param.getPageNum(),param.getPageSize()),param);
        List<SceneVo> records = page.getRecords();
        HashMap<String,SceneCopyLog> map = null;
        if(records.size() >0){
            List<String> numList = records.parallelStream().map(SceneVo::getNum).collect(Collectors.toList());
            map = copyLogService.getByNewNumList(numList);
        }
        for (SceneVo record : page.getRecords()) {
            record.setStatusString(SceneStatusUtil.getStatusString(record));
            if(map !=null ){
                SceneCopyLog sceneCopyLog = map.get(record.getNum());
                if(sceneCopyLog != null){
                    record.setCopyTime(sceneCopyLog.getCreateTime());
                    record.setIsCopy(true);
                }
            }
        }
        return PageInfo.PageInfo(page);
    }

    @Override
    public void move(SceneParam param) {
        Camera camera = cameraService.getBySnCode(param.getSnCode());
        if(camera == null){
            throw new BusinessException(ResultCode.CAMERA_SN_NOT_EXIST);
        }
        CameraDetail cameraDetail = cameraDetailService.getByCameraId(camera.getId());
        if(cameraDetail == null){
            throw new BusinessException(ResultCode.CAMERA_SN_NOT_EXIST);
        }
        ScenePro scenePro = this.getByNum(param.getNum());
        ScenePlus scenePlus = scenePlusService.getByNum(param.getNum());
        if((scenePro == null || scenePro.getCameraId() == null ) && (scenePlus== null || scenePlus.getCameraId() == null)){
            throw new BusinessException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }
        Integer status =  scenePro == null ? scenePlus.getSceneStatus() : scenePro.getStatus();
        if(status == 0){
            throw new BusinessException(SceneConstant.FAILURE_CODE_5037, SceneConstant.FAILURE_MSG_5037);
        }

        Long cameraId = scenePro == null ? scenePlus.getCameraId() : scenePro.getCameraId();
        Long space = scenePro == null ? 0 :scenePro.getSpace();
        if(scenePlus !=null){
            ScenePlusExt scenePlusExt = scenePlusExtService.getByPlusId(scenePlus.getId());
            space = scenePlusExt.getSpace();
        }
        space = space == null ? 0 :space;
        Long newUseSpace = space + cameraDetail.getUsedSpace();
        Long count = userIncrementService.getValidCountByCameraId(cameraId);
        if(count<=0 && newUseSpace  > cameraDetail.getTotalSpace()){
            throw new BusinessException(ResultCode.CAMERA_SPACE_ERROR);
        }

        Camera oldCamera = cameraService.getById(cameraId);
        if(oldCamera == null){
            throw new BusinessException(ResultCode.CAMERA_NOT_EXIST);
        }
        CameraDetail oldCameraDetail = cameraDetailService.getByCameraId(oldCamera.getId());
        if(oldCameraDetail == null){
            throw new BusinessException(ResultCode.CAMERA_NOT_EXIST);
        }
        if(!oldCameraDetail.getType().equals(cameraDetail.getType())){
            throw new BusinessException(ResultCode.CAMERA_TYPE_NOT_ERROR);
        }
        Long oldUseSpace = oldCameraDetail.getUsedSpace() - space < 0 ? 0 : oldCameraDetail.getUsedSpace() - space;
        oldCameraDetail.setUsedSpace(oldUseSpace);
        Long subSpace =  oldCameraDetail.getTotalSpace() - oldUseSpace;
        if(subSpace >0){    //有剩余容量解封容量内场景
            this.lockOrUnLockBySpace(oldCameraDetail,oldCameraDetail.getCameraId(),1);
        }
        cameraDetailService.updateById(oldCameraDetail);

        cameraDetail.setUsedSpace(newUseSpace);
        cameraDetailService.updateById(cameraDetail);

        if(scenePro!=null){
            LambdaUpdateWrapper<ScenePro> wrapper = new LambdaUpdateWrapper<>();
            wrapper.eq(ScenePro::getId,scenePro.getId());
            wrapper.set(ScenePro::getCameraId,camera.getId());
            wrapper.set(ScenePro::getUserId,cameraDetail.getUserId());
            this.update(wrapper);
        }
        if(scenePlus!=null){
            LambdaUpdateWrapper<ScenePlus> wrapper = new LambdaUpdateWrapper<>();
            wrapper.eq(ScenePlus::getId,scenePlus.getId());
            wrapper.set(ScenePlus::getCameraId,camera.getId());
            wrapper.set(ScenePlus::getUserId,cameraDetail.getUserId());
            scenePlusService.update(wrapper);
        }
        if(cameraDetail.getType() == 10){       //深时场景
            laserService.move(param.getNum(),oldCamera.getSnCode(),camera.getSnCode());
        }

    }

    @Override
    public void copy(String sceneNum) throws Exception {
        ScenePro scenePro = this.getByNum(sceneNum);
        ScenePlus scenePlus = scenePlusService.getByNum(sceneNum);
        if((scenePro == null || scenePro.getCameraId() == null ) && (scenePlus== null || scenePlus.getCameraId() == null)){
            throw new BusinessException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }
        Long cameraId = scenePro == null ? scenePlus.getCameraId() : scenePro.getCameraId();
        Camera camera = cameraService.getById(cameraId);
        if(camera == null){
            throw new BusinessException(CameraConstant.FAILURE_CODE_6029, CameraConstant.FAILURE_MSG_6029);
        }
        CameraDetail detailEntity = cameraDetailService.getByCameraId(cameraId);
        if(detailEntity == null){
            throw new BusinessException(CameraConstant.FAILURE_CODE_6029, CameraConstant.FAILURE_MSG_6029);
        }

        HashMap<String, Object> param = new HashMap<>();
        param.put("num",sceneNum);
        fdKKClient.copyScene(param,"m_a_n_a_g_e");

    }

    @Override
    public void deleteByNum(String num) {
        ScenePro scenePro = this.getByNum(num);
        if(scenePro!=null){
            this.removeById(scenePro.getId());
        }
        Scene scene = sceneService.getByNum(num);
        if(scene!=null){
            sceneService.removeById(scene.getId());
        }
        ScenePlus scenePlus = scenePlusService.getByNum(num);
        if(scenePlus!=null){
            scenePlusService.removeById(scenePlus.getId());
        }
        laserService.delete(num);
    }

    @Override
    public Long getKkCount(List<String> asList, String startTime) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(ScenePro::getSceneSource,asList);
        wrapper.eq(ScenePro::getIsUpgrade,0);
        wrapper.lt(ScenePro::getCreateTime,startTime);
        long count = this.count(wrapper);

        LambdaQueryWrapper<ScenePlus> wrapper2 = new LambdaQueryWrapper<>();
        wrapper2.in(ScenePlus::getSceneSource,asList);
        wrapper2.lt(ScenePlus::getCreateTime,startTime);
        long count1 = scenePlusService.count(wrapper2);
        return count + count1;
    }
    @Override
    public Long getSsCount(List<String> asList, String startTime) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(ScenePro::getSceneSource,asList);
        wrapper.eq(ScenePro::getIsUpgrade,0);
        wrapper.lt(ScenePro::getCreateTime,startTime);
        LambdaQueryWrapper<ScenePlus> wrapper2 = new LambdaQueryWrapper<>();
        wrapper2.in(ScenePlus::getSceneSource,asList);
        wrapper2.lt(ScenePlus::getCreateTime,startTime);
        long count = scenePlusService.count(wrapper2);
        return this.count(wrapper) + count;
    }
    @Override
    public Long getSsObjCount(List<String> asList, String startTime) {
        LambdaQueryWrapper<ScenePro> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(ScenePro::getSceneSource,asList);
        wrapper.eq(ScenePro::getIsUpgrade,0);
        wrapper.lt(ScenePro::getCreateTime,startTime);
        wrapper.eq(ScenePro::getIsObj,1);
        LambdaQueryWrapper<ScenePlus> wrapper2 = new LambdaQueryWrapper<>();
        wrapper2.in(ScenePlus::getSceneSource,asList);
        wrapper2.lt(ScenePlus::getCreateTime,startTime);
        List<ScenePlus> list = scenePlusService.list(wrapper2);
        List<Long> plusIds = list.stream().map(ScenePlus::getId).collect(Collectors.toList());

        LambdaQueryWrapper<ScenePlusExt> wrapper3 = new LambdaQueryWrapper<>();
        wrapper3.in(ScenePlusExt::getPlusId,plusIds);
        wrapper3.eq(ScenePlusExt::getIsObj,1);
        long count = scenePlusExtService.count(wrapper3);
        return this.count(wrapper) + count;
    }
}