core-legacy/models/schedule_dbo.cc

#include <cstring>
#include <trantor/utils/Logger.h>
#include <helpers.h>
#include "schedule_dbo.h"
#include "junction_tag_dbo.h"
#include "tag_dbo.h"
#include "globals.h"
#include "period.h"

static bool schedule_db_update_insert(schedule_dbo *schedule, sqlite3_stmt *stmt)
{
    int rc;
    uint16_t *periods_blob = schedule->periods->to_blob();
    int blob_size = (int)sizeof(uint16_t) * ((periods_blob[0] * 2) + 1);

    sqlite3_bind_int(stmt, 1, schedule->id);
    sqlite3_bind_blob(stmt, 2, schedule->uid, sizeof(uuid_t), SQLITE_STATIC);
    sqlite3_bind_text(stmt, 3, schedule->name, -1, SQLITE_STATIC);
    sqlite3_bind_blob(stmt, 4, periods_blob, blob_size, SQLITE_STATIC);

    rc = sqlite3_step(stmt);

    sqlite3_finalize(stmt);
    free(periods_blob);

    if (rc != SQLITE_DONE)
    {
        LOG_ERROR << "ERROR inserting/updating data: " << sqlite3_errmsg(globals::db);
        return false;
    }

    return true;
}

static schedule_dbo*
schedule_db_select_mapper(sqlite3_stmt *stmt)
{
    auto new_schedule = new schedule_dbo();
    for(int i = 0; i < sqlite3_column_count(stmt); i++)
    {
        const char *name = sqlite3_column_name(stmt, i);
        switch(name[0])
        {
            case 'i': // id
                new_schedule->id = sqlite3_column_int(stmt, i);
                break;
            case 'n': // name
                strncpy(new_schedule->name, (const char*)sqlite3_column_text(stmt, i), 127);
                new_schedule->name[127] = '\0';
                break;
            case 'p': // periods
                new_schedule->periods = new period_list((const uint16_t*)sqlite3_column_blob(stmt, i));
                break;
            case 'u': // uid
                uuid_copy(new_schedule->uid, (const unsigned char*)sqlite3_column_blob(stmt, i));
                break;
            default: // ignore columns not implemented
                break;
        }
    }
    return new_schedule;
}

static schedule_dbo**
schedule_db_select(sqlite3_stmt *stmt)
{
    auto **all_schedules = (schedule_dbo**)malloc(sizeof(schedule_dbo*));

    int row = 0;

    while(true)
    {
        int s;

        s = sqlite3_step(stmt);
        if (s == SQLITE_ROW)
        {
            schedule_dbo *new_schedule = schedule_db_select_mapper(stmt);
            row++;

            all_schedules = (schedule_dbo**)realloc(all_schedules, sizeof(schedule_dbo*) * (row + 1));
            all_schedules[row - 1] = new_schedule;
        }
        else
        {
            if(s == SQLITE_DONE)
            {
                break;
            }
            else
            {
                LOG_ERROR << "Error Selecting schedules from database: " << sqlite3_errstr(s);
                break;
            }
        }
    }

    sqlite3_finalize(stmt);

    all_schedules[row] = nullptr;

    return all_schedules;
}

bool
schedule_dbo::update()
{
    sqlite3_stmt *stmt;

    sqlite3_prepare_v2(globals::db, "UPDATE schedules SET uid = ?2, name = ?3, periods = ?4 WHERE id=?1;", -1, &stmt, nullptr);

    return schedule_db_update_insert(this, stmt);
}

bool
schedule_dbo::insert()
{
    sqlite3_stmt *stmt;

    sqlite3_prepare_v2(globals::db, "INSERT INTO schedules(uid, name, periods) values (?2, ?3, ?4);", -1, &stmt, nullptr);

    return schedule_db_update_insert(this, stmt);
}

bool
schedule_dbo::remove()
{
    sqlite3_stmt *stmt;
    int rc;

    sqlite3_prepare_v2(globals::db, "DELETE FROM schedules WHERE id=?1;", -1, &stmt, nullptr);
    sqlite3_bind_int(stmt, 1, this->id);
    rc = sqlite3_step(stmt);

    sqlite3_finalize(stmt);

    return rc == SQLITE_DONE;

}

schedule_dbo::~schedule_dbo()
{
    delete this->periods;
}

Json::Value
schedule_dbo::to_json()
{
    char id_str[37];
    schedule_dbo::unparse_uid(this->uid, id_str);
    Json::Value schedule_json;
    schedule_json["name"] = this->name;
    schedule_json["id"] = id_str;
    schedule_json["periods"] = this->periods->to_json();

    int *tags_ids = junction_tag_dbo::get_tags_for_schedule_id(this->id);
    if(tags_ids != nullptr)
    {
        Json::Value tags_json(Json::arrayValue);

        int tags_count;
        for(tags_count = 0; tags_ids[tags_count] != 0; ++tags_count);

        char **tags = (char**)malloc(sizeof(char*) * tags_count);

        for(int i = 0; i < tags_count; ++i)
        {
            tags[i] = tag_dbo::get_tag(tags_ids[i]);
            tags_json[i] = tags[i];
        }
        schedule_json["tags"] = tags_json;
    }

    return schedule_json;
}

schedule_dbo**
schedule_dbo::get_all()
{
    sqlite3_stmt *stmt;

    sqlite3_prepare_v2(globals::db, "SELECT * FROM schedules;", -1, &stmt, nullptr);

    return schedule_db_select(stmt);
}

schedule_dbo**
schedule_dbo::get_by_simple(const char *key, const void *value, intptr_t bind_func, int bind_func_param)
{
    helpers::sql_filter_builder *filters[1];
    helpers::sql_filter_builder filter
    {
        key,
        value,
        bind_func,
        bind_func_param,
        ";"
    };
    filters[0] = &filter;

    sqlite3_stmt *stmt = helpers::create_sql_filtered_query("SELECT * FROM schedules WHERE", filters);

    return schedule_db_select(stmt);
}

schedule_dbo*
schedule_dbo::get_by_id(int id)
{
    schedule_dbo **schedules = schedule_dbo::get_by_simple("id", &id, (intptr_t)&sqlite3_bind_int, 0);
    schedule_dbo *result = schedules[0];
    
    free(schedules);

    return result;
}

schedule_dbo*
schedule_dbo::get_by_id_or_off(int id)
{
    schedule_dbo **schedules = schedule_dbo::get_by_simple("id", &id, (intptr_t)&sqlite3_bind_int, 0);

    if(!schedules[0])
    {
        free(schedules);
        uuid_t off_uuid;
        memset(off_uuid, 0, sizeof(uuid_t));
        memcpy(off_uuid, "off", 3);
        schedules = schedule_dbo::get_by_simple("uid", off_uuid, (intptr_t)&sqlite3_bind_blob, sizeof(uuid_t));
        if(!schedules[0])
        {
            LOG_FATAL << "schedule with uid 'off' not found";
            exit(1);
        }
    }
    schedule_dbo *schedule = schedules[0];
    free(schedules);
    return schedule;
}

schedule_dbo**
schedule_dbo::get_by(helpers::sql_filter_builder **filters)
{
    sqlite3_stmt *stmt = helpers::create_sql_filtered_query("SELECT * FROM schedules WHERE", filters);

    return schedule_db_select(stmt);
}

void
schedule_dbo::free_list(schedule_dbo **schedules_list)
{
    for(int i = 0; schedules_list[i] != nullptr; i++)
    {
        delete schedules_list[i];
    }
    free(schedules_list);
}

int
schedule_dbo::parse_uid(const char *uid_str, uuid_t result)
{
    if(strcmp("off", uid_str) == 0)
    {
        memset(result, 0, sizeof(uuid_t));
        memcpy(result, "off", 3);
        return 0;
    }
    if(strcmp("on", uid_str) == 0)
    {
        memset(result, 0, sizeof(uuid_t));
        memcpy(result, "on", 2);
        return 0;
    }

    if(uuid_parse(uid_str, result))
    {
        return 1;
    }
    return 0;
}

void
schedule_dbo::unparse_uid(const uuid_t uid, char *result)
{
    uuid_t tmp_uuid;

    memset(tmp_uuid, 0, sizeof(uuid_t));
    memcpy(tmp_uuid, "off", 3);
    if(uuid_compare(uid, tmp_uuid) == 0)
    {
        strcpy(result, "off");
        return;
    }

    memset(tmp_uuid, 0, sizeof(uuid_t));
    memcpy(tmp_uuid, "on", 2);
    if(uuid_compare(uid, tmp_uuid) == 0)
    {
        strcpy(result, "on");
        return;
    }

    uuid_unparse(uid, result);
}