#include <ScaleManager.h>

Classes
struct	LooseOSDEntry

struct	ScaleMetadata

Public Member Functions
	ScaleManager (const std::string &batteryPath, const std::string &workspacePath="")

	~ScaleManager ()

std::vector< std::string >	GetAvailableScales ()

std::shared_ptr< ScaleDefinition >	CreateScale (const std::string &code)

std::shared_ptr< ScaleDefinition >	LoadScale (const std::string &code)

bool	SaveScale (std::shared_ptr< ScaleDefinition > scale)

bool	DeleteScale (const std::string &code)

bool	ExportToBattery (std::shared_ptr< ScaleDefinition > scale)

std::shared_ptr< ScaleDefinition >	ImportFromFile (const std::string &filePath)

std::vector< LooseOSDEntry >	GetLooseOSDEntries () const

std::shared_ptr< ScaleDefinition >	InstallLooseOSD (const std::string &osdPath)

std::string	GetDefinitionPath (const std::string &code) const

std::string	GetOSDPath (const std::string &code) const

std::string	GetTranslationPath (const std::string &code, const std::string &lang) const

std::string	GetBatteryPath () const

std::string	GetWorkspacePath () const

std::string	GetBatteryScalesPath () const

std::string	GetWorkspaceScalesPath () const

std::string	GetScalesPath () const

std::string	GetDefinitionsPath () const

bool	ScaleExists (const std::string &code) const

ScaleMetadata	GetScaleMetadata (const std::string &code) const

bool	CreateStudyFromScale (std::shared_ptr< ScaleDefinition > scale, const std::string &workspaceStudiesPath, const std::string &studyName="")

bool	AddScaleToStudy (std::shared_ptr< ScaleDefinition > scale, const std::string &studyPath)

Detailed Description

Definition at line 14 of file ScaleManager.h.

Constructor & Destructor Documentation

◆ ScaleManager()

ScaleManager::ScaleManager	(	const std::string &	batteryPath,
		const std::string &	workspacePath = `""`
	)

Definition at line 24 of file ScaleManager.cpp.

    : mBatteryPath(batteryPath)
    , mWorkspacePath(workspacePath)
{
    // Library paths: media/apps/scales/ (relative to PEBL root, which is parent of battery/)
    mBatteryScalesPath = batteryPath + "/../media/apps/scales";
    mBatteryDefinitionsPath = mBatteryScalesPath + "/definitions";
 
    // Workspace paths (writable, user scales)
    if (!workspacePath.empty()) {
        mWorkspaceScalesPath = workspacePath + "/scales";
        mWorkspaceDefinitionsPath = mWorkspaceScalesPath + "/definitions";
    }
 
    EnsureDirectoriesExist();
}

◆ ~ScaleManager()

ScaleManager::~ScaleManager ( )

Definition at line 41 of file ScaleManager.cpp.

42{

43}

Member Function Documentation

◆ AddScaleToStudy()

bool ScaleManager::AddScaleToStudy	(	std::shared_ptr< ScaleDefinition >	scale,
		const std::string &	studyPath
	)

Definition at line 617 of file ScaleManager.cpp.

{
    if (!scale) {
        printf("Error: Scale is null\n");
        return false;
    }
 
    std::string scaleCode = scale->GetScaleInfo().code;
    printf("Adding scale '%s' to study at: %s\n", scaleCode.c_str(), studyPath.c_str());
 
    try {
        // Load the existing study
        auto study = Study::LoadFromDirectory(studyPath);
        if (!study) {
            printf("Error: Failed to load study from: %s\n", studyPath.c_str());
            return false;
        }
 
        // Check if this scale/test already exists in the study
        std::string testPath = studyPath + "/tests/" + scaleCode;
        if (fs::exists(testPath)) {
            printf("Removing existing test directory: %s\n", testPath.c_str());
            fs::remove_all(testPath);
        }
 
        // Create test directory with standard PEBL structure matching ScaleRunner's expected layout:
        //   tests/{code}/
        //     {code}.pbl         <- ScaleRunner.pbl (renamed)
        //     definitions/       <- {code}.json
        //     translations/      <- {code}.{lang}.json
        //     params/            <- schema + par files
        std::string paramsPath = testPath + "/params";
        fs::create_directories(testPath + "/definitions");
        fs::create_directories(testPath + "/translations");
        fs::create_directories(paramsPath);
 
        // Copy ScaleRunner.pbl
        std::string scaleRunnerSource = mBatteryScalesPath + "/ScaleRunner.pbl";
        std::string scaleRunnerDest = testPath + "/" + scaleCode + ".pbl";
 
        if (!fs::exists(scaleRunnerSource)) {
            printf("Error: ScaleRunner.pbl not found at: %s\n", scaleRunnerSource.c_str());
            return false;
        }
 
        fs::copy_file(scaleRunnerSource, scaleRunnerDest);
 
        // Export definition to definitions/ and translations to translations/
        if (!scale->ExportToJSON(testPath + "/definitions", testPath + "/translations")) {
            printf("Error: Failed to export scale files\n");
            return false;
        }
 
        // Create .pbl.about.txt from README.md if available, else from metadata
        {
            std::string aboutPath = testPath + "/" + scaleCode + ".pbl.about.txt";
            std::string readmePath = mBatteryDefinitionsPath + "/" + scaleCode + "/README.md";
            bool copied = false;
 
            if (fs::exists(readmePath)) {
                try {
                    fs::copy_file(readmePath, aboutPath, fs::copy_options::overwrite_existing);
                    copied = true;
                } catch (const std::exception&) {}
            }
 
            if (!copied && !mWorkspaceScalesPath.empty()) {
                std::string wsReadme = mWorkspaceScalesPath + "/" + scaleCode + "/README.md";
                if (fs::exists(wsReadme)) {
                    try {
                        fs::copy_file(wsReadme, aboutPath, fs::copy_options::overwrite_existing);
                        copied = true;
                    } catch (const std::exception&) {}
                }
            }
 
            if (!copied) {
                std::ofstream aboutFile(aboutPath);
                if (aboutFile.is_open()) {
                    const auto& info = scale->GetScaleInfo();
                    aboutFile << info.name << std::endl;
                    aboutFile << std::endl;
                    if (!info.description.empty()) {
                        aboutFile << info.description << std::endl;
                        aboutFile << std::endl;
                    }
                    if (!info.citation.empty()) {
                        aboutFile << "Citation:" << std::endl;
                        aboutFile << info.citation << std::endl;
                    }
                    aboutFile.close();
                }
            }
        }
 
        // Generate schema and parameter files from the scale's OSD parameters block
        GenerateSchemaFiles(*scale, testPath);
 
        // Generate screenshot for the deployed test
        GenerateScreenshot(scaleCode, testPath);
 
        // Add test to study (if not already present)
        if (!study->GetTest(scaleCode)) {
            Test test;
            test.testName = scaleCode;
            test.displayName = scale->GetScaleInfo().name;
            test.testPath = scaleCode;
            test.included = true;
            study->AddTest(test);
        }
 
        // Save study
        if (!study->Save()) {
            printf("Error: Failed to save study-info.json\n");
            return false;
        }
 
        printf("Successfully added scale '%s' to study\n", scaleCode.c_str());
        return true;
 
    } catch (const std::exception& e) {
        printf("Exception while adding scale to study: %s\n", e.what());
        return false;
    }
}

References Test::displayName, Test::included, Study::LoadFromDirectory(), Test::testName, and Test::testPath.

◆ CreateScale()

std::shared_ptr< ScaleDefinition > ScaleManager::CreateScale ( const std::string & code )

Definition at line 97 of file ScaleManager.cpp.

{
    return ScaleDefinition::CreateNew(code);
}

References ScaleDefinition::CreateNew().

◆ CreateStudyFromScale()

bool ScaleManager::CreateStudyFromScale	(	std::shared_ptr< ScaleDefinition >	scale,
		const std::string &	workspaceStudiesPath,
		const std::string &	studyName = `""`
	)

Definition at line 440 of file ScaleManager.cpp.

{
    if (!scale) {
        printf("Error: Scale is null\n");
        return false;
    }
 
    std::string scaleCode = scale->GetScaleInfo().code;
 
    // Use provided study name, or default to scale code
    std::string actualStudyName = studyName.empty() ? scaleCode : studyName;
    std::string studyPath = workspaceStudiesPath + "/" + actualStudyName;
 
    printf("Creating scale study at: %s\n", studyPath.c_str());
 
    try {
        // Check if study already exists - if so, remove it (overwrite mode)
        if (fs::exists(studyPath)) {
            printf("Removing existing study directory: %s\n", studyPath.c_str());
            fs::remove_all(studyPath);
        }
 
        // Create study using Study::CreateNew (use study name, not scale code)
        auto study = Study::CreateNew(studyPath, actualStudyName);
        if (!study) {
            printf("Error: Failed to create study structure\n");
            return false;
        }
 
        // Set study metadata from scale
        study->SetDescription("Scale: " + scale->GetScaleInfo().name);
        if (!scale->GetScaleInfo().citation.empty()) {
            study->SetAuthor(scale->GetScaleInfo().citation);
        }
 
        // Create test directory with standard PEBL structure matching ScaleRunner's expected layout:
        //   tests/{code}/
        //     {code}.pbl         <- ScaleRunner.pbl (renamed)
        //     definitions/       <- {code}.json
        //     translations/      <- {code}.{lang}.json
        //     params/            <- schema + par files
        std::string testPath = studyPath + "/tests/" + scaleCode;
        std::string paramsPath = testPath + "/params";
        fs::create_directories(testPath + "/definitions");
        fs::create_directories(testPath + "/translations");
        fs::create_directories(paramsPath);
 
        // Copy ScaleRunner.pbl and rename to match scale code
        std::string scaleRunnerSource = mBatteryScalesPath + "/ScaleRunner.pbl";
        std::string scaleRunnerDest = testPath + "/" + scaleCode + ".pbl";
 
        if (!fs::exists(scaleRunnerSource)) {
            printf("Error: ScaleRunner.pbl not found at: %s\n", scaleRunnerSource.c_str());
            return false;
        }
 
        fs::copy_file(scaleRunnerSource, scaleRunnerDest);
        printf("Copied ScaleRunner.pbl to %s\n", scaleRunnerDest.c_str());
 
        // Export definition to definitions/ and translations to translations/
        if (!scale->ExportToJSON(testPath + "/definitions", testPath + "/translations")) {
            printf("Error: Failed to export scale files\n");
            return false;
        }
 
        printf("Exported scale definition and translations\n");
 
        // Create .pbl.about.txt from README.md if available, else from metadata
        {
            std::string aboutPath = testPath + "/" + scaleCode + ".pbl.about.txt";
            std::string readmePath = mBatteryDefinitionsPath + "/" + scaleCode + "/README.md";
            bool copied = false;
 
            if (fs::exists(readmePath)) {
                try {
                    fs::copy_file(readmePath, aboutPath, fs::copy_options::overwrite_existing);
                    printf("Created about file from README.md: %s\n", aboutPath.c_str());
                    copied = true;
                } catch (const std::exception& e) {
                    printf("Warning: Failed to copy README.md: %s\n", e.what());
                }
            }
 
            // Also check workspace for README.md
            if (!copied && !mWorkspaceScalesPath.empty()) {
                std::string wsReadme = mWorkspaceScalesPath + "/" + scaleCode + "/README.md";
                if (fs::exists(wsReadme)) {
                    try {
                        fs::copy_file(wsReadme, aboutPath, fs::copy_options::overwrite_existing);
                        printf("Created about file from workspace README.md: %s\n", aboutPath.c_str());
                        copied = true;
                    } catch (const std::exception& e) {
                        printf("Warning: Failed to copy workspace README.md: %s\n", e.what());
                    }
                }
            }
 
            // Fallback: generate from scale metadata
            if (!copied) {
                std::ofstream aboutFile(aboutPath);
                if (aboutFile.is_open()) {
                    const auto& info = scale->GetScaleInfo();
                    aboutFile << info.name << std::endl;
                    aboutFile << std::endl;
                    if (!info.description.empty()) {
                        aboutFile << info.description << std::endl;
                        aboutFile << std::endl;
                    }
                    if (!info.citation.empty()) {
                        aboutFile << "Citation:" << std::endl;
                        aboutFile << info.citation << std::endl;
                        aboutFile << std::endl;
                    }
                    if (!info.license.empty()) {
                        aboutFile << "License: " << info.license << std::endl;
                    }
                    aboutFile.close();
                    printf("Created about file from metadata: %s\n", aboutPath.c_str());
                }
            }
        }
 
        // Generate schema and parameter files from the scale's OSD parameters block
        GenerateSchemaFiles(*scale, testPath);
 
        // Generate screenshot for the deployed test
        GenerateScreenshot(scaleCode, testPath);
 
        // Add test to study
        Test test;
        test.testName = scaleCode;  // The actual .pbl filename (e.g., "MOCI")
        test.displayName = scale->GetScaleInfo().name;  // Human-readable name
        test.testPath = scaleCode;  // Directory name (e.g., "MOCI")
        test.included = true;
 
        study->AddTest(test);
 
        // Save study
        if (!study->Save()) {
            printf("Error: Failed to save study-info.json\n");
            return false;
        }
 
        // Create default chain with the scale test
        std::string chainPath = studyPath + "/chains/Main.json";
        auto defaultChain = Chain::CreateNew(chainPath, "Main",
                                             "Default chain for " + scale->GetScaleInfo().name);
        if (defaultChain) {
            // Add the scale test to the chain
            ChainItem testItem(ItemType::Test);
            testItem.testName = scaleCode;
            testItem.paramVariant = "default";
            testItem.language = "en";
            testItem.randomGroup = 0;
 
            defaultChain->AddItem(testItem);
 
            if (defaultChain->Save()) {
                printf("Created default chain with test: Main.json\n");
            } else {
                printf("Warning: Failed to save default chain\n");
            }
        } else {
            printf("Warning: Failed to create default chain\n");
        }
 
        printf("Successfully created scale study: %s\n", scaleCode.c_str());
        return true;
 
    } catch (const std::exception& e) {
        printf("Exception while creating scale study: %s\n", e.what());
        return false;
    }
}

References Study::CreateNew(), Chain::CreateNew(), Test::displayName, Test::included, ChainItem::language, ChainItem::paramVariant, ChainItem::randomGroup, Test, ChainItem::testName, Test::testName, and Test::testPath.

◆ DeleteScale()

bool ScaleManager::DeleteScale ( const std::string & code )

Definition at line 140 of file ScaleManager.cpp.

{
    try {
        // Delete definition file
        std::string defPath = GetDefinitionPath(code);
        if (fs::exists(defPath)) {
            fs::remove(defPath);
        }
 
        // Delete all translation files
        auto transFiles = GetTranslationFiles(code);
        for (const auto& transFile : transFiles) {
            if (fs::exists(transFile)) {
                fs::remove(transFile);
            }
        }
 
        return true;
    } catch (const std::exception& e) {
        return false;
    }
}

References GetDefinitionPath().

◆ ExportToBattery()

bool ScaleManager::ExportToBattery ( std::shared_ptr< ScaleDefinition > scale )

Definition at line 163 of file ScaleManager.cpp.

{
    return SaveScale(scale);
}

References SaveScale().

◆ GetAvailableScales()

std::vector< std::string > ScaleManager::GetAvailableScales ( )

Definition at line 59 of file ScaleManager.cpp.

{
    std::set<std::string> scalesSet;  // Use set to avoid duplicates
 
    // Scan a directory for per-scale subdirectories containing <code>/<code>.json or <code>.osd
    auto scanForScales = [&](const std::string& basePath) {
        try {
            if (!fs::exists(basePath)) return;
            for (const auto& entry : fs::directory_iterator(basePath)) {
                if (entry.is_directory()) {
                    std::string dirName = entry.path().filename().string();
                    std::string defFile = entry.path().string() + "/" + dirName + ".json";
                    std::string osdFile = entry.path().string() + "/" + dirName + ".osd";
                    if (fs::exists(defFile) || fs::exists(osdFile)) {
                        scalesSet.insert(dirName);
                    }
                }
            }
        } catch (const std::exception& e) {
            // Continue on error
        }
    };
 
    // Scan library: media/apps/scales/definitions/<code>/<code>.json
    scanForScales(mBatteryDefinitionsPath);
 
    // Scan workspace: workspace/scales/<code>/<code>.json
    if (!mWorkspacePath.empty()) {
        scanForScales(mWorkspaceScalesPath);
    }
 
    // Convert set to sorted vector
    std::vector<std::string> scales(scalesSet.begin(), scalesSet.end());
    std::sort(scales.begin(), scales.end());
 
    return scales;
}

◆ GetBatteryPath()

std::string ScaleManager::GetBatteryPath ( ) const

inline

Definition at line 57 of file ScaleManager.h.

57{ return mBatteryPath; }

◆ GetBatteryScalesPath()

std::string ScaleManager::GetBatteryScalesPath ( ) const

inline

Definition at line 59 of file ScaleManager.h.

59{ return mBatteryScalesPath; }

◆ GetDefinitionPath()

std::string ScaleManager::GetDefinitionPath ( const std::string & code ) const

Definition at line 244 of file ScaleManager.cpp.

{
    // Check workspace: workspace/scales/<code>/<code>.json
    if (!mWorkspaceScalesPath.empty()) {
        std::string path = mWorkspaceScalesPath + "/" + code + "/" + code + ".json";
        if (fs::exists(path)) return path;
    }
    // Check library: media/apps/scales/definitions/<code>/<code>.json
    {
        std::string path = mBatteryDefinitionsPath + "/" + code + "/" + code + ".json";
        if (fs::exists(path)) return path;
    }
    // Return expected library path even if not found
    return mBatteryDefinitionsPath + "/" + code + "/" + code + ".json";
}

Referenced by DeleteScale(), GetScaleMetadata(), and ScaleExists().

◆ GetDefinitionsPath()

std::string ScaleManager::GetDefinitionsPath ( ) const

inline

Definition at line 64 of file ScaleManager.h.

64{ return mWorkspaceDefinitionsPath.empty() ? mBatteryDefinitionsPath : mWorkspaceDefinitionsPath; }

◆ GetLooseOSDEntries()

std::vector< ScaleManager::LooseOSDEntry > ScaleManager::GetLooseOSDEntries ( ) const

Definition at line 173 of file ScaleManager.cpp.

{
    std::vector<LooseOSDEntry> entries;
    if (mWorkspaceScalesPath.empty()) return entries;
 
    try {
        if (!fs::exists(mWorkspaceScalesPath)) return entries;
        for (const auto& entry : fs::directory_iterator(mWorkspaceScalesPath)) {
            if (!entry.is_regular_file()) continue;
            std::string filename = entry.path().filename().string();
            if (filename.size() < 5 || filename.substr(filename.size() - 4) != ".osd") continue;
 
            // Only treat as loose if there is no matching <code>/ subdirectory already
            std::string stemCode = filename.substr(0, filename.size() - 4);
            std::string subdirPath = mWorkspaceScalesPath + "/" + stemCode;
            if (fs::exists(subdirPath) && fs::is_directory(subdirPath)) continue;
 
            // Read code/name from the .osd bundle
            try {
                std::ifstream f(entry.path().string());
                if (!f.is_open()) continue;
                json bundle = json::parse(f);
                if (!bundle.contains("definition")) continue;
 
                LooseOSDEntry e;
                e.path = entry.path().string();
                if (bundle["definition"].contains("scale_info")) {
                    auto& si = bundle["definition"]["scale_info"];
                    if (si.contains("code")) e.code = si["code"].get<std::string>();
                    if (si.contains("name")) e.name = si["name"].get<std::string>();
                }
                if (e.code.empty()) e.code = stemCode;
                if (e.name.empty()) e.name = e.code;
                entries.push_back(e);
            } catch (...) {}
        }
    } catch (...) {}
 
    return entries;
}

References ScaleManager::LooseOSDEntry::code, ScaleManager::LooseOSDEntry::name, and ScaleManager::LooseOSDEntry::path.

◆ GetOSDPath()

std::string ScaleManager::GetOSDPath ( const std::string & code ) const

Definition at line 260 of file ScaleManager.cpp.

{
    // Check workspace: workspace/scales/<code>/<code>.osd
    if (!mWorkspaceScalesPath.empty()) {
        std::string path = mWorkspaceScalesPath + "/" + code + "/" + code + ".osd";
        if (fs::exists(path)) return path;
    }
    // Check library definitions: media/apps/scales/definitions/<code>/<code>.osd
    {
        std::string path = mBatteryDefinitionsPath + "/" + code + "/" + code + ".osd";
        if (fs::exists(path)) return path;
    }
    return "";
}

Referenced by GetScaleMetadata().

◆ GetScaleMetadata()

ScaleManager::ScaleMetadata ScaleManager::GetScaleMetadata ( const std::string & code ) const

Definition at line 357 of file ScaleManager.cpp.

{
    ScaleMetadata meta;
    meta.code = code;
    meta.questionCount = 0;
 
    try {
        std::string defPath = GetDefinitionPath(code);
        if (fs::exists(defPath)) {
            // Load from .json definition file
            std::ifstream file(defPath);
            if (!file.is_open()) return meta;
 
            json j;
            file >> j;
 
            if (j.contains("scale_info")) {
                auto& info = j["scale_info"];
                if (info.contains("name")) meta.name = info["name"];
                if (info.contains("description")) meta.description = info["description"];
                if (info.contains("author")) meta.author = info["author"];
            }
            if (j.contains("questions") && j["questions"].is_array()) {
                meta.questionCount = j["questions"].size();
            } else if (j.contains("items") && j["items"].is_array()) {
                meta.questionCount = j["items"].size();
            }
 
            // Get available languages from separate files
            auto transFiles = GetTranslationFiles(code);
            for (const auto& transFile : transFiles) {
                fs::path p(transFile);
                std::string filename = p.filename().string();
                std::string prefix = code + ".pbl-";
                if (filename.find(prefix) == 0 && filename.size() > prefix.length() + 5) {
                    std::string lang = filename.substr(prefix.length());
                    lang = lang.substr(0, lang.length() - 5);
                    meta.availableLanguages.push_back(lang);
                }
            }
        } else {
            // Fall back to .osd bundle
            std::string osdPath = GetOSDPath(code);
            if (osdPath.empty()) return meta;
 
            std::ifstream file(osdPath);
            if (!file.is_open()) return meta;
 
            json bundle;
            file >> bundle;
 
            if (!bundle.contains("definition")) return meta;
            auto& j = bundle["definition"];
 
            if (j.contains("scale_info")) {
                auto& info = j["scale_info"];
                if (info.contains("name")) meta.name = info["name"];
                if (info.contains("description")) meta.description = info["description"];
                if (info.contains("author")) meta.author = info["author"];
            }
            if (j.contains("items") && j["items"].is_array()) {
                meta.questionCount = j["items"].size();
            } else if (j.contains("questions") && j["questions"].is_array()) {
                meta.questionCount = j["questions"].size();
            }
 
            // Languages come from the translations block inside the bundle
            if (bundle.contains("translations") && bundle["translations"].is_object()) {
                for (auto& [lang, _] : bundle["translations"].items()) {
                    meta.availableLanguages.push_back(lang);
                }
            }
        }
 
        std::sort(meta.availableLanguages.begin(), meta.availableLanguages.end());
 
    } catch (const std::exception& e) {
        // Return partial metadata on error
    }
 
    return meta;
}

References ScaleManager::ScaleMetadata::author, ScaleManager::ScaleMetadata::availableLanguages, ScaleManager::ScaleMetadata::code, ScaleManager::ScaleMetadata::description, GetDefinitionPath(), GetOSDPath(), ScaleManager::ScaleMetadata::name, and ScaleManager::ScaleMetadata::questionCount.

◆ GetScalesPath()

std::string ScaleManager::GetScalesPath ( ) const

inline

Definition at line 63 of file ScaleManager.h.

63{ return mWorkspaceScalesPath.empty() ? mBatteryScalesPath : mWorkspaceScalesPath; }

Referenced by SaveScale().

◆ GetTranslationPath()

std::string ScaleManager::GetTranslationPath	(	const std::string &	code,
		const std::string &	lang
	)		const

Definition at line 275 of file ScaleManager.cpp.

{
    // Check workspace: new format first, then old
    if (!mWorkspaceScalesPath.empty()) {
        std::string newPath = mWorkspaceScalesPath + "/" + code + "/" + code + "." + lang + ".json";
        if (fs::exists(newPath)) return newPath;
        std::string oldPath = mWorkspaceScalesPath + "/" + code + "/" + code + ".pbl-" + lang + ".json";
        if (fs::exists(oldPath)) return oldPath;
    }
    // Check library: new format first, then old
    {
        std::string newPath = mBatteryDefinitionsPath + "/" + code + "/" + code + "." + lang + ".json";
        if (fs::exists(newPath)) return newPath;
        std::string oldPath = mBatteryDefinitionsPath + "/" + code + "/" + code + ".pbl-" + lang + ".json";
        if (fs::exists(oldPath)) return oldPath;
    }
    // Return expected path in new format
    return mBatteryDefinitionsPath + "/" + code + "/" + code + "." + lang + ".json";
}

◆ GetWorkspacePath()

std::string ScaleManager::GetWorkspacePath ( ) const

inline

Definition at line 58 of file ScaleManager.h.

58{ return mWorkspacePath; }

◆ GetWorkspaceScalesPath()

std::string ScaleManager::GetWorkspaceScalesPath ( ) const

inline

Definition at line 60 of file ScaleManager.h.

60{ return mWorkspaceScalesPath; }

◆ ImportFromFile()

std::shared_ptr< ScaleDefinition > ScaleManager::ImportFromFile ( const std::string & filePath )

Definition at line 168 of file ScaleManager.cpp.

{
    return ScaleDefinition::LoadFromFile(filePath);
}

References ScaleDefinition::LoadFromFile().

◆ InstallLooseOSD()

std::shared_ptr< ScaleDefinition > ScaleManager::InstallLooseOSD ( const std::string & osdPath )

Definition at line 214 of file ScaleManager.cpp.

{
    // Load the .osd to determine the scale code
    auto scale = ScaleDefinition::LoadFromOSDFile(osdPath);
    if (!scale) {
        printf("InstallLooseOSD: failed to load OSD from: %s\n", osdPath.c_str());
        return nullptr;
    }
    std::string code = scale->GetScaleInfo().code;
    if (code.empty()) {
        printf("InstallLooseOSD: scale has no code in: %s\n", osdPath.c_str());
        return nullptr;
    }
 
    // Create workspace/scales/<code>/ directory
    std::string targetDir = mWorkspaceScalesPath + "/" + code;
    std::string targetFile = targetDir + "/" + code + ".osd";
    try {
        fs::create_directories(targetDir);
        fs::copy_file(osdPath, targetFile, fs::copy_options::overwrite_existing);
        fs::remove(osdPath);  // Remove the loose file now that it is installed
        printf("Installed OSD '%s' to: %s\n", code.c_str(), targetFile.c_str());
    } catch (const std::exception& e) {
        printf("InstallLooseOSD error: %s\n", e.what());
        return nullptr;
    }
 
    return scale;
}

References ScaleDefinition::LoadFromOSDFile().

◆ LoadScale()

std::shared_ptr< ScaleDefinition > ScaleManager::LoadScale ( const std::string & code )

Definition at line 102 of file ScaleManager.cpp.

{
    auto scale = std::make_shared<ScaleDefinition>();
 
    // Try workspace first: workspace/scales/<code>/<code>.json
    if (!mWorkspaceScalesPath.empty()) {
        if (scale->LoadFromScalesDir(mWorkspaceScalesPath, code)) {
            return scale;
        }
    }
 
    // Fall back to library: media/apps/scales/definitions/<code>/<code>.json
    if (scale->LoadFromScalesDir(mBatteryDefinitionsPath, code)) {
        return scale;
    }
 
    return nullptr;
}

◆ SaveScale()

bool ScaleManager::SaveScale ( std::shared_ptr< ScaleDefinition > scale )

Definition at line 121 of file ScaleManager.cpp.

{
    if (!scale) {
        return false;
    }
 
    // Save to per-scale directory in workspace: workspace/scales/<code>/
    // Primary format is .osd (single-file bundle); no separate .json or translation files needed.
    std::string scaleDir = GetScalesPath() + "/" + scale->GetScaleInfo().code;
    try {
        fs::create_directories(scaleDir);
    } catch (const std::exception& e) {
        printf("Error creating scale directory: %s\n", e.what());
        return false;
    }
 
    return scale->ExportToOSD(scaleDir);
}

References GetScalesPath().

Referenced by ExportToBattery().

◆ ScaleExists()

bool ScaleManager::ScaleExists ( const std::string & code ) const

Definition at line 295 of file ScaleManager.cpp.

{
    return fs::exists(GetDefinitionPath(code));
}

References GetDefinitionPath().

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ScaleManager()

◆ ~ScaleManager()

Member Function Documentation

◆ AddScaleToStudy()

◆ CreateScale()

◆ CreateStudyFromScale()

◆ DeleteScale()

◆ ExportToBattery()

◆ GetAvailableScales()

◆ GetBatteryPath()

◆ GetBatteryScalesPath()

◆ GetDefinitionPath()

◆ GetDefinitionsPath()

◆ GetLooseOSDEntries()

◆ GetOSDPath()

◆ GetScaleMetadata()

◆ GetScalesPath()

◆ GetTranslationPath()

◆ GetWorkspacePath()

◆ GetWorkspaceScalesPath()

◆ ImportFromFile()

◆ InstallLooseOSD()

◆ LoadScale()

◆ SaveScale()

◆ ScaleExists()