ElogPerson.cxx

Go to the documentation of this file.

// ----------------------------------------------------------------------
//                    ElogPerson cxx file
//                      Generated 27-11-2017
// ----------------------------------------------------------------------
 
#include "ElogPerson.h"
 
#include "TSQLServer.h"
#include "TSQLStatement.h"
 
#include <iostream>
using namespace std;
 
/* GENERATED CLASS MEMBERS (SHOULD NOT BE CHANGED MANUALLY) */
// -----   Constructor with database connection   -----------------------
ElogPerson::ElogPerson(ElogConnection* db_connect, TString person_id, TString person_name, bool is_active, TString* email)
{
    connectionDB = db_connect;
 
    str_person_id = person_id;
    str_person_name = person_name;
    b_is_active = is_active;
    str_email = email;
}
 
// -----   Destructor   -------------------------------------------------
ElogPerson::~ElogPerson()
{
    if (connectionDB)
        delete connectionDB;
    if (str_email)
        delete str_email;
}
 
// -----   Creating new person in the database  ---------------------------
ElogPerson* ElogPerson::CreatePerson(TString person_name, bool is_active, TString* email)
{
    ElogConnection* connDb = ElogConnection::Open();
    if (connDb == nullptr)
        return nullptr;
 
    TSQLServer* db_server = connDb->GetSQLServer();
 
    TString sql = TString::Format("insert into person_(person_name, is_active, email) "
                                  "values ($1, $2, $3)");
    TSQLStatement* stmt = db_server->Statement(sql);
 
    stmt->NextIteration();
    stmt->SetString(0, person_name);
    stmt->SetInt(1, is_active);
    if (email == nullptr)
        stmt->SetNull(2);
    else
        stmt->SetString(2, *email);
 
    // inserting new person to the Database
    if (!stmt->Process()) {
        cout << "ERROR: inserting new person to the Database has been failed" << endl;
        delete stmt;
        delete connDb;
        return nullptr;
    }
 
    delete stmt;
 
    // getting last inserted ID
    TString person_id;
    TSQLStatement* stmt_last = db_server->Statement("SELECT currval(pg_get_serial_sequence('person_','person_id'))");
 
    // process getting last id
    if (stmt_last->Process()) {
        // store result of statement in buffer
        stmt_last->StoreResult();
 
        // if there is no last id then exit with error
        if (!stmt_last->NextResultRow()) {
            cout << "ERROR: no last ID in DB!" << endl;
            delete stmt_last;
            return nullptr;
        } else {
            person_id = stmt_last->GetString(0);
            delete stmt_last;
        }
    } else {
        cout << "ERROR: getting last ID has been failed!" << endl;
        delete stmt_last;
        return nullptr;
    }
 
    TString tmp_person_id;
    tmp_person_id = person_id;
    TString tmp_person_name;
    tmp_person_name = person_name;
    bool tmp_is_active;
    tmp_is_active = is_active;
    TString* tmp_email;
    if (email == nullptr)
        tmp_email = nullptr;
    else
        tmp_email = new TString(*email);
 
    return new ElogPerson(connDb, tmp_person_id, tmp_person_name, tmp_is_active, tmp_email);
}
 
// -----  Get person from the database  ---------------------------
ElogPerson* ElogPerson::GetPerson(TString person_id)
{
    ElogConnection* connDb = ElogConnection::Open();
    if (connDb == nullptr)
        return nullptr;
 
    TSQLServer* db_server = connDb->GetSQLServer();
 
    TString sql = TString::Format("select person_id, person_name, is_active, email "
                                  "from person_ "
                                  "where person_id = %s",
                                  person_id.Data());
    TSQLStatement* stmt = db_server->Statement(sql);
 
    // get person from the database
    if (!stmt->Process()) {
        cout << "ERROR: getting person from the database has been failed" << endl;
 
        delete stmt;
        delete connDb;
        return nullptr;
    }
 
    // store result of statement in buffer
    stmt->StoreResult();
 
    // extract row
    if (!stmt->NextResultRow()) {
        cout << "ERROR: person was not found in the database" << endl;
 
        delete stmt;
        delete connDb;
        return nullptr;
    }
 
    TString tmp_person_id;
    tmp_person_id = stmt->GetString(0);
    TString tmp_person_name;
    tmp_person_name = stmt->GetString(1);
    bool tmp_is_active;
    tmp_is_active = stmt->GetInt(2);
    TString* tmp_email;
    if (stmt->IsNull(3))
        tmp_email = nullptr;
    else
        tmp_email = new TString(stmt->GetString(3));
 
    delete stmt;
 
    return new ElogPerson(connDb, tmp_person_id, tmp_person_name, tmp_is_active, tmp_email);
}
 
// -----  Check person exists in the database  ---------------------------
int ElogPerson::CheckPersonExists(TString person_id)
{
    ElogConnection* connDb = ElogConnection::Open();
    if (connDb == nullptr)
        return -1;
 
    TSQLServer* db_server = connDb->GetSQLServer();
 
    TString sql = TString::Format("select 1 "
                                  "from person_ "
                                  "where person_id = %s",
                                  person_id.Data());
    TSQLStatement* stmt = db_server->Statement(sql);
 
    // get person from the database
    if (!stmt->Process()) {
        cout << "ERROR: getting person from the database has been failed" << endl;
 
        delete stmt;
        delete connDb;
        return -2;
    }
 
    // store result of statement in buffer
    stmt->StoreResult();
 
    // extract row
    if (!stmt->NextResultRow()) {
        delete stmt;
        delete connDb;
        return 0;
    }
 
    delete stmt;
    delete connDb;
 
    return 1;
}
 
// -----  Delete person from the database  ---------------------------
int ElogPerson::DeletePerson(TString person_id)
{
    ElogConnection* connDb = ElogConnection::Open();
    if (connDb == nullptr)
        return -1;
 
    TSQLServer* db_server = connDb->GetSQLServer();
 
    TString sql = TString::Format("delete from person_ "
                                  "where person_id = $1");
    TSQLStatement* stmt = db_server->Statement(sql);
 
    stmt->NextIteration();
    stmt->SetString(0, person_id);
 
    // delete person from the dataBase
    if (!stmt->Process()) {
        cout << "ERROR: deleting person from the dataBase has been failed" << endl;
 
        delete stmt;
        delete connDb;
        return -2;
    }
 
    delete stmt;
    delete connDb;
    return 0;
}
 
// -----  Print all 'persons'  ---------------------------------
int ElogPerson::PrintAll()
{
    ElogConnection* connDb = ElogConnection::Open();
    if (connDb == nullptr)
        return -1;
 
    TSQLServer* db_server = connDb->GetSQLServer();
 
    TString sql = TString::Format("select person_id, person_name, is_active, email "
                                  "from person_");
    TSQLStatement* stmt = db_server->Statement(sql);
 
    // get all 'persons' from the database
    if (!stmt->Process()) {
        cout << "ERROR: getting all 'persons' from the dataBase has been failed" << endl;
 
        delete stmt;
        delete connDb;
        return -2;
    }
 
    // store result of statement in buffer
    stmt->StoreResult();
 
    // print rows
    cout << "Table 'person_':" << endl;
    while (stmt->NextResultRow()) {
        cout << "person_id: ";
        cout << (stmt->GetString(0));
        cout << ", person_name: ";
        cout << (stmt->GetString(1));
        cout << ", is_active: ";
        cout << (stmt->GetInt(2));
        cout << ", email: ";
        if (stmt->IsNull(3))
            cout << "nullptr";
        else
            cout << stmt->GetString(3);
        cout << "." << endl;
    }
 
    delete stmt;
    delete connDb;
 
    return 0;
}
 
// Setters functions
int ElogPerson::SetPersonName(TString person_name)
{
    if (!connectionDB) {
        cout << "CRITICAL ERROR: Connection object is null" << endl;
        return -1;
    }
 
    TSQLServer* db_server = connectionDB->GetSQLServer();
 
    TString sql = TString::Format("update person_ "
                                  "set person_name = $1 "
                                  "where person_id = $2");
    TSQLStatement* stmt = db_server->Statement(sql);
 
    stmt->NextIteration();
    stmt->SetString(0, person_name);
    stmt->SetString(1, str_person_id);
 
    // write new value to the database
    if (!stmt->Process()) {
        cout << "ERROR: updating information about person has been failed" << endl;
 
        delete stmt;
        return -2;
    }
 
    str_person_name = person_name;
 
    delete stmt;
    return 0;
}
 
int ElogPerson::SetIsActive(bool is_active)
{
    if (!connectionDB) {
        cout << "CRITICAL ERROR: Connection object is null" << endl;
        return -1;
    }
 
    TSQLServer* db_server = connectionDB->GetSQLServer();
 
    TString sql = TString::Format("update person_ "
                                  "set is_active = $1 "
                                  "where person_id = $2");
    TSQLStatement* stmt = db_server->Statement(sql);
 
    stmt->NextIteration();
    stmt->SetInt(0, is_active);
    stmt->SetString(1, str_person_id);
 
    // write new value to the database
    if (!stmt->Process()) {
        cout << "ERROR: updating information about person has been failed" << endl;
 
        delete stmt;
        return -2;
    }
 
    b_is_active = is_active;
 
    delete stmt;
    return 0;
}
 
int ElogPerson::SetEmail(TString* email)
{
    if (!connectionDB) {
        cout << "CRITICAL ERROR: Connection object is null" << endl;
        return -1;
    }
 
    TSQLServer* db_server = connectionDB->GetSQLServer();
 
    TString sql = TString::Format("update person_ "
                                  "set email = $1 "
                                  "where person_id = $2");
    TSQLStatement* stmt = db_server->Statement(sql);
 
    stmt->NextIteration();
    if (email == nullptr)
        stmt->SetNull(0);
    else
        stmt->SetString(0, *email);
    stmt->SetString(1, str_person_id);
 
    // write new value to the database
    if (!stmt->Process()) {
        cout << "ERROR: updating information about person has been failed" << endl;
 
        delete stmt;
        return -2;
    }
 
    if (str_email)
        delete str_email;
    if (email == nullptr)
        str_email = nullptr;
    else
        str_email = new TString(*email);
 
    delete stmt;
    return 0;
}
 
// -----  Print current person  ---------------------------------------
void ElogPerson::Print()
{
    cout << "Table 'person_'";
    cout << ". person_id: " << str_person_id << ". person_name: " << str_person_name << ". is_active: " << b_is_active
         << ". email: " << (str_email == nullptr ? "nullptr" : *str_email) << endl;
 
    return;
}
/* END OF GENERATED CLASS PART (SHOULD NOT BE CHANGED MANUALLY) */
 
// -----  Get persons from the database by name or its part  -----
TObjArray* ElogPerson::GetPersonByName(TString person_name_part)
{
    TObjArray* arrayResult = nullptr;
    
    ElogConnection* connDb = ElogConnection::Open();
    if (connDb == nullptr)
    {
        cout << "ERROR: connection to the eLog Database was failed" << endl;
        return arrayResult;
    }
 
    TSQLServer* db_server = connDb->GetSQLServer();
 
    TString sql = TString::Format("select person_id, person_name, is_active, email "
                                  "from person_ "
                                  "where lower(person_name) like lower('%s')",
                                  person_name_part.Data());
    TSQLStatement* stmt = db_server->Statement(sql);
 
    // get persons from the database
    if (!stmt->Process()) {
        cout << "ERROR: getting person from the database has been failed" << endl;
 
        delete stmt;
        delete connDb;
        return arrayResult;
    }
 
    // store result of statement in buffer
    stmt->StoreResult();
 
    // extract rows one after another
    arrayResult = new TObjArray();
    arrayResult->SetOwner(kTRUE);
    while (stmt->NextResultRow()) {
        ElogConnection* connRecord = ElogConnection::Open();
        if (connRecord == nullptr) {
            cout << "ERROR: connection to the eLog database for a record was failed" << endl;
            return arrayResult;
        }
        
        TString tmp_person_id;
        tmp_person_id = stmt->GetString(0);
        TString tmp_person_name;
        tmp_person_name = stmt->GetString(1);
        bool tmp_is_active;
        tmp_is_active = stmt->GetInt(2);
        TString* tmp_email;
        if (stmt->IsNull(3))
            tmp_email = nullptr;
        else
            tmp_email = new TString(stmt->GetString(3));
        
        arrayResult->Add((TObject*)new ElogPerson(
            connDb, tmp_person_id, tmp_person_name, tmp_is_active, tmp_email));
    }
 
    delete stmt;
 
    return arrayResult;
}
 
// -----  Check persons exists in the database by name or its part:  ------------
// -----  >=1 - person count, 0 - false, <0 - database operation error  ---------
int ElogPerson::CheckPersonExistsByName(TString person_name_part)
{
    ElogConnection* connDb = ElogConnection::Open();
    if (connDb == nullptr)
        return -1;
 
    TSQLServer* db_server = connDb->GetSQLServer();
 
    TString sql = TString::Format("select count(person_id) "
                                  "from person_ "
                                  "where lower(person_name) like lower('%s')",
                                  person_name_part.Data());
    TSQLStatement* stmt = db_server->Statement(sql);
 
    // get person from the database
    if (!stmt->Process()) {
        cout << "ERROR: checking persons in the database has been failed" << endl;
 
        delete stmt;
        delete connDb;
        return -2;
    }
 
    // store result of statement in buffer
    stmt->StoreResult();
 
    // extract row
    if (!stmt->NextResultRow()) {
        delete stmt;
        delete connDb;
        return 0;
    }
 
    int person_count = stmt->GetInt(0);
 
    delete stmt;
    delete connDb;
 
    return person_count;
}
 
// -----  Delete persons from the database by name or its part  -----------------
// -----  >=1 - affected count, 0 - persons not found, <0 - database error  -----
int ElogPerson::DeletePersonByName(TString person_name_part)
{
    ElogConnection* connDb = ElogConnection::Open();
    if (connDb == nullptr)
        return -1;
 
    TSQLServer* db_server = connDb->GetSQLServer();
 
    TString sql = TString::Format("delete from person_ "
                                  "where lower(person_name) like lower($1)");
    TSQLStatement* stmt = db_server->Statement(sql);
 
    stmt->NextIteration();
    stmt->SetString(0, person_name_part);
 
    // delete person from the dataBase
    if (!stmt->Process()) {
        cout << "ERROR: deleting persons from the database has been failed" << endl;
 
        delete stmt;
        delete connDb;
        return -2;
    }
 
    // get affected rows after Process()
    Int_t deleted_count = stmt->GetNumAffectedRows();
 
    delete stmt;
    delete connDb;
    
    return deleted_count;
}