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

package com.fdkankan.manage_jp.service.impl;
import java.util.*;
import java.util.stream.Collectors;

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.util.DateUtil;
import com.fdkankan.manage_jp.common.Constant;
import com.fdkankan.manage_jp.common.PageInfo;
import com.fdkankan.manage_jp.common.ResultCode;
import com.fdkankan.manage_jp.entity.Camera;
import com.fdkankan.manage_jp.entity.CameraDetail;
import com.fdkankan.manage_jp.entity.Company;
import com.fdkankan.manage_jp.entity.User;
import com.fdkankan.manage_jp.exception.BusinessException;
import com.fdkankan.manage_jp.httpClient.param.SSToBind;
import com.fdkankan.manage_jp.httpClient.service.LaserService;
import com.fdkankan.manage_jp.mapper.ICameraMapper;
import com.fdkankan.manage_jp.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.manage_jp.util.CameraTypeUtils;
import com.fdkankan.manage_jp.vo.request.CameraAddParam;
import com.fdkankan.manage_jp.vo.request.CameraListParam;
import com.fdkankan.manage_jp.vo.request.RequestCamera;
import com.fdkankan.manage_jp.vo.request.SceneParam;
import com.fdkankan.manage_jp.vo.response.ResponseCamera;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

    @Autowired
    ICameraDetailService cameraDetailService;
    @Autowired
    ICompanyService companyService;
    @Autowired
    IUserService userService;
    @Autowired
    IUserRoleService userRoleService;
    @Autowired
    ISceneProService sceneProService;
    @Autowired
    IScenePlusService scenePlusService;
    @Autowired
    LaserService laserService;

    @Override
    public Camera findByChildName(String childName) {
        LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Camera::getChildName,childName);
        return this.getOne(wrapper);
    }

    @Override
    public Object pageList(CameraListParam param,User user) {
        Set<Long> roleIds = userRoleService.getByUser(user);
        if(roleIds.contains(6L)){
            param.setCompanyId(user.getCompanyId());
        }
        Page<ResponseCamera> page = this.getBaseMapper().pageList(new Page<>(param.getPageNum(),param.getPageSize()),param);
        for (ResponseCamera record : page.getRecords()) {
            record.setCameraType(record.getType());
        }
        return PageInfo.PageInfo(page);
    }

    @Override
    public void add(CameraAddParam param) {
        if(StringUtils.isBlank(param.getChildName()) && StringUtils.isBlank(param.getSnCode())){
            throw new BusinessException(ResultCode.PARAM_ERROR);
        }
        if(!param.getChildName().equals(param.getSnCode())){
            throw new BusinessException(ResultCode.PARAM_ERROR);
        }
        List<Camera> byChildNames = this.getByChildNames(Arrays.asList(param.getChildName()));
        if(byChildNames !=null && byChildNames.size() >0){
            throw new BusinessException(ResultCode.CAMERA_IN);
        }
        Camera camera = new Camera();
        camera.setChildName(param.getChildName());
        camera.setChildPassword(Constant.CHILD_PASSWORD_VALUE);
        camera.setSnCode(param.getSnCode());
        camera.setWifiName(param.getWifiName());
        camera.setWifiPassword(Constant.WIFI_PASSWORD_VALUE);
       // camera.setActivatedTime(DateUtil.date2String(new Date(),"yyyy-MM-dd HH:mm:ss"));
        this.save(camera);

        CameraDetail detail = new CameraDetail();
        detail.setOwn(param.getOwn());
        detail.setTotalSpace(0L);
        detail.setUsedSpace(0L);
        detail.setCameraId(camera.getId());
        detail.setType(param.getCameraType());
        if(param.getCameraType() == 9){
            detail.setGoodsId(9L);
        }else if(param.getCameraType() == 10){
            detail.setGoodsId(10L);
        }else{
            detail.setGoodsId(param.getCameraType() == 0 ? 1L : 4L);
        }
        detail.setOutTime(new Date());
        detail.setAgency(Constant.DEFAULT_AGENT);
        detail.setAddress(param.getAddress());
      //  detail.setCompanyId(112L);
        cameraDetailService.save(detail);
    }

    @Override
    public void updateByParam(CameraAddParam param) {
        if(param.getCameraId() == null || param.getOwn() == null ){
            throw new BusinessException(ResultCode.PARAM_ERROR);
        }

        cameraDetailService.updateOwnByCameraId(param.getCameraId(),param.getOwn());
    }

    @Override
    public void unbind(CameraAddParam param) {
        if(StringUtils.isBlank(param.getChildName())){
            throw new BusinessException(ResultCode.PARAM_ERROR);
        }
        Camera camera = this.findByChildName(param.getChildName());
        if(camera == null){
            throw new BusinessException(ResultCode.PARAM_ERROR);
        }
        CameraDetail cameraDetail = cameraDetailService.getByCameraId(camera.getId());
        if(cameraDetail == null){
            throw new BusinessException(ResultCode.PARAM_ERROR);
        }
        LambdaUpdateWrapper<Camera> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Camera::getId,camera.getId());
        wrapper.set(Camera::getActivatedTime,null);
        this.update(wrapper);

        cameraDetailService.unbind(camera.getId());
//        sceneProService.unbind(camera.getId(),null);
//        scenePlusService.unbind(camera.getId(),null);
//        if(cameraDetail.getType() == 10){
//            //laserService.toBind(Arrays.asList(camera.getSnCode()),false,null);
//        }
    }

    @Override
    public void bind(CameraAddParam param) {
        if(param.getChildNames() == null  || param.getChildNames().size() <=0 || param.getCompanyId() == null){
            throw new BusinessException(ResultCode.PARAM_ERROR);
        }
        Company company = companyService.getById(param.getCompanyId());
        if(company ==  null){
            throw new BusinessException(ResultCode.COMPANY_NOT_EXIST);
        }
        User user = userService.getById(company.getManagerId());
        if(user == null){
            throw new BusinessException(ResultCode.USER_NOT_EXIST);
        }

        LambdaUpdateWrapper<Camera> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(Camera::getChildName,param.getChildNames());
        wrapper.set(Camera::getActivatedTime, DateUtil.date2String(new Date(),"yyyy-MM-dd HH:mm:ss"));
        this.update(wrapper);
        List<Camera> byChildNames = this.getByChildNames(param.getChildNames());
        List<Long> cameraIds = byChildNames.stream().map(Camera::getId).collect(Collectors.toList());
        cameraDetailService.bind(cameraIds,param.getCompanyId(),user.getId());
//        for (Long cameraId : cameraIds) {
//            sceneProService.unbind(cameraId, user.getId());
//            scenePlusService.unbind(cameraId,user.getId());
//
//        }
    }

    @Override
    public List<Camera> getByChildNames(List<String> childNames) {
        LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(Camera::getChildName,childNames);
        return this.list(wrapper);
    }

    @Override
    public List<Camera> getByWiFiName(List<String> wifiNames) {
        LambdaQueryWrapper<Camera> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(Camera::getWifiName,wifiNames);
        return this.list(wrapper);
    }

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

    @Override
    public Object getByUser(SceneParam param) {
        if(StringUtils.isBlank(param.getUserName()) && param.getType() == null){
            throw new BusinessException(ResultCode.PARAM_ERROR);
        }
        User user = userService.getByUserName(param.getUserName());
        if(user == null){
            throw new BusinessException(ResultCode.USER_NOT_EXIST);
        }
        Integer cameraType = CameraTypeUtils.getCameraType(param.getType());
        Set<Long> roleIds = userRoleService.getByUser(user);
        List<CameraDetail> cameraDetails = new ArrayList<>();
        if(roleIds.contains(5L)){
            cameraDetails =  cameraDetailService.getByCompanyAndType(null,cameraType);
        }else if(roleIds.contains(6L)){
            cameraDetails =  cameraDetailService.getByCompanyAndType(user.getCompanyId(),cameraType);
        }else {
            cameraDetails = cameraDetailService.getByUserIdAndType(user.getId(),cameraType);
        }

        if(cameraDetails.isEmpty()){
            return null;
        }
        List<Long> cameraIds = cameraDetails.stream().map(CameraDetail::getCameraId).collect(Collectors.toList());
        return this.listByIds(cameraIds);
    }
}