4dkankan-fusion/src/main/java/com/fdkankan/fusion/service/impl/TmCameraServiceImpl.java

package com.fdkankan.fusion.service.impl;
import java.util.*;


import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSONArray;
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.fdkankan.fusion.common.PageInfo;
import com.fdkankan.fusion.common.ResultCode;
import com.fdkankan.fusion.common.enums.IdPreEnum;
import com.fdkankan.fusion.common.util.IdUtils;
import com.fdkankan.fusion.entity.TmCamera;
import com.fdkankan.fusion.entity.TmDepartment;
import com.fdkankan.fusion.entity.TmUser;
import com.fdkankan.fusion.exception.BusinessException;
import com.fdkankan.fusion.httpClient.FdService;
import com.fdkankan.fusion.httpClient.client.FdKKClient;
import com.fdkankan.fusion.httpClient.request.FdkkCameraParam;
import com.fdkankan.fusion.httpClient.response.FdkkResponse;
import com.fdkankan.fusion.mapper.ITmCameraMapper;
import com.fdkankan.fusion.response.BindCameraDto;
import com.fdkankan.fusion.response.CameraVo;
import com.fdkankan.fusion.service.ITmCameraService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.fusion.service.ITmDepartmentService;
import com.fdkankan.fusion.service.ITmUserService;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.stream.Collectors;

/**
 * <p>
 * 相机关联关系表 服务实现类
 * </p>
 *
 * @author 
 * @since 2023-07-28
 */
@Service
public class TmCameraServiceImpl extends ServiceImpl<ITmCameraMapper, TmCamera> implements ITmCameraService {

    @Autowired
    FdService fdService;
    @Autowired
    ITmDepartmentService tmDepartmentService;
    @Autowired
    ITmUserService tmUserService;

    @Override
    public List<TmCamera> getByUserId(String userId) {
        LambdaQueryWrapper<TmCamera> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(TmCamera::getUserId,userId);
        return list(wrapper);
    }

    @Override
    public TmCamera getBySnCode(String snCode) {
        LambdaQueryWrapper<TmCamera> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(TmCamera::getCameraSn,snCode);
        return getOne(wrapper);
    }

    @Override
    public void bind(BindCameraDto param) {
        if(StringUtils.isBlank(param.getCameraSn()) || StringUtils.isBlank(param.getDeptId()) || StringUtils.isBlank(param.getUserId()) || param.getCameraType() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        TmUser tmUser = tmUserService.getById(param.getUserId());
        if(tmUser == null || tmUser.getStatus() == 0){
            throw new BusinessException(ResultCode.USER_NOT_EXIST);
        }
        TmDepartment tmDepartment = tmDepartmentService.getById(param.getDeptId());
        if(tmDepartment == null){
            throw new BusinessException(ResultCode.DEPT_NOT_EXITS);
        }
        TmCamera tmCamera = this.getBySnCode(param.getCameraSn());
        if(tmCamera != null){
            throw new BusinessException(ResultCode.CAMERA_EXITS);
        }

        FdkkResponse fdkkResponse2 =  fdService.fdkKBind(param.getCameraSn(),tmUser.getUserName(),param.getCameraType());
        if(fdkkResponse2.getCode() != 0){
            throw new BusinessException(fdkkResponse2.getCode(),fdkkResponse2.getMsg());
        }
        FdkkResponse<CameraVo> fdkkResponse = fdService.getCameraDetail(param.getCameraSn());
        if(fdkkResponse.getCode() !=0 || fdkkResponse.getData() == null){
            throw new BusinessException(ResultCode.CAMERA_NOT_EXITS);
        }
        tmCamera = new TmCamera();
        tmCamera.setId(IdUtils.genId(IdPreEnum.CAMERA_PRE.getPre()));
        tmCamera.setCameraSn(param.getCameraSn());
        tmCamera.setDeptId(param.getDeptId());
        tmCamera.setUserId(param.getUserId());
        tmCamera.setFdCameraId(fdkkResponse.getData().getId());
        this.save(tmCamera);

    }

    @Override
    public void unBind(BindCameraDto param) {
        if(StringUtils.isBlank(param.getCameraSn())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        TmCamera tmCamera = this.getBySnCode(param.getCameraSn());
        if(tmCamera == null){
            throw new BusinessException(ResultCode.CAMERA_NOT_EXITS);
        }
        this.unBind(Arrays.asList(tmCamera));
    }

    @Override
    public void unBind(List<TmCamera> cameras) {
        if(CollectionUtil.isNotEmpty(cameras)){
            //四维解绑相机
            List<String> tmCameraIds = cameras.stream().map(TmCamera::getId).collect(Collectors.toList());
            FdkkResponse fdkkResponse = fdService.fdkkUnbind(cameras);
            if(fdkkResponse.getCode() == 0 ){
                this.removeByIds(tmCameraIds);
            }else {
                throw new BusinessException(fdkkResponse.getCode(),fdkkResponse.getMsg());
            }

        }
    }

    @Override
    public void edit(BindCameraDto param) {
        if(StringUtils.isBlank(param.getCameraSn())|| StringUtils.isBlank(param.getUserId()) || param.getCameraType() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        TmUser tmUser = tmUserService.getById(param.getUserId());
        if(tmUser == null || tmUser.getStatus() == 0){
            throw new BusinessException(ResultCode.USER_NOT_EXIST);
        }
        TmCamera tmCamera = this.getBySnCode(param.getCameraSn());
        if(tmCamera == null){
            throw new BusinessException(ResultCode.CAMERA_NOT_EXITS);
        }
        FdkkResponse fdkkResponse = fdService.fdkkUnbind(Arrays.asList(tmCamera));
        if(fdkkResponse.getCode() !=0){
            throw new BusinessException(fdkkResponse.getCode(),fdkkResponse.getMsg());
        }
        fdkkResponse = fdService.fdkKBind(param.getCameraSn(), tmUser.getUserName(),param.getCameraType());
        if(fdkkResponse.getCode() !=0){
            throw new BusinessException(fdkkResponse.getCode(),fdkkResponse.getMsg());
        }
        LambdaUpdateWrapper<TmCamera> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(TmCamera::getCameraSn,param.getCameraSn());
        wrapper.set(TmCamera::getUserId,param.getUserId());
        this.update(wrapper);
    }

    @Override
    public Object getDetail(String snCode) {
        if(StringUtils.isBlank(snCode)){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }

        TmCamera tmCamera = this.getBySnCode(snCode);
        if(tmCamera == null){
            throw new BusinessException(ResultCode.CAMERA_NOT_EXITS);
        }
        return fdService.getCameraDetail(snCode);
    }

    @Override
    public Object pageList(Long pageNum, Long pageSize, String snCode, String deptId, Integer type,String searchKey) {
        LambdaQueryWrapper<TmCamera> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotBlank(searchKey)){
            List<TmUser> tmUsers = tmUserService.getLikeNickName(searchKey);
            if(tmUsers.size() <=0){
                return PageInfo.PageInfo(new Page<>(pageNum,pageSize));
            }
            List<String> userIds = tmUsers.stream().map(TmUser::getId).collect(Collectors.toList());
            wrapper.in(TmCamera::getUserId,userIds);
        }
        if (StringUtils.isNotBlank(snCode)) {
            wrapper.like(TmCamera::getCameraSn,snCode);
        }

        List<String> deptIds = tmDepartmentService.getDeptIds();
        if(StringUtils.isNotBlank(deptId)){
            deptIds = tmDepartmentService.getSonByDeptIdAndDeptIds(deptIds,deptId);
        }
        wrapper.in(TmCamera::getDeptId,deptIds);

        wrapper.orderByDesc(TmCamera::getCreateTime);
        Page<TmCamera> page = this.page(new Page<>(pageNum, pageSize), wrapper);
        if(page.getRecords().size()<=0){
            return PageInfo.PageInfo(page);
        }
        List<String> snCodes = page.getRecords().stream().map(TmCamera::getCameraSn).collect(Collectors.toList());
        FdkkResponse<List<CameraVo>> fdkkResponse = fdService.getCameraDetails(snCodes);

        HashMap<String,String> deptIdMap = new HashMap<>();
        HashMap<String,String> deptNameMap = new HashMap<>();
        for (TmCamera record : page.getRecords()) {
            deptIdMap.put(record.getCameraSn().toUpperCase(),record.getDeptId());
        }
        Collection<String> values = deptIdMap.values();
        if(values.size() >0){
            List<TmDepartment> departments = tmDepartmentService.listByIds(values);
            for (TmDepartment department : departments) {
                deptNameMap.put(department.getId(),department.getName());
            }
        }
        List<CameraVo> list =  fdkkResponse.getData();
        HashMap<String ,TmUser> map = tmUserService.getByCamera(page.getRecords());

        for (CameraVo cameraVo : list) {
            String deptIdO = deptIdMap.get(cameraVo.getSnCode().toUpperCase());
            cameraVo.setDeptId(deptIdO);
            cameraVo.setDeptName(deptNameMap.get(deptIdO));
            TmUser tmUser = map.get(cameraVo.getSnCode().toUpperCase());
            if(tmUser != null){
                cameraVo.setNickName(tmUser.getNickName());
                cameraVo.setUserId(tmUser.getId());
            }
        }
        Page<CameraVo> objectPage = new Page<>(pageNum, pageSize);
        objectPage.setRecords(list);
        objectPage.setTotal(page.getTotal());
        return PageInfo.PageInfo(objectPage);
    }

    @Override
    public List<TmCamera> getByDeptIds() {
        List<String> deptIds = tmDepartmentService.getDeptIds();

        return getByDeptIds(deptIds);
    }

    @Override
    public List<TmCamera> getByDeptIds(List<String> deptIds) {
        if(CollectionUtil.isEmpty(deptIds)){
            return new ArrayList<>();
        }
        LambdaQueryWrapper<TmCamera> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(TmCamera::getDeptId,deptIds);
        return this.list(wrapper);
    }

    @Override
    public HashMap<String, TmDepartment> getMapBySnCodes(Set<String> snCodes) {
        HashMap<String, TmDepartment> map = new HashMap<>();
        if(snCodes.size() >0){
            LambdaQueryWrapper<TmCamera> wrapper = new LambdaQueryWrapper<>();
            wrapper.in(TmCamera::getCameraSn,snCodes);
            List<TmCamera> list = this.list(wrapper);
            Set<String> deptIds = list.stream().map(TmCamera::getDeptId).collect(Collectors.toSet());
            HashMap<String, TmDepartment> mapDept = tmDepartmentService.getMapByDeptIds(deptIds);
            list.forEach(entity -> map.put(entity.getCameraSn().toUpperCase(),mapDept.get(entity.getDeptId())));
        }
        return map;
    }
}