Study Class Reference

#include <Study.h>

Classes
struct	ValidationResult

Public Member Functions
	Study ()
	~Study ()
bool	Save ()
const std::string &	GetName () const
const std::string &	GetDescription () const
int	GetVersion () const
const std::string &	GetAuthor () const
const std::string &	GetStudyToken () const
const std::string &	GetUploadServerURL () const
bool	GetUploadEnabled () const
const std::string &	GetCreatedDate () const
const std::string &	GetModifiedDate () const
const std::string &	GetPath () const
const std::vector< Test > &	GetTests () const
std::string	GetStudyCode () const
void	SetName (const std::string &name)
void	SetDescription (const std::string &desc)
void	SetAuthor (const std::string &author)
void	SetStudyToken (const std::string &token)
void	SetUploadServerURL (const std::string &url)
void	SetUploadEnabled (bool enabled)
void	IncrementVersion ()
bool	AddTest (const Test &test)
bool	RemoveTest (const std::string &testName)
Test *	GetTest (const std::string &testName)
const Test *	GetTest (const std::string &testName) const
std::vector< std::string >	GetChainFiles () const
int	GetChainCount () const
bool	CreateUploadConfigForTest (const std::string &testName)
std::string	GetUploadConfigPath (const std::string &testName) const
bool	TestHasUploadConfig (const std::string &testName) const
ValidationResult	Validate () const

Static Public Member Functions
static std::shared_ptr< Study >	LoadFromDirectory (const std::string &path)
static std::shared_ptr< Study >	CreateNew (const std::string &path, const std::string &name, const std::string &author="")

Detailed Description

Definition at line 44 of file Study.h.

Constructor & Destructor Documentation

Study()

Study::Study

(

)

Definition at line 92 of file Study.cpp.

    : mVersion(1), mUploadEnabled(false)
{
}

~Study()

Study::~Study

(

)

Definition at line 97 of file Study.cpp.

              {
}

Member Function Documentation

AddTest()

bool Study::AddTest

(

const Test &

test

)

Definition at line 161 of file Study.cpp.

                                    {
    // Check if test already exists
    for (const auto& t : mTests) {
        if (t.testName == test.testName) {
            return false;  // Already exists
        }
    }
 
    mTests.push_back(test);
    UpdateModifiedDate();
    return true;
}

References Test::testName.

CreateNew()

std::shared_ptr< Study > Study::CreateNew ( const std::string &  path, const std::string &  name, const std::string &  author = ""  )

static

Definition at line 129 of file Study.cpp.

                                                                  {
    auto study = std::make_shared<Study>();
    study->mPath = path;
    study->mName = name;
    study->mAuthor = author;
    study->mVersion = 1;
    study->mCreatedDate = study->GetCurrentISO8601Time();
    study->mModifiedDate = study->mCreatedDate;
 
    // Create directory structure using filesystem API (handles paths with spaces)
    try {
        fs::create_directories(path);
        fs::create_directories(fs::path(path) / "chains");
        fs::create_directories(fs::path(path) / "tests");
        // Note: data/ directory removed - not needed in study structure
    } catch (const fs::filesystem_error& e) {
        printf("Error creating study directories: %s\n", e.what());
    }
 
    // Create default chain
    std::string chainPath = path + "/chains/Main.json";
    auto defaultChain = Chain::CreateNew(chainPath, "Main", "Default chain for this study");
    if (defaultChain) {
        defaultChain->Save();
        printf("Created default chain: Main.json\n");
    }
 
    return study;
}

References Chain::CreateNew().

Referenced by ScaleManager::CreateStudyFromScale().

CreateUploadConfigForTest()

bool Study::CreateUploadConfigForTest

(

const std::string &

testName

)

Definition at line 458 of file Study.cpp.

                                                               {
    // Validate inputs
    if (mStudyToken.empty()) {
        printf("Cannot create upload config: study token not set\n");
        return false;
    }
 
    if (mUploadServerURL.empty()) {
        printf("Cannot create upload config: upload server URL not set\n");
        return false;
    }
 
    // Get test
    const Test* test = GetTest(testName);
    if (!test) {
        printf("Cannot create upload config: test not found: %s\n", testName.c_str());
        return false;
    }
 
    // Parse server URL to extract host, port, path
    std::string host, page;
    int port = 443;  // Default HTTPS port
 
    std::string url = mUploadServerURL;
 
    // Remove protocol
    if (url.find("https://") == 0) {
        url = url.substr(8);
        port = 443;
    } else if (url.find("http://") == 0) {
        url = url.substr(7);
        port = 80;
    }
 
    // Find first slash to separate host from path
    size_t slashPos = url.find('/');
    if (slashPos != std::string::npos) {
        host = url.substr(0, slashPos);
        page = url.substr(slashPos);
    } else {
        host = url;
        page = "/api/upload.php";  // Default page
    }
 
    // Check for port in host (host:port format)
    size_t colonPos = host.find(':');
    if (colonPos != std::string::npos) {
        std::string portStr = host.substr(colonPos + 1);
        port = std::atoi(portStr.c_str());
        host = host.substr(0, colonPos);
    }
 
    // Create upload.json content
    try {
        json j;
        j["host"] = host;
        j["page"] = page;
        j["subnumpage"] = "/api/getNewParticipantId.php";  // For server-assigned participant IDs
        j["port"] = port;
        j["token"] = mStudyToken;
        j["taskname"] = testName;
        j["username"] = mStudyToken;
        j["uploadpassword"] = mStudyToken;
 
        // Write to file
        std::string uploadPath = GetUploadConfigPath(testName);
 
        // Ensure test directory exists
        std::string testDir = mPath + "/tests/" + testName;
        try {
            fs::create_directories(testDir);
        } catch (const fs::filesystem_error& e) {
            printf("Error creating test directory: %s\n", e.what());
            return false;
        }
 
        std::ofstream file(uploadPath);
        if (!file.is_open()) {
            printf("Failed to create upload config file: %s\n", uploadPath.c_str());
            return false;
        }
 
        file << j.dump(2);  // Pretty print with 2-space indent
        file.close();
 
        printf("Created upload config: %s\n", uploadPath.c_str());
        return true;
 
    } catch (const std::exception& e) {
        printf("Error creating upload config: %s\n", e.what());
        return false;
    }
}

References GetTest(), and GetUploadConfigPath().

GetAuthor()

const std::string & Study::GetAuthor ( ) const

inline

Definition at line 64 of file Study.h.

{ return mAuthor; }

GetChainCount()

int Study::GetChainCount

(

)

const

Definition at line 235 of file Study.cpp.

                               {
    return static_cast<int>(GetChainFiles().size());
}

References GetChainFiles().

GetChainFiles()

std::vector< std::string > Study::GetChainFiles

(

)

const

Definition at line 209 of file Study.cpp.

                                                {
    std::vector<std::string> chains;
    std::string chainsDir = mPath + "/chains";
 
    try {
        if (!fs::exists(chainsDir) || !fs::is_directory(chainsDir)) {
            return chains;
        }
 
        for (const auto& entry : fs::directory_iterator(chainsDir)) {
            if (!entry.is_regular_file()) continue;
 
            std::string filename = entry.path().filename().string();
 
            // Look for .json files
            if (filename.size() > 5 && filename.substr(filename.size() - 5) == ".json") {
                chains.push_back(filename);
            }
        }
    } catch (const fs::filesystem_error&) {
        // Directory doesn't exist or can't be read
    }
 
    return chains;
}

Referenced by GetChainCount().

GetCreatedDate()

const std::string & Study::GetCreatedDate ( ) const

inline

Definition at line 68 of file Study.h.

{ return mCreatedDate; }

GetDescription()

const std::string & Study::GetDescription ( ) const

inline

Definition at line 62 of file Study.h.

{ return mDescription; }

GetModifiedDate()

const std::string & Study::GetModifiedDate ( ) const

inline

Definition at line 69 of file Study.h.

{ return mModifiedDate; }

GetName()

const std::string & Study::GetName ( ) const

inline

Definition at line 61 of file Study.h.

{ return mName; }

GetPath()

const std::string & Study::GetPath ( ) const

inline

Definition at line 70 of file Study.h.

{ return mPath; }

Referenced by Chain::Validate().

GetStudyCode()

std::string Study::GetStudyCode

(

)

const

Definition at line 422 of file Study.cpp.

                                    {
    std::string code;
    code.reserve(4);
 
    // Extract first 4 alphanumeric characters from study name
    for (char c : mName) {
        if (std::isalnum(static_cast<unsigned char>(c))) {
            code += std::toupper(static_cast<unsigned char>(c));
            if (code.length() >= 4) {
                break;
            }
        }
    }
 
    // Pad with 'X' if less than 4 characters
    while (code.length() < 4) {
        code += 'X';
    }
 
    return code;
}

GetStudyToken()

const std::string & Study::GetStudyToken ( ) const

inline

Definition at line 65 of file Study.h.

{ return mStudyToken; }

GetTest() [1/2]

Test * Study::GetTest

(

const std::string &

testName

)

Definition at line 187 of file Study.cpp.

                                              {
    auto it = std::find_if(mTests.begin(), mTests.end(),
                          [&testName](const Test& t) { return t.testName == testName; });
 
    if (it != mTests.end()) {
        return &(*it);
    }
 
    return nullptr;
}

Referenced by CreateUploadConfigForTest(), and Chain::Validate().

GetTest() [2/2]

const Test * Study::GetTest

(

const std::string &

testName

)

const

Definition at line 198 of file Study.cpp.

                                                          {
    auto it = std::find_if(mTests.begin(), mTests.end(),
                          [&testName](const Test& t) { return t.testName == testName; });
 
    if (it != mTests.end()) {
        return &(*it);
    }
 
    return nullptr;
}

GetTests()

const std::vector< Test > & Study::GetTests ( ) const

inline

Definition at line 71 of file Study.h.

{ return mTests; }

GetUploadConfigPath()

std::string Study::GetUploadConfigPath

(

const std::string &

testName

)

const

Definition at line 448 of file Study.cpp.

                                                                    {
    return mPath + "/tests/" + testName + "/upload.json";
}

Referenced by CreateUploadConfigForTest(), and TestHasUploadConfig().

GetUploadEnabled()

bool Study::GetUploadEnabled ( ) const

inline

Definition at line 67 of file Study.h.

{ return mUploadEnabled; }

GetUploadServerURL()

const std::string & Study::GetUploadServerURL ( ) const

inline

Definition at line 66 of file Study.h.

{ return mUploadServerURL; }

GetVersion()

int Study::GetVersion ( ) const

inline

Definition at line 63 of file Study.h.

{ return mVersion; }

IncrementVersion()

void Study::IncrementVersion ( )

inline

Definition at line 83 of file Study.h.

{ mVersion++; UpdateModifiedDate(); }

LoadFromDirectory()

std::shared_ptr< Study > Study::LoadFromDirectory ( const std::string &  path )

static

Definition at line 100 of file Study.cpp.

                                                                   {
    auto study = std::make_shared<Study>();
    study->mPath = path;
 
    std::string jsonPath = path + "/study-info.json";
    printf("  Looking for: %s\n", jsonPath.c_str());
 
    // Check if file exists
    std::ifstream testFile(jsonPath);
    if (!testFile.good()) {
        printf("  File does not exist or cannot be opened\n");
        return nullptr;
    }
    testFile.close();
 
    if (!study->LoadFromJSON(jsonPath)) {
        printf("  Failed to parse JSON from file\n");
        return nullptr;
    }
 
    printf("  Successfully loaded study: %s\n", study->GetName().c_str());
    return study;
}

Referenced by ScaleManager::AddScaleToStudy(), SnapshotManager::CreateSnapshot(), SnapshotManager::GetSnapshotInfo(), and SnapshotManager::ValidateSnapshot().

RemoveTest()

bool Study::RemoveTest

(

const std::string &

testName

)

Definition at line 174 of file Study.cpp.

                                                {
    auto it = std::find_if(mTests.begin(), mTests.end(),
                          [&testName](const Test& t) { return t.testName == testName; });
 
    if (it != mTests.end()) {
        mTests.erase(it);
        UpdateModifiedDate();
        return true;
    }
 
    return false;
}

Save()

bool Study::Save

(

)

Definition at line 124 of file Study.cpp.

                 {
    std::string jsonPath = mPath + "/study-info.json";
    return SaveToJSON(jsonPath);
}

SetAuthor()

void Study::SetAuthor ( const std::string &  author )

inline

Definition at line 79 of file Study.h.

{ mAuthor = author; UpdateModifiedDate(); }

SetDescription()

void Study::SetDescription ( const std::string &  desc )

inline

Definition at line 78 of file Study.h.

{ mDescription = desc; UpdateModifiedDate(); }

SetName()

void Study::SetName ( const std::string &  name )

inline

Definition at line 77 of file Study.h.

{ mName = name; UpdateModifiedDate(); }

SetStudyToken()

void Study::SetStudyToken ( const std::string &  token )

inline

Definition at line 80 of file Study.h.

{ mStudyToken = token; UpdateModifiedDate(); }

SetUploadEnabled()

void Study::SetUploadEnabled ( bool  enabled )

inline

Definition at line 82 of file Study.h.

{ mUploadEnabled = enabled; UpdateModifiedDate(); }

SetUploadServerURL()

void Study::SetUploadServerURL ( const std::string &  url )

inline

Definition at line 81 of file Study.h.

{ mUploadServerURL = url; UpdateModifiedDate(); }

TestHasUploadConfig()

bool Study::TestHasUploadConfig

(

const std::string &

testName

)

const

Definition at line 452 of file Study.cpp.

                                                               {
    std::string uploadPath = GetUploadConfigPath(testName);
    struct stat info;
    return (stat(uploadPath.c_str(), &info) == 0);
}

References GetUploadConfigPath().

Validate()

Study::ValidationResult Study::Validate

(

)

const

Definition at line 239 of file Study.cpp.

                                            {
    ValidationResult result;
 
    // Check required fields
    if (mName.empty()) {
        result.errors.push_back("Study name is required");
    }
 
    if (mPath.empty()) {
        result.errors.push_back("Study path is required");
    }
 
    if (mVersion < 1) {
        result.errors.push_back("Study version must be >= 1");
    }
 
    // Check directory structure
    struct stat info;
    if (stat(mPath.c_str(), &info) != 0 || !(info.st_mode & S_IFDIR)) {
        result.errors.push_back("Study directory does not exist: " + mPath);
    } else {
        // Check subdirectories
        std::string chainsDir = mPath + "/chains";
        if (stat(chainsDir.c_str(), &info) != 0 || !(info.st_mode & S_IFDIR)) {
            result.warnings.push_back("chains/ directory missing");
        }
 
        std::string testsDir = mPath + "/tests";
        if (stat(testsDir.c_str(), &info) != 0 || !(info.st_mode & S_IFDIR)) {
            result.warnings.push_back("tests/ directory missing");
        }
    }
 
    // Validate tests
    for (const auto& test : mTests) {
        if (test.testName.empty()) {
            result.errors.push_back("Test name cannot be empty");
        }
 
        if (test.testPath.empty()) {
            result.errors.push_back("Test path cannot be empty for test: " + test.testName);
        }
 
        // Check if test directory exists
        if (!test.Exists(mPath)) {
            result.warnings.push_back("Test directory not found: " + test.testPath);
        }
    }
 
    return result;
}

References Study::ValidationResult::errors, and Study::ValidationResult::warnings.

---

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

• Study.h
• Study.cpp