4dkankan-center-user/src/main/java/com/fdkankan/ucenter/service/impl/CameraServiceImpl.java

package com.fdkankan.ucenter.service.impl;

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.fdkankan.common.exception.BusinessException;
import com.fdkankan.db.response.PageInfo;
import com.fdkankan.common.util.DateUtil;
import com.fdkankan.common.util.FileSizeUtil;
import com.fdkankan.ucenter.entity.*;
import com.fdkankan.ucenter.mapper.ICameraMapper;
import com.fdkankan.ucenter.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.ucenter.util.DateUserUtil;
import com.fdkankan.ucenter.vo.request.CameraParam;
import com.fdkankan.ucenter.vo.response.CameraAppVo;
import com.fdkankan.ucenter.vo.response.CameraSpaceVo;
import com.fdkankan.ucenter.vo.response.CameraVo;
import com.fdkankan.ucenter.vo.response.GroupByCount;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.joda.time.Days;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 相机主表 服务实现类
 * </p>
 *
 * @author 
 * @since 2022-07-04
 */
@Service
public class CameraServiceImpl extends ServiceImpl<ICameraMapper, Camera> implements ICameraService {

    @Autowired
    IUserService userService;
    @Autowired
    FdkkLaserService fdkkLaserService;
    @Autowired
    ISceneProService sceneProService;
    @Autowired
    ICameraSpaceService cameraSpaceService;
    @Autowired
    IUserIncrementService userIncrementService;
    @Autowired
    ISceneService sceneService;
    @Autowired
    ISceneResourceCameraService sceneResourceCameraService;
    @Autowired
    ICameraDetailService cameraDetailService;
    @Autowired
    IScenePlusService scenePlusService;
    @Autowired
    ISceneCooperationService sceneCooperationService;

    @Override
    public Camera getBySnCode(String snCode) {
        LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Camera::getSnCode,snCode);
        List<Camera> list = this.list(wrapper);
        if(list !=null && list.size() > 0){
            return list.get(0);
        }
        return null;
    }

    @Override
    public List<Camera> getCameraLikeSnCode(String snCode) {
        LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(Camera::getSnCode,snCode);
        return this.list(wrapper);
    }

    @Override
    public HashMap<Long, Camera> getByIds(List<Long> cameraIds) {
        LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(Camera::getId,cameraIds);
        List<Camera> list = this.list(wrapper);
        HashMap<Long, Camera> map = new HashMap<>();
        list.forEach(entity -> map.put(entity.getId(),entity));
        return map;
    }

    @Override
    public PageInfo pageList(CameraParam param) {
        User user = userService.getByUserName(param.getUserName());
        param.setUserId(user.getId());
        Page<CameraVo> page = this.getBaseMapper().pageList(new Page<>(param.getPageNum(),param.getPageSize()),param);
        List<Long> cameraIdList = page.getRecords().parallelStream().map(CameraVo::getId).collect(Collectors.toList());
        HashMap<Long,GroupByCount> sceneNumMap = new HashMap<>();      //场景数量,最后拍摄时间
        HashMap<Long, CameraSpaceVo> cameraSpaceMap = new HashMap<>();   //到期时间
        HashMap<Long, UserIncrement> incrementMap = new HashMap<>();   //到期时间，是否过期
        if(cameraIdList.size() >0){
            sceneNumMap =  sceneProService.findSceneNumByCameraIds(cameraIdList);
            cameraSpaceMap = cameraSpaceService.getVoListByCameraIds(cameraIdList);
            incrementMap = userIncrementService.findByCameraIds(cameraIdList);
        }
        for (CameraVo responseCamera : page.getRecords()) {
            responseCamera.setCameraType(param.getCameraType());
            if (responseCamera.getType() != 0){
                responseCamera.setUsedSpaceStr(FileSizeUtil.formatFileSize(Long.parseLong(responseCamera.getUsedSpace())));
                responseCamera.setTotalSpaceStr(FileSizeUtil.formatFileSize(Long.parseLong(responseCamera.getTotalSpace())));
                String usedSpace = String.valueOf(FileSizeUtil.formetFileSize(Long.parseLong(responseCamera.getUsedSpace()), FileSizeUtil.SIZETYPE_GB));
                String totalSpace = String.valueOf(FileSizeUtil.formetFileSize(Long.parseLong(responseCamera.getTotalSpace()), FileSizeUtil.SIZETYPE_GB));
                responseCamera.setUsedSpace(usedSpace);
                responseCamera.setTotalSpace(totalSpace);
            }
            if(cameraSpaceMap.get(responseCamera.getId()) !=null){
                responseCamera.setSpace((long)FileSizeUtil.formetFileSize(cameraSpaceMap.get(responseCamera.getId()).getSpace().longValue(), FileSizeUtil.SIZETYPE_GB));
                responseCamera.setSpaceStr(FileSizeUtil.formatFileSize(cameraSpaceMap.get(responseCamera.getId()).getSpace().longValue()));
                responseCamera.setSpaceEndStr(DateUtil.date2String(cameraSpaceMap.get(responseCamera.getId()).getSpaceEndTime(), DateUtil.YYYY_MM_DD_DATE_FORMAT));
                if(Days.daysBetween(new DateTime(), new DateTime(cameraSpaceMap.get(responseCamera.getId()).getSpaceEndTime())).getDays() < 7){
                    responseCamera.setIsExpire(true);
                }
            }
            if(incrementMap.get(responseCamera.getId()) != null){
                responseCamera.setUserIncrementId(incrementMap.get(responseCamera.getId()).getId());
                responseCamera.setSpaceEndStr(DateUserUtil.getDayTime(incrementMap.get(responseCamera.getId()).getIncrementEndTime()));
                String dayTime = incrementMap.get(responseCamera.getId()).getIncrementEndTime();
                Integer surplusDate = Days.daysBetween(new DateTime(), new DateTime( DateUserUtil.getDate(dayTime))).getDays();
                if(surplusDate < 31){
                    responseCamera.setIsExpire(true);
                    responseCamera.setSurplusDate(surplusDate);
                }else {
                    responseCamera.setIsExpire(false);
                }
            }


            if(responseCamera.getType() == 10){
                Map<String, String> params = new HashMap<>();
                params.put("snCode", responseCamera.getSnCode());
                responseCamera.setSceneNum(fdkkLaserService.getLaserSceneNum(params));
            }else{
                Integer sceneNum = sceneNumMap.get(responseCamera.getId()) == null ? 0 : Math.toIntExact(sceneNumMap.get(responseCamera.getId()).getCount());
                String lastTime = sceneNumMap.get(responseCamera.getId()) == null ? "" : sceneNumMap.get(responseCamera.getId()).getLastTime();
                responseCamera.setSceneNum(sceneNum);
                responseCamera.setLastTime(lastTime);
            }
        }
        return PageInfo.PageInfo(page);
    }

    @Override
    public HashMap<String, Object> deadline(String username) {
        //7天内过期的集合
        List<CameraSpaceVo> cameraSpaceList = new ArrayList<>();
        //所有期限的集合
        List<CameraSpaceVo> cameraSpaceAll = new ArrayList<>();
        User user = userService.getByUserName(username);
        CameraParam param = new CameraParam();
        param.setPageNum(1);
        param.setPageSize(100);
        param.setUserId(user.getId());
        Page<CameraVo> page = this.getBaseMapper().pageList(new Page<>(param.getPageNum(),param.getPageSize()),param);
        List<Long> cameraIdList = page.getRecords().parallelStream().map(CameraVo::getId).collect(Collectors.toList());
        if(cameraIdList.size() >0){
            HashMap<Long, CameraSpaceVo> cameraSpaceMap = cameraSpaceService.getVoListByCameraIds(cameraIdList);
            for (CameraVo responseCamera : page.getRecords()) {
                CameraSpaceVo cameraSpace = cameraSpaceMap.get(responseCamera.getId());
                if(cameraSpace != null){
                    DateTime dateTime  = new DateTime(cameraSpace.getSpaceEndTime());
                    cameraSpace.setSnCode(responseCamera.getSnCode());
                    cameraSpace.setUsedSpace(Double.parseDouble(responseCamera.getUsedSpace()));
                    cameraSpace.setUsedSpaceStr(responseCamera.getUsedSpaceStr());
                    cameraSpace.setTotalSpace(Double.parseDouble(responseCamera.getTotalSpace()));
                    cameraSpace.setTotalSpaceStr(responseCamera.getTotalSpaceStr());

                    Long space = cameraSpace.getSpace();
                    cameraSpace.setSpace((long)FileSizeUtil.formetFileSize(space, FileSizeUtil.SIZETYPE_GB));
                    cameraSpace.setSpaceStr(FileSizeUtil.formatFileSize(space));
                    cameraSpace.setSpaceEndStr(DateUtil.date2String(cameraSpace.getSpaceEndTime(), DateUtil.YYYY_MM_DD_DATE_FORMAT));

                    if(Days.daysBetween(new DateTime(), dateTime).getDays() < 7){
                        cameraSpaceList.add(cameraSpace);
                        cameraSpaceAll.add(cameraSpace);
                        continue;
                    }
                    cameraSpaceAll.add(cameraSpace);
                }
            }
        }
        HashMap<String,Object> map = new HashMap<>();
        map.put("nickName", user.getNickName());

        if(cameraSpaceList.size() > 0){
            map.put("isExpire", true);
            Collections.sort(cameraSpaceList);
            map.put("cameraList", cameraSpaceList);
            return map;
        }

        map.put("isExpire", false);
        Collections.sort(cameraSpaceAll);
        map.put("cameraList", cameraSpaceAll);
        return map;
    }

    @Override
    public void unbind(Long cameraId, String ids,String userName) {
        if(cameraId != null){
            ids = cameraId.toString();
        }
        String[] split = ids.split(",");
        List<Long> cameraIds = new ArrayList<>();
        for (String id : split) {
            cameraIds.add(Long.valueOf(id));
        }
        cameraDetailService.unbindCamera(cameraIds);                     //取消相机用户关联
        userIncrementService.unbindCamera(cameraIds);                   //取消关联用户权益
        sceneService.bindOrUnCamera(cameraIds,null);                //取消关联场景
        sceneProService.bindOrUnCamera(cameraIds,null);             //取消关联场景
        scenePlusService.bindOrUnCamera(cameraIds,null);            //取消关联场景
        sceneResourceCameraService.deleteByCameraIds(cameraIds);       //删除协作相机

    }

    @Override
    public void bind(Integer cameraType, String snCodes, String username) {
        User user = userService.getByUserName(username);
        String[] snCodeArr = snCodes.split(",");
        List<String> snCodeList = Arrays.asList(snCodeArr);
        LambdaUpdateWrapper<Camera> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(Camera::getSnCode,snCodeList);
        List<Camera> list = this.list(wrapper);
        List<Long> cameraIds = list.parallelStream().map(Camera::getId).collect(Collectors.toList());
        cameraDetailService.bindCamera(cameraIds,user.getId());
        sceneService.bindOrUnCamera(cameraIds,user.getId());
        sceneProService.bindOrUnCamera(cameraIds,user.getId());
        scenePlusService.bindOrUnCamera(cameraIds,user.getId());
    }

    @Override
    public void saveCooperationUser(String ids, Long id,String resourceIds, String username) {
        if (id != null) {
            ids = id.toString();
        }
        String[] split = ids.split(",");
        List<Long> cameraIds = new ArrayList<>();
        for (String cameraId : split) {
            cameraIds.add(Long.valueOf(cameraId));
        }
        HashMap<Long, CameraDetail> detailMap = cameraDetailService.getByCameraIds(cameraIds);
        HashMap<Long, Camera> cameraMap = this.getByIds(cameraIds);
        User user = userService.getByUserName(username);
        cameraDetailService.updateCooperationByIds(cameraIds, user.getId());
        sceneResourceCameraService.deleteByCameraIds(cameraIds);

        //保存相机和场景资源的关联关系你
        List<Long> resourceIdList = new ArrayList<>();
        if (StringUtils.isNotEmpty(resourceIds)) {
            for (String rId : resourceIds.split(",")) {
                resourceIdList.add(Long.valueOf(rId));
            }
            sceneResourceCameraService.saveBatchByCameraIds(cameraIds,resourceIdList);
        }

        List<ScenePro> sceneProList = sceneProService.getListByCameraIds(cameraIds);
        List<ScenePlus> scenePlusList = scenePlusService.getListByCameraIds(cameraIds);
        sceneCooperationService.deleteCooperationList(sceneProList,scenePlusList);

        sceneCooperationService.saveBatchByList(sceneProList,scenePlusList,user.getId(),resourceIdList);

        fdkkLaserService.disableCooperation(detailMap, cameraMap);
        fdkkLaserService.enableCameraCooperation(detailMap, cameraMap, username);
    }

    @Override
    public void deleteCooperationUser(Long cameraId) {
        List<Long> cameraIds = new ArrayList<>();
        cameraIds.add(cameraId);
        HashMap<Long, CameraDetail> detailMap = cameraDetailService.getByCameraIds(cameraIds);
        HashMap<Long, Camera> cameraMap = this.getByIds(cameraIds);
        cameraDetailService.updateCooperationByIds(cameraIds, null);
        sceneResourceCameraService.deleteByCameraIds(cameraIds);

        List<ScenePro> sceneProList = sceneProService.getListByCameraIds(cameraIds);
        List<ScenePlus> scenePlusList = scenePlusService.getListByCameraIds(cameraIds);
        sceneCooperationService.deleteCooperationList(sceneProList,scenePlusList);
        fdkkLaserService.disableCooperation(detailMap, cameraMap);

    }

    @Override
    public Camera getBySnCodeAndPassword(String appUserName, String appPassword) {
        LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Camera::getChildName,appUserName)
                .eq(Camera::getChildPassword,appPassword);
        List<Camera> list = this.list(wrapper);
        if(list != null && list.size() >0){
            return list.get(0);
        }
        return null;
    }

    @Override
    public Camera getByChildName(String childName) {
        LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Camera::getChildName,childName);
        List<Camera> list = this.list(wrapper);
        if(list != null && list.size() >0){
            return list.get(0);
        }
        return null;
    }

    @Override
    public List<CameraAppVo> getCameraInfo(String childName, String childPassword) {
        return this.getBaseMapper().getCameraInfo(childName,childPassword);
    }

    @Override
    public List<Camera> getAllList(String childName,String token) {
        User user = userService.getByToken(token);
        if(user == null){
            return new ArrayList<>();
        }
        return  this.getBaseMapper().getAllListByUser(user.getId(),childName);
    }
}