cloud-etl-engine/cloud-etl-server/src/main/java/com/muyu/service/serviceImpl/EngIneServiceImpl.java

package com.muyu.service.serviceImpl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.muyu.common.core.domain.Result;
import com.muyu.common.core.utils.StringUtils;
import com.muyu.domain.EngineMaintenance;
import com.muyu.domain.EngineVersion;
import com.muyu.mapper.EngineMapper;
import com.muyu.req.EngineMaintenanceQueryReq;
import com.muyu.req.EngineVersionListResp;
import com.muyu.service.EngIneService;
import com.muyu.service.EngineVersionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Author：qdm
 * @Package：com.muyu.service.serviceImpl
 * @Project：cloud-etl-engine
 * @name：EngIneServiceImpl
 * @Date：2024/8/22 15:37
 */
@Service
public class EngIneServiceImpl extends ServiceImpl<EngineMapper, EngineMaintenance> implements EngIneService {

    @Autowired
    EngineMapper engineMapper;

    @Autowired
    private EngineVersionService engineConfigService;

    @Override
    public List<EngineMaintenance> list( ) {
        LambdaQueryWrapper<EngineMaintenance> queryWrapper = new LambdaQueryWrapper<>();

//
//        if (StringUtils.isNotNull(engineMaintenance.getName())) {
//            queryWrapper.like(EngineMaintenance::getName, engineMaintenance.getName());
//        }
//
//        if (StringUtils.isNotNull(engineMaintenance.getType())) {
//            queryWrapper.eq(EngineMaintenance::getType, engineMaintenance.getType());
//        }
//
//        if (StringUtils.isNotNull(engineMaintenance.getScope())) {
//            queryWrapper.eq(EngineMaintenance::getScope, engineMaintenance.getScope());
//        }
//
//        if (StringUtils.isNotNull(engineMaintenance.getEngineCode())) {
//            queryWrapper.eq(EngineMaintenance::getEngineCode, engineMaintenance.getEngineCode());
//        }
//
//        if (StringUtils.isNotNull(engineMaintenance.getIsActivate())) {
//            queryWrapper.eq(EngineMaintenance::getIsActivate, engineMaintenance.getIsActivate());
//        }
//
//        if (StringUtils.isNotNull(engineMaintenance.getStatus())) {
//            queryWrapper.eq(EngineMaintenance::getStatus, engineMaintenance.getStatus());
//        }

        return list(queryWrapper);
    }

    @Override
    public Result delete(Integer id) {
        Integer res = engineMapper.deleteById(id);
        if (res > 0) {
            return Result.success("成功");
        }
        return Result.error("失败");
    }

    @Override
    public Result<EngineMaintenance> updateMsg(EngineMaintenance engineMaintenance) {
       Integer res = engineMapper.updateById(engineMaintenance);
       if (res > 0) {
           return Result.success();
       }
        return Result.error("失败");
    }

    @Override
    public Result<EngineMaintenance> insert(EngineMaintenance engineMaintenance) {
       Integer res = engineMapper.insert(engineMaintenance);
       if (res > 0) {
           return Result.success();
       }
        return Result.error("失败");
    }

    @Override
    public EngineVersionListResp getRuleEngineInfo(Long id) {
        EngineMaintenance engineMaintenance = this.getOne(new LambdaQueryWrapper<>() {{
            eq(EngineMaintenance::getId, id);
        }});
        List<EngineVersion> engineConfigs = engineConfigService.list();
        List<EngineVersion> engineConfigList = engineConfigs.stream().filter(engineConfig ->
                engineConfig.getEngineMaintenanceId().equals(engineMaintenance.getId())
        ).toList();
        return EngineVersionListResp.builder()
                .id(engineMaintenance.getId())
                .name(engineMaintenance.getName())
                .type(engineMaintenance.getType())
                .scope(engineMaintenance.getScope())
                .engineCode(engineMaintenance.getEngineCode())
                .isActivate(engineMaintenance.getIsActivate())
                .status(engineMaintenance.getStatus())
                .description(engineMaintenance.getDescription())
                .engineVersionList(engineConfigList)
                .build();
    }

    @Override
    public void forbiddenEngine(Integer id) {
        Integer res = engineMapper.forbiddenEngine(id);
    }

    @Override
    public void onEngine(Integer id) {
        Integer res = engineMapper.onEngine(id);
    }

    @Override
    public void closeEngine(Integer id) {
        Integer res = engineMapper.closeEngine(id);
    }

    @Override
    public void activateEngine(Integer id) {
        Integer res = engineMapper.activateEngine(id);
    }

    @Override
    public int deleteByIds(String ids) {
        LambdaQueryWrapper<EngineMaintenance> engineMaintenanceLambdaQueryWrapper = new LambdaQueryWrapper<>();
        engineMaintenanceLambdaQueryWrapper.in(EngineMaintenance::getId,ids);
        int delete = engineMapper.delete(engineMaintenanceLambdaQueryWrapper);

        return delete;
    }

    @Override
    public Result<EngineMaintenance> add(EngineMaintenance engineMaintenance) {
        Integer res = engineMapper.add(engineMaintenance);
        if (res > 0) {
            return Result.success();
        }
        return Result.error();
    }
}