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

package com.fdkankan.manage.service.impl;

import com.alibaba.nacos.shaded.org.checkerframework.checker.units.qual.A;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.common.constant.Constant;
import com.fdkankan.common.constant.ErrorCode;
import com.fdkankan.common.exception.BusinessException;
import com.fdkankan.common.response.PageInfo;
import com.fdkankan.common.util.DateUtil;
import com.fdkankan.manage.common.CameraTypeEnum;
import com.fdkankan.manage.constant.CameraConstant;
import com.fdkankan.manage.entity.Camera;
import com.fdkankan.manage.entity.CameraDetail;
import com.fdkankan.manage.entity.Company;
import com.fdkankan.manage.mapper.ICameraMapper;
import com.fdkankan.manage.service.*;
import com.fdkankan.manage.util.Dateutils;
import com.fdkankan.manage.vo.request.CameraInOutParam;
import com.fdkankan.manage.vo.request.CameraParam;
import com.fdkankan.manage.vo.response.CameraDetailVo;
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 java.util.*;
import java.util.stream.Collectors;

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

    @Autowired
    ICameraDetailService cameraDetailService;
    @Autowired
    ISceneService sceneService;
    @Autowired
    ISceneProService sceneProService;
    @Autowired
    IUserIncrementService userIncrementService;
    @Autowired
    ISceneResourceCameraService sceneResourceCameraService;
    @Autowired
    IScenePlusService scenePlusService;
    @Autowired
    ICompanyService companyService;
    @Value("${upload.type}")
    private String ossType;

    @Override
    public List<Camera> getListByCameraIdList(List<Long> cameraIdList) {
        LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(Camera::getId,cameraIdList);
        return this.list(wrapper);
    }

    @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 null;
        }
        return list.get(0);
    }

    private List<Camera> getBySnCodes(List<String> snCodeList) {
        LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(Camera::getSnCode,snCodeList);
        return this.list(wrapper);
    }

    @Override
    public void unbindCamera(Long cameraId) {
        cameraDetailService.unbindCamera(cameraId);         //取消相机用户关联
        userIncrementService.unbindCamera(cameraId);        //取消关联用户权益
        sceneService.unbindCamera(cameraId);                //取消关联场景
        sceneProService.unbindCamera(cameraId);             //取消关联场景
        scenePlusService.unbindCamera(cameraId);             //取消关联场景
        sceneResourceCameraService.unbindCamera(cameraId);  //删除协作相机
    }

    @Override
    public PageInfo pageList(CameraParam param) {
        Page<CameraDetailVo> voPage = this.getBaseMapper().pageList(new Page<>(param.getPageNum(),param.getPageSize()),param);
        return PageInfo.PageInfo(voPage);
    }

    @Override
    public void in(String wifiName) {
        if(StringUtils.isEmpty(wifiName) ){
            throw new BusinessException(ErrorCode.MISSING_REQUIRED_PARAMETERS);
        }
        if( !wifiName.contains("_") || !wifiName.contains("4D")){
            throw new BusinessException(-1,"wifi名称格式错误");
        }
        LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Camera::getWifiName,wifiName);
        long count = this.count(wrapper);
        if(count > 0){
            throw new BusinessException(-1,"设备wifi名称重复");
        }
        saveBatchCamera(Collections.singletonList(wifiName));
    }
    
    private Integer saveBatchCamera(List<String> wifiNameList){
        HashSet<String> wifiNameSet = new HashSet<>(wifiNameList);
        List<Camera> cameraList = new ArrayList<>();
        for (String wifiName : wifiNameSet) {
            String[] res = wifiName.split("_");
            Camera camera = new Camera();
            camera.setWifiName(wifiName);
            camera.setSnCode(res[1]);
            camera.setChildName(res[1]);
            camera.setWifiPassword(CameraConstant.WIFI_PASSWORD_VALUE);
            camera.setChildPassword(CameraConstant.CHILD_PASSWORD_VALUE);
            camera.setActivatedTime(DateUtil.date2String(new Date(),DateUtil.DEFAULT_DATE_FORMAT));
            cameraList.add(camera);

        }
        this.saveBatch(cameraList);

        List<CameraDetail> cameraDetailList = new ArrayList<>();
        for (Camera camera : cameraList) {
            String wifiName = camera.getWifiName();
            Integer type = CameraTypeEnum.getTypeByWifiNamePrefix(wifiName.substring(0,wifiName.lastIndexOf("_") +1));
            if(type == null){
                throw new BusinessException(-1,"wifi名称前缀错误！");
            }
            CameraDetail cameraDetail = new CameraDetail();
            cameraDetail.setAgency(CameraConstant.DEFAULT_AGENT);
            cameraDetail.setCameraId(camera.getId());
            cameraDetail.setCountry(0);//默认中国
            if("aws".equals(ossType)){
                cameraDetail.setCountry(1);//1-国外
            }
            cameraDetail.setType(type);
            if (1 == cameraDetail.getType() || 9 == cameraDetail.getType() || 10 == cameraDetail.getType()){
                cameraDetail.setTotalSpace(Long.valueOf(Constant.CAMERA_BASE_SPACE_VALUE));
                cameraDetail.setUsedSpace(0L);
            }
            if(type != 9 && type != 10){
                type = type == 0 ? 1: 4;
            }
            cameraDetail.setGoodsId(Long.valueOf(type));
            cameraDetailList.add(cameraDetail);
        }
        return  cameraDetailService.saveBatch(cameraDetailList) ? cameraList.size() : 0;

    }
    @Override
    public Integer ins(List<String> wifiNameList){
        List<Integer> errorRow = getErrorRow(wifiNameList, null);
        getResultIn(errorRow);
        LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(Camera::getWifiName,wifiNameList);
        List<Camera> list = this.list(wrapper);
        if(list.size() >0){
            List<String> newList = list.parallelStream().map(Camera::getWifiName).collect(Collectors.toList());
            List<Integer> errorRow2 = getErrorRow(wifiNameList, newList);
            getResultIn(errorRow2);
        }
        return saveBatchCamera(wifiNameList);
    }

    private void getResultIn(List<Integer> errorList){
        if(errorList.size() <=0){
            return;
        }
        StringBuilder res = new StringBuilder("第");
        for (Integer index : errorList) {
            res.append(index).append(",");
        }
        res.deleteCharAt(res.lastIndexOf(","));
        res.append("行存在错误");
        throw new BusinessException(-1, res.toString());
    }

    private List<Integer> getErrorRow(List<String> wifiNameList, List<String> newList){
        List<Integer> errorIndexList = new ArrayList<>();
        boolean bo = false;
        if(newList == null){
            newList = wifiNameList;
            bo = true;
        }
        for (String wifiName : newList) {
            int index = wifiNameList.indexOf(wifiName) + 3;
            if(bo){
                if( !wifiName.contains("_") || !wifiName.contains("4D")
                        || !CameraTypeEnum.typePrefixMap.containsKey(wifiName.split("_")[0])){
                    errorIndexList.add(index);
                }
            }else {
                errorIndexList.add(index);
            }
        }
        return errorIndexList;
    }

    @Override
    public void out(CameraInOutParam param) {
        if(param.getOutType() == null || param.getCompanyName() == null || param.getId() == null){
            throw  new BusinessException(ErrorCode.MISSING_REQUIRED_PARAMETERS);
        }
        Company company = companyService.getCompanyByName(param.getCompanyName());
        if(company == null){
            throw new BusinessException(-1,"客户名称不存在");
        }
        param.setCompanyId(company.getId());
        Camera camera = this.getById(param.getId());
        if(camera == null){
            throw new BusinessException(-1,"相机不存在");
        }
        CameraDetail detail = cameraDetailService.getByCameraId(camera.getId());
        if(detail ==null){
            throw new BusinessException(-1,"该相机未入库");
        }

        HashMap<String,CameraDetail> detailMap = new HashMap<>();
        detailMap.put(detail.getCameraId().toString(),detail);
        this.saveBatchDetail(detailMap, Collections.singletonList(param));

    }
    @Override
    public Integer outs(List<CameraInOutParam> params){
        setCompanyIdByDb(params);
        HashMap<String, Object> resultMap = getResultMap(params);
        HashMap<String,CameraDetail> detailMap = (HashMap<String, CameraDetail>) resultMap.get("detailMap");
        return this.saveBatchDetail(detailMap,params);

    }

    private Integer saveBatchDetail(HashMap<String, CameraDetail> detailMap, List<CameraInOutParam> params){
        List<CameraDetail> cameraDetails = new ArrayList<>();
        for (CameraInOutParam param : params) {
            CameraDetail cameraDetail = detailMap.get(param.getId().toString());
            cameraDetail.setOrderSn(param.getOrderSn());
            cameraDetail.setOwn(param.getOutType());
            cameraDetail.setCompanyId(param.getCompanyId());
            cameraDetail.setOutTime(Dateutils.getDate(new Date()));
            cameraDetails.add(cameraDetail);
        }
        return cameraDetailService.saveOrUpdateBatch(cameraDetails) ? cameraDetails.size() : 0;
    }

    private void checkSnCode(List<String> snCodeList) {
        HashMap<String,Integer> map = new HashMap<>();
        for (String snCode : snCodeList) {
            if(map.get(snCode) == null){
                map.put(snCode,1);
            }else {
                map.put(snCode,2);
            }
        }
        List<String> errorSnCode = new ArrayList<>();
        for (String snCode : map.keySet()) {
            if(map.get(snCode) > 1){
                errorSnCode.add(snCode);
            }
        }
        if(errorSnCode.size() >0){
            throw new BusinessException(-1,"存在重复的snCode:"+errorSnCode);
        }

    }


    @Override
    public void updateCamera(CameraInOutParam param) {
        if(param.getId() == null|| param.getOutType() == null){
            throw new BusinessException(ErrorCode.MISSING_REQUIRED_PARAMETERS);
        }
        CameraDetail cameraDetail = cameraDetailService.getByCameraId(param.getId());
        if(cameraDetail == null){
            throw new BusinessException(ErrorCode.MISSING_REQUIRED_PARAMETERS);
        }
        if(StringUtils.isNotBlank(param.getCompanyName())){
            Company company = companyService.getCompanyByName(param.getCompanyName());
            if(company !=null){
                cameraDetail.setCompanyId(company.getId());
            }
        }
        cameraDetail.setOwn(param.getOutType());
        cameraDetail.setOrderSn(param.getOrderSn());
        cameraDetailService.updateById(cameraDetail);
    }

    @Override
    public void deleteCamera(Long id) {
        if(id == null){
            throw new BusinessException(ErrorCode.MISSING_REQUIRED_PARAMETERS);
        }
        CameraDetail cameraDetail = cameraDetailService.getByCameraId(id);
        if(cameraDetail !=null && cameraDetail.getUserId()!=null){
            throw new BusinessException(-1,"相机已绑定，请先解绑后删除");
        }
        this.removeById(id);
        cameraDetailService.deleteByCameraId(id);
    }

    @Override
    public Integer updateCompany(List<CameraInOutParam> companyParams) {
        setCompanyIdByDb(companyParams);
        HashMap<String, Object> resultMap = getResultMap(companyParams);
        HashMap<Long, CameraDetail> detailMap = (HashMap<Long, CameraDetail>) resultMap.get("detailMap");
        HashMap<String, Camera> snCodeMap = (HashMap<String, Camera>) resultMap.get("snCodeMap");
        List<CameraDetail> updateDetailList = new ArrayList<>();
        for (CameraInOutParam companyParam : companyParams) {
            Camera camera = snCodeMap.get(companyParam.getSnCode());
            CameraDetail cameraDetail = detailMap.get(camera.getId());
            cameraDetail.setCompanyId(companyParam.getCompanyId());
            updateDetailList.add(cameraDetail);
        }
        return cameraDetailService.updateBatchById(updateDetailList) ? updateDetailList.size() : 0;

    }

    private void setCompanyIdByDb(List<CameraInOutParam> companyParams){
        List<String> companyNames = companyParams.parallelStream().map(CameraInOutParam::getCompanyName).collect(Collectors.toList());
        List<Company> companyList = companyService.getCompanyByNames(companyNames);
        List<String> dbCompanyNames = companyList.parallelStream().map(Company::getCompanyName).collect(Collectors.toList());
        List<Integer> errorRow = this.getErrorRow(companyNames, dbCompanyNames);
        getResultIn(errorRow);
        HashMap<String,Long> companyNameMap = new HashMap<>();
        for (Company company : companyList) {
            companyNameMap.put(company.getCompanyName(),company.getId());
        }
        for (CameraInOutParam companyParam : companyParams) {
            companyParam.setCompanyId(companyNameMap.get(companyParam.getCompanyName()));
        }
    }

    private HashMap<String, Object> getResultMap(List<CameraInOutParam> params){
        HashMap<String,Object> resultMap = new HashMap<>();
        List<String> snCodeList = params.parallelStream().map(CameraInOutParam::getSnCode).collect(Collectors.toList());
        checkSnCode(snCodeList);

        List<Camera> cameraList = this.getBySnCodes(snCodeList);

        List<Long> cameraIds = cameraList.parallelStream().map(Camera::getId).collect(Collectors.toList());
        List<CameraDetail> cameraDetails = cameraDetailService.getByCameraIds(cameraIds);
        HashMap<Long,CameraDetail> detailMap = new HashMap<>();
        for (CameraDetail cameraDetail : cameraDetails) {
            detailMap.put(cameraDetail.getCameraId(),cameraDetail);
        }

        HashMap<String,Camera> snCodeMap = new HashMap<>();
        for (Camera camera : cameraList) {
            snCodeMap.put(camera.getSnCode(),camera);
        }
        List<Integer> errorList = new ArrayList<>();
        for (String snCode : snCodeList) {
            Camera camera = snCodeMap.get(snCode);
            if(camera == null || detailMap.get(camera.getId()) ==null){
                errorList.add(snCodeList.indexOf(snCode) +3);
            }
        }
        getResultIn(errorList);
        resultMap.put("detailMap",detailMap);
        resultMap.put("snCodeMap",snCodeMap);
        return resultMap;
    }

}