IotCenter/src/main/java/com/zswl/dataservice/service/docker/DockerMetaService.java

package com.zswl.dataservice.service.docker;

import com.zswl.dataservice.dao.docker.DockerMetaDao;
import com.zswl.dataservice.dao.docker.DockerMetaLastTimeDao;
import com.zswl.dataservice.dataConfig.ResultMessage;
import com.zswl.dataservice.domain.docker.DockerMeta;
import com.zswl.dataservice.domain.docker.DockerMetaLastTime;
import com.zswl.dataservice.domain.mqtt.DeviceInfo;
import com.zswl.dataservice.model.docker.*;
import com.zswl.dataservice.model.mqtt.DeviceInfoModel;
import com.zswl.dataservice.model.mqtt.DeviceInfoSearchParam;
import com.zswl.dataservice.service.base.SuperService;
import com.zswl.dataservice.utils.bean.BeanUtils;
import com.zswl.dataservice.utils.page.PageEntityUtil;
import com.zswl.dataservice.utils.result.ResultContent;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;

import java.util.ArrayList;
import java.util.List;

/**
 * @author TRX
 * @date 2024/7/25
 */
@Slf4j
@Service
public class DockerMetaService extends SuperService {

    @Autowired
    private DockerMetaDao dockerMetaDao;

    @Autowired
    private DockerMetaLastTimeDao dockerMetaLastTimeDao;

    /**
     * 添加docker元数据
     *
     * @param param
     * @return
     */
    public ResultContent addOrUpdate(DockerMetaParam param) {
        String groupCode = param.getGroupCode();
        Assert.hasText(param.getGroupCode(), "groupCode不能为空");
        Assert.hasText(param.getName(), "name不能为空");
        Assert.hasText(param.getImage(), "image不能为空");

        DockerMeta dockerMeta = new DockerMeta();
        DockerMeta temp = dockerMetaDao.findTopByGroupCodeAndName(groupCode, param.getName());
        if (StringUtils.isNotEmpty(param.getId())) {
            dockerMeta = dockerMetaDao.findTopById(param.getId());
            if (ObjectUtils.isEmpty(dockerMeta)) {
                return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, param.getId()));
            }
            if (ObjectUtils.isNotEmpty(temp) && !temp.getId().equals(dockerMeta.getId())) {
                return ResultContent.buildFail(String.format(
                        "分组【%s】下已存在名称【%s】", groupCode, param.getName()));
            }
        } else {
            if (ObjectUtils.isNotEmpty(temp)) {
                return ResultContent.buildFail(String.format(
                        "分组【%s】下已存在名称【%s】", groupCode, param.getName()));
            }
            dockerMeta = new DockerMeta();
            param.setId(null);
        }
        BeanUtils.copyProperties(param, dockerMeta);
        dockerMetaDao.save(dockerMeta);
        updateLastTime(groupCode);
        return ResultContent.buildSuccess();
    }

    /**
     * 删除docker元数据
     *
     * @param id
     * @return
     */
    public ResultContent deleteMeta(String id) {
        DockerMeta dockerMeta = dockerMetaDao.findTopById(id);
        if (ObjectUtils.isEmpty(dockerMeta)) {
            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, id));
        }
        updateLastTime(dockerMeta.getGroupCode());
        dockerMetaDao.delete(dockerMeta);
        return ResultContent.buildSuccess();
    }

    /**
     * 得到详情
     *
     * @param id
     * @return
     */
    public ResultContent<DockerMetaModel> getDockerMeta(String id) {
        DockerMeta dockerMeta = dockerMetaDao.findTopById(id);
        if (ObjectUtils.isEmpty(dockerMeta)) {
            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, id));
        }
        DockerMetaModel model = toModel(dockerMeta);
        return ResultContent.buildSuccess(model);
    }

    public ResultContent<Page<DockerMetaModel>> page(Pageable pageable, DockerMetaSearch param) {
        Page<DockerMeta> page = dockerMetaDao.page(pageable, param);
        return ResultContent.buildSuccess(PageEntityUtil.toPageModel(page, this::toModel));
    }

    public ResultContent updateLastTime(String groupCode) {
        DockerMetaLastTime lastTime = dockerMetaLastTimeDao.findTopByGroupCode(groupCode);
        if (ObjectUtils.isEmpty(lastTime)) {
            lastTime = new DockerMetaLastTime();
        }
        lastTime.setLastTime(System.currentTimeMillis());
        dockerMetaLastTimeDao.save(lastTime);
        return ResultContent.buildSuccess();
    }

    public DockerMetaLastTimeModel getVersion() {
        DockerMetaLastTimeModel model = new DockerMetaLastTimeModel();
        String groupCode = getHeader("groupCode");
        DockerMetaLastTime lastTime = dockerMetaLastTimeDao.findTopByGroupCode(groupCode);
        if (ObjectUtils.isNotEmpty(lastTime)) {
            model.setUpdateTime(lastTime.getLastTime());
        }
        return model;
    }

    public List<DockerListModel> getList() {
        List<DockerListModel> list = new ArrayList<>();

        return list;
    }

    public DockerMetaModel toModel(DockerMeta entity) {
        DockerMetaModel model = null;
        if (ObjectUtils.isNotEmpty(entity)) {
            model = new DockerMetaModel();
            BeanUtils.copyProperties(entity, model);
        }
        return model;
    }

}