more sql and convenience initializer/getter and cleaner code

src/main/CMakeLists.txt

@@ -1,3 +1,4 @@
-add_executable(klist main.c sql.c util.c)
+add_executable(klist main.c sql.c util.c models.c)
 target_include_directories(klist PRIVATE include)
 target_link_libraries(klist sqlite3)
+target_compile_options(klist PRIVATE -Werror -Wall) #-Wextra)

src/main/include/models.h

@@ -6,7 +6,7 @@
 
 struct klist_user {
     ssize_t id;
-    char *name;
+    unsigned char *name;
     ssize_t local_id;
     ssize_t discord_id;
     ssize_t google_id;
@@ -14,43 +14,50 @@ struct klist_user {
 typedef struct klist_user klist_user;
 
 klist_user *klist_user_init();
+klist_user *klist_user_init_from_sql(sqlite3_stmt *);
 klist_user *klist_user_get_by_id(klist *, u_int);
-klist_user *klist_user_get_by_local(klist *, char *);
-klist_user *klist_user_get_by_discord(klist *, char *);
-klist_user *klist_user_get_by_google(klist *, char *);
+klist_user *klist_user_get_by_local(klist *, u_int);
+klist_user *klist_user_get_by_discord(klist *, u_int);
+klist_user *klist_user_get_by_google(klist *, u_int);
 void klist_user_deinit(klist_user *);
 
 
 struct klist_stage {
     ssize_t id;
-    char *name;
-    char *desc;
+    unsigned char *name;
+    unsigned char *desc;
+    ssize_t list_id;
 };
 typedef struct klist_stage klist_stage;
 
 klist_stage *klist_stage_init();
+klist_stage *klist_stage_init_from_sql(sqlite3_stmt *);
+klist_stage *klist_stage_get_by_id(klist *, u_int);
 void klist_stage_deinit(klist_stage *);
 
 
 struct klist_list {
     ssize_t id;
-    char *name;
-    char *desc;
-
+    unsigned char *name;
+    unsigned char *desc;
 };
 typedef struct klist_list klist_list;
 
 klist_list *klist_list_init();
+klist_list *klist_list_init_from_sql(sqlite3_stmt *);
+klist_list *klist_list_get_by_id(klist *, u_int);
+klist_list **klist_list_get_all_by_user(klist *, u_int, size_t *);
 void klist_list_deinit(klist_list *);
 
 
 struct klist_task {
     ssize_t id;
-    char *name;
-    char *desc;
-
+    unsigned char *name;
+    unsigned char *desc;
 };
 typedef struct klist_task klist_task;
 
 klist_task *klist_task_init();
+klist_task *klist_task_init_from_sql(sqlite3_stmt *);
+klist_task *klist_task_get_by_id(klist *, u_int);
 void klist_task_deinit(klist_task *);

src/main/include/sql.h

@@ -5,6 +5,9 @@ enum KLIST_SQL {
     INIT,
     ADD_USER,
     GET_USER,
+    GET_USER_BY_LOCAL,
+    GET_USER_BY_DISCORD,
+    GET_USER_BY_GOOGLE,
     GET_USERS,
     MOD_USER_NAME,
     MOD_USER_LOCAL,
@@ -13,6 +16,7 @@ enum KLIST_SQL {
     ADD_LIST,
     GET_LIST,
     GET_LISTS,
+    GET_LISTS_BY_USER,
     MOD_LIST_NAME,
     DEL_LIST,
     ADD_STAGE,

src/main/include/util.h

@@ -46,7 +46,7 @@ enum klist_list_command {
     LIST_DELETE,
 };
 struct klist_list_context {
-    enum klist_user_command cmd;
+    enum klist_list_command cmd;
     char *name;
     char **stages;
     size_t stages_len;

src/main/main.c

@@ -20,19 +20,17 @@ int main(int argc, char **argv) {
         setup(ctx, argc, argv);
         switch (ctx->cmd) {
             case USER:
-                switch (((klist_list_context *)ctx->cmd_ctx)->cmd) {
+                switch (((klist_user_context *)ctx->cmd_ctx)->cmd) {
                 case USER_GET:
-
                 case USER_DELETE:
                 default: ;
                 }
             case LIST:
-                switch (((klist_user_context *)ctx->cmd_ctx)->cmd) {
+                switch (((klist_list_context *)ctx->cmd_ctx)->cmd) {
                 case LIST_ADD:
                 case LIST_EDIT:
                 case LIST_GET:
-                case LIST_DELETE:
-                default: ;
+                case LIST_DELETE: ;
                 }
             case TASK:
                 switch (((klist_task_context *)ctx->cmd_ctx)->cmd) {

src/main/models.c

@@ -1,6 +1,9 @@
 #include "models.h"
 
 #include <stdlib.h>
+#include <string.h>
+
+#include "sql.h"
 
 klist_user *klist_user_init() {
     klist_user *user = malloc(sizeof(klist_user));
@@ -11,8 +14,177 @@ klist_user *klist_user_init() {
     user->google_id = -1;
     return user;
 }
-klist_user *klist_user_get_by_id(klist *ctx, u_int id);
+
+klist_user *klist_user_init_from_sql(sqlite3_stmt *stmt) {
+    klist_user *user = klist_user_init();
+    size_t bytes;
+    user->id = sqlite3_column_int(stmt, 0);
+    if ((bytes = sqlite3_column_bytes(stmt, 1)) > 0) {
+        user->name = malloc(bytes);
+        memcpy(user->name, sqlite3_column_text(stmt, 1), bytes);
+    }
+    if (sqlite3_column_type(stmt, 2) != SQLITE_NULL) user->local_id = sqlite3_column_int(stmt, 2);
+    if (sqlite3_column_type(stmt, 3) != SQLITE_NULL) user->discord_id = sqlite3_column_int(stmt, 3);
+    if (sqlite3_column_type(stmt, 4) != SQLITE_NULL) user->google_id = sqlite3_column_int(stmt, 4);
+    return user;
+}
+
+klist_user *klist_user_get_by_id(klist *ctx, u_int id) {
+    sqlite3_stmt *stmt = ctx->stmts[GET_USER];
+    sqlite3_bind_int(stmt, 1, id);
+    if (sqlite3_step(stmt) == SQLITE_ROW) {
+        sqlite3_reset(stmt);
+        return klist_user_init_from_sql(stmt);
+    }
+    return NULL;
+}
+
+klist_user *klist_user_get_by_local(klist *ctx, u_int local_id) {
+    sqlite3_stmt *stmt = ctx->stmts[GET_USER_BY_LOCAL];
+    sqlite3_bind_int(stmt, 1, local_id);
+    if (sqlite3_step(stmt) == SQLITE_ROW) {
+        sqlite3_reset(stmt);
+        return klist_user_init_from_sql(stmt);
+    }
+    return NULL;
+}
+
 void klist_user_deinit(klist_user *user) {
     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();
+    size_t bytes;
+    stage->id = sqlite3_column_int(stmt, 0);
+    if ((bytes = sqlite3_column_bytes(stmt, 1)) > 0) {
+        stage->name = malloc(bytes);
+        memcpy(stage->name, sqlite3_column_text(stmt, 1), bytes);
+    }
+    if ((bytes = sqlite3_column_bytes(stmt, 2)) > 0) {
+        stage->desc = malloc(bytes);
+        memcpy(stage->desc, sqlite3_column_text(stmt, 2), bytes);
+    }
+    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;
+}
+
+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;
+    return list;
+}
+
+klist_list *klist_list_init_from_sql(sqlite3_stmt *stmt) {
+    klist_list *list = klist_list_init();
+    size_t bytes;
+    list->id = sqlite3_column_int(stmt, 0);
+    if ((bytes = sqlite3_column_bytes(stmt, 1)) > 0) {
+        list->name = malloc(bytes);
+        memcpy(list->name, sqlite3_column_text(stmt, 1), bytes);
+    }
+    if ((bytes = sqlite3_column_bytes(stmt, 2)) > 0) {
+        list->desc = malloc(bytes);
+        memcpy(list->desc, sqlite3_column_text(stmt, 2), bytes);
+    }
+    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++;
+        lists = realloc(lists, lists_len * sizeof(klist_list *));
+        lists[lists_len - 1] = klist_list_init(stmt);
+    }
+    if (count != NULL) *count = lists_len;
+    return lists;
+}
+
+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;
+    return task;
+}
+
+klist_task *klist_task_init_from_sql(sqlite3_stmt *stmt) {
+    klist_task *task = klist_task_init();
+    size_t bytes;
+    task->id = sqlite3_column_int(stmt, 0);
+    if ((bytes = sqlite3_column_bytes(stmt, 1)) > 0) {
+        task->name = malloc(bytes);
+        memcpy(task->name, sqlite3_column_text(stmt, 1), bytes);
+    }
+    if ((bytes = sqlite3_column_bytes(stmt, 2)) > 0) {
+        task->desc = malloc(bytes);
+        memcpy(task->desc, sqlite3_column_text(stmt, 2), bytes);
+    }
+    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;
+}
+
+void klist_task_deinit(klist_task *task) {
+    if (task->name) free(task->name);
+    if (task->desc) free(task->desc);
+    free(task);
+}

src/main/sql.c

@@ -41,6 +41,9 @@ char *klist_sql_get(const enum KLIST_SQL sql) {
                     ")";
         case ADD_USER: return "insert into users values (?1, ?2, ?3, ?4)";
         case GET_USER: return "select * from users where id = ?1";
+        case GET_USER_BY_LOCAL: return "select * from users where local_id = ?1";
+        case GET_USER_BY_DISCORD: return "select * from users where discord_id = ?1";
+        case GET_USER_BY_GOOGLE: return "select * from users where google_id = ?1";
         case GET_USERS: return "select * from users";
         case MOD_USER_NAME: return "update users set name = ?1 where id = ?2";
         case MOD_USER_LOCAL: return "update users set local_id = ?1 where id = ?2";;
@@ -49,6 +52,7 @@ char *klist_sql_get(const enum KLIST_SQL sql) {
         case ADD_LIST: return "insert into lists values (?1, ?2)";
         case GET_LIST: return "select * from lists where id = ?1";
         case GET_LISTS: return "select * from lists";
+        case GET_LISTS_BY_USER: return "select * from lists where id = (select list_id from user_lists where user_id = ?1)";
         case MOD_LIST_NAME: return "update lists set name = ?1 where id = ?2";
         case DEL_LIST: return "delete from lists where id = ?1";
         case ADD_STAGE: return "insert into task_stages values (?1, ?2, ?3)";