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.constant.AppConstant;
import com.fdkankan.common.exception.BusinessException;
import com.fdkankan.ucenter.common.PageInfo;
import com.fdkankan.common.util.DateUtil;
import com.fdkankan.common.util.FileSizeUtil;
import com.fdkankan.ucenter.common.constants.NacosProperty;
import com.fdkankan.ucenter.constant.CameraConstant;
import com.fdkankan.ucenter.constant.LoginConstant;
import com.fdkankan.ucenter.constant.OrderConstant;
import com.fdkankan.ucenter.entity.*;
import com.fdkankan.ucenter.httpClient.service.LaserService;
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 lombok.extern.slf4j.Slf4j;
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;
import java.util.stream.Stream;

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

    @Autowired
    IUserService userService;
    @Autowired
    LaserService fdkkLaserService;
    @Autowired
    ISceneProService sceneProService;
    @Autowired
    ICameraSpaceService cameraSpaceService;
    @Autowired
    IUserIncrementService userIncrementService;
    @Autowired
    ISceneService sceneService;
    @Autowired
    ISceneResourceCameraService sceneResourceCameraService;
    @Autowired
    ISceneResourceService sceneResourceService;
    @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) {
        HashMap<Long, Camera> map = new HashMap<>();
        if(cameraIds.size() >0){
            LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
            wrapper.in(Camera::getId,cameraIds);
            List<Camera> list = this.list(wrapper);
            list.forEach(entity -> map.put(entity.getId(),entity));
        }
        return map;
    }

    @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(Long.valueOf(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;
    }

    @Autowired
    IUserRoleService userRoleService;

    @Override
    public PageInfo pageList(CameraParam param) {

        if(StringUtils.isNotBlank(param.getSceneCode())){
            Long cameraId = sceneProService.getCameraIdByNum(param.getSceneCode());
            if(cameraId != null){
                CameraDetail cameraDetail = cameraDetailService.getByCameraId(cameraId);
                if(cameraDetail != null && cameraDetail.getCompanyId() != null){
                    param.setCompanyId(cameraDetail.getCompanyId());
                }
            }
        }

        User user = userService.getByUserName(param.getUserName());
        Long userId = null;
        Set<Long> roleIds = userRoleService.getByUser(user);
        if(roleIds.contains(6L) || roleIds.contains(5L)){
            userId = 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()) {

            List<ScenePro> proList = sceneProService.getListByUserId(userId,responseCamera.getId());
            List<ScenePlus> plusList = scenePlusService.getListByUserId(userId,responseCamera.getId());
            Set<String> numList = proList.stream().map(ScenePro::getNum).collect(Collectors.toSet());
            Set<String> numList2 = plusList.stream().map(ScenePlus::getNum).collect(Collectors.toSet());
            numList.addAll(numList2);
            responseCamera.setSceneList(new ArrayList<>(numList));
            log.info("listNew---深时访问返回----camera:{},numList:{}",responseCamera.getSnCode(),numList);

            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){
                UserIncrement userIncrement = incrementMap.get(responseCamera.getId());
                if(userIncrement != null){
                    responseCamera.setUserIncrementId(userIncrement.getId());
                    responseCamera.setMemberLevels(userIncrement.getMemberLevels());
                    responseCamera.setSpaceEndStr(DateUserUtil.getDayTime(userIncrement.getIncrementEndTime()));
                    responseCamera.setSpaceEndTime(userIncrement.getIncrementEndTime());

                    String dayTime = userIncrement.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("SE".equals(userIncrement.getMemberLevels()) && DateUserUtil.getDate(dayTime).getTime() > new Date().getTime() ){  //高级会员 50G容量
                        responseCamera.setTotalSpaceStr("50.00GB");
                        responseCamera.setTotalSpace("50.00");
                    }
                }
            }


            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 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));
        }
        userIncrementService.unbindCamera(cameraIds);                   //取消关联用户权益
        cameraDetailService.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);
        if(list.size() <=0){
            throw new BusinessException(AppConstant.FAILURE_CODE_4010, snCodes +"-"+ AppConstant.FAILURE_MSG_4010);
        }
        List<String> dbSnCode = list.stream().map(Camera::getSnCode).collect(Collectors.toList());
        for (String code : snCodeList) {
            if(!dbSnCode.contains(code)){
                throw new BusinessException(AppConstant.FAILURE_CODE_4010, code +"-"+ AppConstant.FAILURE_MSG_4010);
            }
        }
        Map<Long, Camera> cameraHashMap = list.stream().collect(Collectors.toMap(Camera::getId, camera -> camera, (o1, o2) -> o1));
        List<Long> cameraIds = new ArrayList<>(cameraHashMap.keySet());
        HashMap<Long, CameraDetail> detailHashMap = cameraDetailService.getByCameraIds(cameraIds);
        for (CameraDetail detail : detailHashMap.values()) {
            if(detail.getUserId() != null){
                throw new BusinessException(CameraConstant.FAILURE_CODE_6010, cameraHashMap.get(detail.getCameraId()).getSnCode() +"-"+ CameraConstant.FAILURE_MSG_6010);
            }
        }

        cameraDetailService.bindCamera(cameraIds,user.getId());
        sceneService.bindOrUnCamera(cameraIds,user.getId());
        sceneProService.bindOrUnCamera(cameraIds,user.getId());
        scenePlusService.bindOrUnCamera(cameraIds,user.getId());

        if("local".equals(NacosProperty.uploadType)){   //局域网绑定相机，添加权益
            userIncrementService.addByCameraAndUser(cameraIds,user.getId());
        }
    }

    @Override
    public void saveCooperationUser(String ids, Long id,String resourceIds, String username) {
        User user = userService.getByUserName(username);
        if(user == null){
            throw new BusinessException(LoginConstant.FAILURE_CODE_3021, LoginConstant.FAILURE_MSG_3021);
        }
        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);
        cameraDetailService.updateCooperationByIds(cameraIds, user.getId());
        sceneResourceCameraService.deleteByCameraIds(cameraIds);

        //保存相机和场景资源的关联关系你
        String resourceType = "all";
        List<Long> resourceIdList = new ArrayList<>();
        if (StringUtils.isNotEmpty(resourceIds)) {
            for (String rId : resourceIds.split(",")) {
                resourceIdList.add(Long.valueOf(rId));
            }
            List<SceneResource> sceneResources = sceneResourceService.listByIds(resourceIdList);
            List<SceneResource> v3List = sceneResources.stream().filter(entity -> entity.getVersion().equals("v3")).collect(Collectors.toList());
            List<SceneResource> v4List = sceneResources.stream().filter(entity -> entity.getVersion().equals("v4")).collect(Collectors.toList());
            if(v3List.size() >0 && v4List.size() >0){
                resourceType = "all";
            }
            if(v3List.size() >0 && v4List.size() <=0){
                resourceType = "v3";
            }
            if(v3List.size() <=0 && v4List.size() >0){
                resourceType = "v4";
            }

            sceneResourceCameraService.saveBatchByCameraIds(cameraIds,resourceIdList);
        }

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

        switch (resourceType){
            case "v3" :
                sceneCooperationService.saveBatchByList(sceneProList,new ArrayList<>(),user.getId(),resourceIdList); break;
            case "v4" :
                sceneCooperationService.saveBatchByList(new ArrayList<>(),scenePlusList,user.getId(),resourceIdList); break;
            default:
                sceneCooperationService.saveBatchByList(sceneProList,scenePlusList,user.getId(),resourceIdList); break;
        }

        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 CameraVo getVoByChildName(String childName) {
        CameraVo vo = new CameraVo();
        Camera cameraEntity = this.getByChildName(childName);
        if (cameraEntity != null){
            CameraDetail detailEntity = cameraDetailService.getByCameraId(cameraEntity.getId());
            if (detailEntity != null){
                vo.setId(cameraEntity.getId());
                vo.setUserId(detailEntity.getUserId());
                vo.setActivatedTime(cameraEntity.getActivatedTime());
                vo.setBalance(Integer.valueOf(detailEntity.getBalance()));
                vo.setChildName(cameraEntity.getChildName());
                vo.setSnCode(cameraEntity.getSnCode());
                if (detailEntity.getType() != 0){
                    vo.setUsedSpace(Double.valueOf(FileSizeUtil.formetFileSize(detailEntity.getUsedSpace().longValue(), FileSizeUtil.SIZETYPE_GB)).intValue() +"" );
                    vo.setTotalSpace(Double.valueOf(FileSizeUtil.formetFileSize(detailEntity.getTotalSpace().longValue(), FileSizeUtil.SIZETYPE_GB)).intValue() +"");
                    vo.setUsedSpaceStr(FileSizeUtil.formatFileSize(detailEntity.getUsedSpace().longValue()));
                    vo.setTotalSpaceStr(FileSizeUtil.formatFileSize(detailEntity.getTotalSpace().longValue()));
                }
                vo.setType(detailEntity.getType());
                vo.setCountry(detailEntity.getCountry());
                vo.setCameraType(detailEntity.getType()+"");
            }
        }
        return vo;
    }

    @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);
    }

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