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

package com.fdkankan.manage.service.impl;
import java.util.Date;

import cn.dev33.satoken.stp.StpUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.common.util.SecurityUtil;
import com.fdkankan.manage.common.CacheUtil;
import com.fdkankan.manage.common.PageInfo;
import com.fdkankan.manage.common.ResultCode;
import com.fdkankan.manage.entity.*;
import com.fdkankan.manage.exception.BusinessException;
import com.fdkankan.manage.mapper.IAuthorizeCameraMapper;
import com.fdkankan.manage.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.manage.util.CameraUtils;
import com.fdkankan.manage.util.ListUtils;
import com.fdkankan.manage.vo.request.AuthorizeParam;
import com.fdkankan.reg.RegCodeUtil;
import com.fdkankan.reg.dto.CamRegDto;
import com.fdkankan.reg.dto.CamRegSDto;
import com.fdkankan.reg.dto.MachineRegDto;
import jdk.internal.dynalink.linker.LinkerServices;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2023-07-07
 */
@Service
@Slf4j
public class AuthorizeCameraServiceImpl extends ServiceImpl<IAuthorizeCameraMapper, AuthorizeCamera> implements IAuthorizeCameraService {

    @Autowired
    IAuthorizeCameraDetailService authorizeCameraDetailService;
    @Autowired
    IAuthorizeCameraLogService authorizeCameraLogService;
    @Autowired
    ISysUserService sysUserService;
    @Autowired
    ICameraService cameraService;
    @Autowired
    ICameraDetailService cameraDetailService;

    @Override
    public Object pageList(AuthorizeParam param) {
        LambdaQueryWrapper<AuthorizeCamera> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotBlank(param.getCustomerName())){
            wrapper.like(AuthorizeCamera::getCustomerName,param.getCustomerName());
        }
        if(param.getCustomerType() != null){
            wrapper.eq(AuthorizeCamera::getCustomerType,param.getCustomerType());
        }
        if(param.getUseType() != null){
            wrapper.eq(AuthorizeCamera::getUseType,param.getUseType());
        }
        if(StringUtils.isNotBlank(param.getAuthorizeKey())){
            wrapper.like(AuthorizeCamera::getAuthorizeKey,param.getAuthorizeKey());
        }
        if(StringUtils.isNotBlank(param.getMachineUuid())){
            wrapper.like(AuthorizeCamera::getMachineUuid,param.getMachineUuid());
        }
        if(StringUtils.isNotBlank(param.getMachineCode())){
            wrapper.like(AuthorizeCamera::getMachineCode,param.getMachineCode());
        }
        wrapper.orderByDesc(AuthorizeCamera::getCreateTime);
        Page<AuthorizeCamera> page = this.page(new Page<>(param.getPageNum(), param.getPageSize()), wrapper);
        Set<Long> sysIds = page.getRecords().stream().map(AuthorizeCamera::getSysUserId).collect(Collectors.toSet());
        HashMap<Long, SysUser> userMap = sysUserService.getByIds(sysIds);
        for (AuthorizeCamera record : page.getRecords()) {
            if(userMap.get(record.getSysUserId())!=null){
                record.setSysUserName(userMap.get(record.getSysUserId()).getNickName());
            }
            String snCodes  = "";
            List<AuthorizeCameraDetail> details = authorizeCameraDetailService.getByCameraId(record.getId());
            for (AuthorizeCameraDetail detail : details) {
                snCodes += detail.getSnCode()+ "\n";
            }
            record.setSnCodes(snCodes);
        }
        return PageInfo.PageInfo(page);
    }

    @Override
    public AuthorizeCamera addOrUpdate(AuthorizeCamera param) {
        param.setSysUserId(Long.valueOf((String) StpUtil.getLoginId()));
        HashMap<String,AuthorizeCameraDetail> detailHashMap = new HashMap<>();
        if(param.getId() == null){
            //获取机器UUID，机器名称
            MachineRegDto machineRegDto = null;
            try {
                 machineRegDto = RegCodeUtil.builder().env(CacheUtil.laserRegEnv).build().ParseMachineCode(param.getMachineCode());
            }catch (Exception e){
                throw new BusinessException(ResultCode.MACHINE_CODE_ERROR);
            }
            if(machineRegDto == null){
                throw new BusinessException(ResultCode.READ_MACHINE_CODE_ERROR);
            }

            param.setMachineUuid( machineRegDto.getUuid());
            try {
                CamRegSDto dtos = new CamRegSDto();
                dtos.setMachineCode(param.getMachineCode());
                dtos.setTimestamp(new Date().getTime());
                List<CamRegDto> camRegs = new ArrayList<>();
                String[] split = param.getSnCodes().split("\n");
                if(ListUtils.checkForDuplicates(split)){
                    throw new BusinessException(ResultCode.CAMERA_SN_EXITS);
                }
                for (String snCode : split) {
                    if(StringUtils.isBlank(snCode)){
                        continue;
                    }
                    snCode = snCode.toUpperCase();
                    CamRegDto camRegDto = new CamRegDto();
                    camRegDto.setSn(snCode);
                    Camera camera = cameraService.getBySnCode(snCode);
                    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);
                    }
                    if(cameraDetail.getType() != 9 && cameraDetail.getType() !=10 && cameraDetail.getType() !=11){
                        throw new BusinessException(ResultCode.CAMERA_AUTHORIZE_ERROR);
                    }
                    camRegDto.setCameraType(cameraDetail.getType());
                    camRegs.add(camRegDto);
                    AuthorizeCameraDetail detail = new AuthorizeCameraDetail();
                    detail.setSnCode(snCode);
                    detail.setCameraId(camera.getId());
                    detail.setCameraType(cameraDetail.getType());
                    detail.setCameraTypeStr(CameraUtils.getCameraTypeStr(detail.getCameraType()));
                    detailHashMap.put(snCode,detail);
                }
                param.setCameraNum(detailHashMap.size());
                dtos.setCamRegs(camRegs);
                String authorizeKey =  RegCodeUtil.builder().env(CacheUtil.laserRegEnv).build().batchGenRegeditCamCode(dtos);
                if(StringUtils.isBlank(authorizeKey)){
                    throw new BusinessException(ResultCode.GET_MACHINE_CODE_ERROR);
                }
                param.setAuthorizeKey(authorizeKey);
            }catch (Exception e){
                log.info("授权相机：error:",e);
                throw e;
            }
        }
        this.saveOrUpdate(param);
        for (AuthorizeCameraDetail detail : detailHashMap.values()) {
            detail.setAuthorizeCameraId(param.getId());
            authorizeCameraDetailService.save(detail);
        }
        return param;
    }

    @Override
    public Object detail(Integer id) {
        AuthorizeCamera authorizeCamera = this.getById(id);
        if(authorizeCamera == null){
            throw new BusinessException(ResultCode.RECOED_NO_EXITS);
        }
        return authorizeCameraDetailService.getByCameraId(id);
    }

    @Override
    public Object updateSnCode(Integer detailId, String snCode) {
        snCode = snCode.toUpperCase();
        AuthorizeCameraDetail cameraDetail = authorizeCameraDetailService.getById(detailId);
        if(cameraDetail == null){
            throw new BusinessException(ResultCode.RECOED_NO_EXITS);
        }
        AuthorizeCamera authorizeCamera = this.getById(cameraDetail.getAuthorizeCameraId());
        if(authorizeCamera == null){
            throw new BusinessException(ResultCode.RECOED_NO_EXITS);
        }
        if(cameraDetail.getSnCode().toUpperCase().equals(snCode)){
            throw new BusinessException(ResultCode.UPDATE_CAMERA_ERROR);
        }
        Camera bySnCode = cameraService.getBySnCode(snCode);
        if(bySnCode == null){
            throw new BusinessException(ResultCode.UPDATE_CAMERA_NO_IN);
        }
        CameraDetail byCameraId = cameraDetailService.getByCameraId(bySnCode.getId());
        if(byCameraId == null){
            throw new BusinessException(ResultCode.UPDATE_CAMERA_NO_IN);
        }
        if(!byCameraId.getType().equals(cameraDetail.getCameraType())){
            throw new BusinessException(ResultCode.CAMERA_AUTHORIZE_TYPE_ERROR);
        }
        try {
            CamRegSDto dtos = new CamRegSDto();
            dtos.setMachineCode(authorizeCamera.getMachineCode());
            dtos.setTimestamp(new Date().getTime());
            List<CamRegDto> camRegs = new ArrayList<>();
            CamRegDto camRegDto = new CamRegDto();
            camRegDto.setSn(cameraDetail.getSnCode());
            camRegDto.setToSn(snCode);
            camRegs.add(camRegDto);
            dtos.setCamRegs(camRegs);
            String authorizeKey =  RegCodeUtil.builder().env(CacheUtil.laserRegEnv).build().batchGenRegeditCamCode(dtos);
            if(StringUtils.isBlank(authorizeKey)){
                throw new BusinessException(ResultCode.GET_MACHINE_CODE_ERROR);
            }
            AuthorizeCameraLog authorizeCameraLog = authorizeCameraLogService.saveLog(cameraDetail, snCode, authorizeKey);
            authorizeCameraDetailService.updateSnCode(cameraDetail.getId(),bySnCode.getId(),byCameraId.getType(),snCode);
            return authorizeCameraLog;
        }catch (Exception e){
            throw new BusinessException(ResultCode.GET_MACHINE_CODE_ERROR);
        }
    }
}