suyu_two/app/src/services/alarm_editor_service.cpp

#include "alarm_editor_service.h"

#include "project_service.h"
#include "domain/project_limits.h"

#include <algorithm>

namespace {

AlarmEditorResult failure(AlarmEditorError error, const std::string &message)
{
    return {false, error, message, {}};
}

} // namespace

AlarmEditorService::AlarmEditorService(ProjectService &project_service)
    : project_service_(project_service)
{
}

const std::vector<AlarmDefinition> &AlarmEditorService::definitions() const
{
    return project_service_.project().alarmDefinitions;
}

const AlarmDefinition *AlarmEditorService::findDefinition(
    const std::string &id) const
{
    const auto &definitions = project_service_.project().alarmDefinitions;
    const auto definition = std::find_if(
        definitions.cbegin(), definitions.cend(),
        [&id](const AlarmDefinition &candidate) { return candidate.id == id; });
    return definition == definitions.cend() ? nullptr : &*definition;
}

AlarmEditorResult AlarmEditorService::addDefinition(
    const AlarmDefinition &definition)
{
    if (definitions().size() >= ProjectLimits::kMaximumAlarmDefinitions)
    {
        return failure(AlarmEditorError::InvalidDefinition, "单个工程最多包含 512 条报警定义");
    }
    AlarmDefinition candidate = definition;
    candidate.id = makeUniqueId();
    std::string error;
    if (!candidate.validate(&error))
    {
        return failure(AlarmEditorError::InvalidDefinition, error);
    }
    project_service_.editProject().alarmDefinitions.push_back(candidate);
    return {true, AlarmEditorError::None, {}, candidate.id};
}

AlarmEditorResult AlarmEditorService::updateDefinition(
    const std::string &id, const AlarmDefinition &definition)
{
    if (findDefinition(id) == nullptr)
    {
        return failure(AlarmEditorError::NotFound, "未找到报警定义");
    }
    AlarmDefinition candidate = definition;
    candidate.id = id;
    std::string error;
    if (!candidate.validate(&error))
    {
        return failure(AlarmEditorError::InvalidDefinition, error);
    }

    Project &project = project_service_.editProject();
    auto editable = std::find_if(
        project.alarmDefinitions.begin(), project.alarmDefinitions.end(),
        [&id](const AlarmDefinition &item) { return item.id == id; });
    *editable = std::move(candidate);
    return {true, AlarmEditorError::None, {}, id};
}

AlarmEditorResult AlarmEditorService::removeDefinition(const std::string &id)
{
    if (findDefinition(id) == nullptr)
    {
        return failure(AlarmEditorError::NotFound, "未找到报警定义");
    }
    Project &project = project_service_.editProject();
    project.alarmDefinitions.erase(
        std::remove_if(
            project.alarmDefinitions.begin(), project.alarmDefinitions.end(),
            [&id](const AlarmDefinition &definition)
            {
                return definition.id == id;
            }),
        project.alarmDefinitions.end());
    return {true, AlarmEditorError::None, {}, id};
}

std::string AlarmEditorService::makeUniqueId() const
{
    int suffix = 1;
    while (true)
    {
        const std::string candidate = "alarm-" + std::to_string(suffix);
        if (findDefinition(candidate) == nullptr)
        {
            return candidate;
        }
        ++suffix;
    }
}