blist/src/main/models.c

#include "models.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "sql.h"

klist_user *klist_user_init() {
  klist_user *user = malloc(sizeof(klist_user));
  user->id = -1;
  user->name = NULL;
  user->local_id = -1;
  return user;
}

klist_user *klist_user_init_from_sql(sqlite3_stmt *stmt) {
  klist_user *user = klist_user_init();
  user->id = sqlite3_column_int(stmt, 0);
  if (sqlite3_column_bytes(stmt, 1) > 0)
    user->name = (unsigned char *)strdup((char *)sqlite3_column_text(stmt, 1));
  return user;
}

klist_user *klist_user_get_by_id(klist *ctx, u_int id) {
  sqlite3_stmt *stmt = ctx->stmts[GET_USER];
  klist_user *user = NULL;
  sqlite3_bind_int(stmt, 1, id);
  if (sqlite3_step(stmt) == SQLITE_ROW)
    return klist_user_init_from_sql(stmt);
  sqlite3_reset(stmt);
  return user;
}

klist_user *klist_user_get_by_local(klist *ctx, u_int local_id) {
  sqlite3_stmt *stmt = ctx->stmts[GET_USER_BY_LOCAL];
  klist_user *user = NULL;
  sqlite3_bind_int(stmt, 1, local_id);
  if (sqlite3_step(stmt) == SQLITE_ROW) {
    user = klist_user_init_from_sql(stmt);
  } else
    fprintf(stderr, "failed to get user by local id %u: %s\n", local_id,
            sqlite3_errmsg(ctx->db));
  sqlite3_reset(stmt);
  return user;
}

void klist_user_save(klist *ctx, klist_user *user) {
  sqlite3_stmt *stmt = ctx->stmts[ADD_USER];
  int result = 0;
  sqlite3_bind_text(stmt, 1, (char *)user->name, -1, SQLITE_STATIC);
  if ((result = sqlite3_step(stmt)) == SQLITE_ROW)
    user->id = sqlite3_column_int(stmt, 0);
  else
    fprintf(stderr, "failed to save user: %s - %d\n", sqlite3_errmsg(ctx->db),
            result);
  sqlite3_reset(stmt);

  if (user->local_id != -1) {
    sqlite3_stmt *stmt = ctx->stmts[ADD_LOGIN];
    int result = 0;
    sqlite3_bind_int(stmt, 1, user->id);
    sqlite3_bind_int(stmt, 2, user->local_id);
    if ((result = sqlite3_step(stmt)) != SQLITE_ROW)
      fprintf(stderr, "failed to save logins for user: %s - %d\n",
              sqlite3_errmsg(ctx->db), result);
    sqlite3_reset(stmt);
  } else
    fprintf(stderr, "no local uid saved for user %s", user->name);
}

void klist_user_delete(klist *ctx, klist_user *user) {
  sqlite3_stmt *stmt = ctx->stmts[DEL_USER];
  sqlite3_bind_int(stmt, 1, (int)user->id);
  if (sqlite3_step(stmt) == SQLITE_ROW)
    sqlite3_reset(stmt);
}

void klist_user_deinit(klist_user *user) {
  if (user->name)
    free(user->name);
  free(user);
}

klist_stage *klist_stage_init() {
  klist_stage *stage = malloc(sizeof(klist_stage));
  stage->id = -1;
  stage->name = NULL;
  stage->desc = NULL;
  stage->list_id = -1;
  return stage;
}

klist_stage *klist_stage_init_from_sql(sqlite3_stmt *stmt) {
  klist_stage *stage = klist_stage_init();
  stage->id = sqlite3_column_int(stmt, 0);
  if (sqlite3_column_bytes(stmt, 1) > 0)
    stage->name = (unsigned char *)strdup((char *)sqlite3_column_text(stmt, 1));
  if (sqlite3_column_bytes(stmt, 2) > 0)
    stage->desc = (unsigned char *)strdup((char *)sqlite3_column_text(stmt, 2));
  return stage;
}

klist_stage *klist_stage_get_by_id(klist *ctx, u_int id) {
  sqlite3_stmt *stmt = ctx->stmts[GET_STAGE];
  sqlite3_bind_int(stmt, 1, id);
  if (sqlite3_step(stmt) == SQLITE_ROW) {
    sqlite3_reset(stmt);
    return klist_stage_init_from_sql(stmt);
  }
  return NULL;
}

klist_stage **klist_stage_get_all_for_list(klist *ctx, u_int id,
                                           size_t *count) {
  sqlite3_stmt *stmt = ctx->stmts[GET_STAGES_FOR_LIST];
  sqlite3_bind_int(stmt, 1, id);
  klist_stage **stages = NULL;
  size_t stages_len = 0;
  while (sqlite3_step(stmt) == SQLITE_ROW) {
    stages_len++;
    klist_stage **_stages = realloc(stages, stages_len * sizeof(klist_stage *));
    if (_stages) {
      stages = _stages;
      stages[stages_len - 1] = klist_stage_init_from_sql(stmt);
    }
  }
  if (count != NULL)
    *count = stages_len;
  return stages;
}

void klist_stage_save(klist *ctx, klist_stage *stage) {
  sqlite3_stmt *stmt = ctx->stmts[ADD_STAGE];
  int result = 0;
  sqlite3_bind_text(stmt, 1, (char *)stage->name, -1, SQLITE_STATIC);
  sqlite3_bind_text(stmt, 2, (char *)stage->name, -1, SQLITE_STATIC);
  sqlite3_bind_int(stmt, 3, stage->list_id);
  if ((result = sqlite3_step(stmt)) == SQLITE_ROW || result == SQLITE_DONE) {
    stage->id = sqlite3_column_int(stmt, 0);
    sqlite3_reset(stmt);
  } else
    fprintf(stderr, "failed to save stage: %s - %d\n", sqlite3_errmsg(ctx->db),
            result);
}

void klist_stage_deinit(klist_stage *stage) {
  if (stage->name)
    free(stage->name);
  if (stage->desc)
    free(stage->desc);
  free(stage);
}

klist_list *klist_list_init() {
  klist_list *list = malloc(sizeof(klist_list));
  list->id = -1;
  list->name = NULL;
  list->desc = NULL;
  list->is_preset = false;
  return list;
}

klist_list *klist_list_init_from_sql(sqlite3_stmt *stmt) {
  klist_list *list = klist_list_init();
  list->id = sqlite3_column_int(stmt, 0);
  if (sqlite3_column_bytes(stmt, 1) > 0)
    list->name = (unsigned char *)strdup((char *)sqlite3_column_text(stmt, 1));
  if (sqlite3_column_bytes(stmt, 2) > 0)
    list->desc = (unsigned char *)strdup((char *)sqlite3_column_text(stmt, 2));

  list->is_preset = sqlite3_column_int(stmt, 3) ? true : false;
  return list;
}

klist_list *klist_list_get_by_id(klist *ctx, u_int id) {
  sqlite3_stmt *stmt = ctx->stmts[GET_LIST];
  sqlite3_bind_int(stmt, 1, id);
  if (sqlite3_step(stmt) == SQLITE_ROW) {
    sqlite3_reset(stmt);
    return klist_list_init_from_sql(stmt);
  }
  return NULL;
}

klist_list **klist_list_get_all_by_user(klist *ctx, u_int user_id,
                                        size_t *count) {
  sqlite3_stmt *stmt = ctx->stmts[GET_LISTS_BY_USER];
  sqlite3_bind_int(stmt, 1, user_id);
  klist_list **lists = NULL;
  size_t lists_len = 0;
  while (sqlite3_step(stmt) == SQLITE_ROW) {
    lists_len++;
    klist_list **_lists = realloc(lists, lists_len * sizeof(klist_list *));
    if (_lists) {
      lists = _lists;
      lists[lists_len - 1] = klist_list_init_from_sql(stmt);
    }
  }
  if (count != NULL)
    *count = lists_len;
  return lists;
}

klist_list *klist_list_get_by_user_and_name(klist *ctx, u_int user_id,
                                            const char *name) {
  sqlite3_stmt *stmt = ctx->stmts[GET_LISTS_BY_USER_NAME];
  klist_list *list = NULL;
  sqlite3_bind_int(stmt, 1, user_id);
  sqlite3_bind_text(stmt, 2, name, -1, SQLITE_STATIC);

  if (sqlite3_step(stmt) == SQLITE_ROW)
    list = klist_list_init_from_sql(stmt);
  else
    fprintf(stderr, "failed to get lists for user\n");
  sqlite3_reset(stmt);
  return list;
}

void klist_list_save(klist *ctx, klist_list *list, klist_user *user) {
  sqlite3_stmt *stmt = ctx->stmts[ADD_LIST];
  int result = 0;
  sqlite3_bind_text(stmt, 1, (char *)list->name, -1, SQLITE_STATIC);
  sqlite3_bind_text(stmt, 2, (char *)list->desc, -1, SQLITE_STATIC);
  sqlite3_bind_int(stmt, 3, list->is_preset);
  if ((result = sqlite3_step(stmt)) == SQLITE_ROW) {
    list->id = sqlite3_column_int(stmt, 0);
    sqlite3_reset(stmt);
  } else
    fprintf(stderr, "failed to save list: %s - %d\n", sqlite3_errmsg(ctx->db),
            result);
  if (list->id) {
    sqlite3_stmt *stmt = ctx->stmts[ADD_USER_LIST];
    sqlite3_bind_int(stmt, 1, list->id);
    sqlite3_bind_int(stmt, 2, user->id);
    if (sqlite3_step(stmt) == SQLITE_DONE)
      sqlite3_reset(stmt);
    else
      fprintf(stderr, "failed to save user - list relation in join table: %s\n",
              sqlite3_errmsg(ctx->db));
  }
}

void klist_list_deinit(klist_list *list) {
  if (list->name)
    free(list->name);
  if (list->desc)
    free(list->desc);
  free(list);
}

klist_task *klist_task_init() {
  klist_task *task = malloc(sizeof(klist_task));
  task->id = -1;
  task->name = NULL;
  task->desc = NULL;
  task->due = -1;
  task->target_stage = -1;
  return task;
}

klist_task *klist_task_init_from_sql(sqlite3_stmt *stmt) {
  klist_task *task = klist_task_init();
  task->id = sqlite3_column_int(stmt, 0);
  if (sqlite3_column_bytes(stmt, 1) > 0)
    task->name = (unsigned char *)strdup((char *)sqlite3_column_text(stmt, 1));
  if (sqlite3_column_bytes(stmt, 2) > 0)
    task->desc = (unsigned char *)strdup((char *)sqlite3_column_text(stmt, 2));
  return task;
}

klist_task *klist_task_get_by_id(klist *ctx, u_int id) {
  sqlite3_stmt *stmt = ctx->stmts[GET_TASK];
  sqlite3_bind_int(stmt, 1, id);
  if (sqlite3_step(stmt) == SQLITE_ROW) {
    sqlite3_reset(stmt);
    return klist_task_init_from_sql(stmt);
  }
  return NULL;
}

klist_task **klist_task_get_for_list(klist *ctx, u_int list_id, size_t *count) {
  sqlite3_stmt *stmt = ctx->stmts[GET_TASKS_FOR_LIST];
  sqlite3_bind_int(stmt, 1, list_id);
  klist_task **tasks = NULL;
  size_t tasks_len = 0;
  while (sqlite3_step(stmt) == SQLITE_ROW) {
    tasks_len++;
    klist_task **_tasks = realloc(tasks, tasks_len * sizeof(klist_task *));
    if (_tasks) {
      tasks = _tasks;
      tasks[tasks_len - 1] = klist_task_init_from_sql(stmt);
    }
  }
  sqlite3_reset(stmt);
  *count = tasks_len;
  return tasks;
}

klist_task *klist_task_get_for_list_by_name(klist *ctx, u_int list_id,
                                            const char *name) {
  sqlite3_stmt *stmt = ctx->stmts[GET_TASKS_FOR_LIST_BY_NAME];
  klist_task *task = NULL;
  sqlite3_bind_int(stmt, 1, list_id);
  sqlite3_bind_text(stmt, 2, name, -1, SQLITE_STATIC);
  if (sqlite3_step(stmt) == SQLITE_ROW)
    task = klist_task_init_from_sql(stmt);
  sqlite3_reset(stmt);
  return task;
}

void klist_task_save(klist *ctx, klist_task *task) {
  sqlite3_stmt *stmt = ctx->stmts[ADD_TASK];
  int result = 0;
  sqlite3_bind_text(stmt, 1, (char *)task->name, -1, SQLITE_STATIC);
  sqlite3_bind_text(stmt, 2, (char *)task->desc, -1, SQLITE_STATIC);
  sqlite3_bind_int(stmt, 3, task->stage_id);
  if (task->due)
    sqlite3_bind_int(stmt, 4, task->due);
  if (task->target_stage)
    sqlite3_bind_int(stmt, 5, task->target_stage);
  if ((result = sqlite3_step(stmt)) == SQLITE_ROW) {
    task->id = sqlite3_column_int(stmt, 0);
  } else
    fprintf(stderr, "failed to save list: %s - %d\n", sqlite3_errmsg(ctx->db),
            result);
  sqlite3_reset(stmt);
}
void klist_task_delete(klist *ctx, klist_task *task) {
  sqlite3_stmt *stmt = ctx->stmts[DEL_TASK];
  sqlite3_bind_int(stmt, 1, task->id);
  if (sqlite3_step(stmt) == SQLITE_DONE)
    sqlite3_reset(stmt);
  else
    fprintf(stderr, "failed to delete task: %s\n", sqlite3_errmsg(ctx->db));
}

void klist_task_deinit(klist_task *task) {
  if (task->name)
    free(task->name);
  if (task->desc)
    free(task->desc);
  free(task);
}