theBreadCompany/blist
1
0
Fork 0
Code Issues 5 Pull requests Projects Releases Packages Wiki Activity Actions

clang-format

Browse source
This commit is contained in:
theBreadCompany 2025-06-08 12:38:33 +02:00
parent 4ed84f160d
commit ed063a7483
7 changed files with 844 additions and 763 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
src/main/include/models.h
View file

@ -5,9 +5,9 @@
#include "util.h" #include "util.h"
struct klist_user { struct klist_user {
ssize_t id; ssize_t id;
unsigned char *name; unsigned char *name;
ssize_t local_id; ssize_t local_id;
}; };
typedef struct klist_user klist_user; typedef struct klist_user klist_user;
@ -21,12 +21,11 @@ void klist_user_save(klist *, klist_user *);
void klist_user_delete(klist *, klist_user *); void klist_user_delete(klist *, klist_user *);
void klist_user_deinit(klist_user *); void klist_user_deinit(klist_user *);
struct klist_list { struct klist_list {
ssize_t id; ssize_t id;
unsigned char *name; unsigned char *name;
unsigned char *desc; unsigned char *desc;
bool is_preset; bool is_preset;
}; };
typedef struct klist_list klist_list; typedef struct klist_list klist_list;
@ -39,12 +38,11 @@ void klist_list_save(klist *, klist_list *);
void klist_list_delete(klist *, klist_list *); void klist_list_delete(klist *, klist_list *);
void klist_list_deinit(klist_list *); void klist_list_deinit(klist_list *);
struct klist_stage { struct klist_stage {
ssize_t id; ssize_t id;
unsigned char *name; unsigned char *name;
unsigned char *desc; unsigned char *desc;
ssize_t list_id; ssize_t list_id;
}; };
typedef struct klist_stage klist_stage; typedef struct klist_stage klist_stage;
@ -56,15 +54,13 @@ void klist_stage_save(klist *, klist_stage *);
void klist_stage_delete(klist *, klist_stage *); void klist_stage_delete(klist *, klist_stage *);
void klist_stage_deinit(klist_stage *); void klist_stage_deinit(klist_stage *);
struct klist_task { struct klist_task {
ssize_t id; ssize_t id;
unsigned char *name; unsigned char *name;
unsigned char *desc; unsigned char *desc;
int stage_id; int stage_id;
time_t due; time_t due;
int target_stage; int target_stage;
}; };
typedef struct klist_task klist_task; typedef struct klist_task klist_task;

56
src/main/include/sql.h
View file

@ -2,34 +2,34 @@
#include <sys/types.h> #include <sys/types.h>
enum KLIST_SQL { enum KLIST_SQL {
INIT, INIT,
ADD_LOGIN, ADD_LOGIN,
ADD_USER, ADD_USER,
GET_USER, GET_USER,
GET_USER_BY_LOCAL, GET_USER_BY_LOCAL,
GET_USERS, GET_USERS,
MOD_USER_NAME, MOD_USER_NAME,
DEL_USER, DEL_USER,
ADD_LIST, ADD_LIST,
GET_LIST, GET_LIST,
GET_LISTS, GET_LISTS,
GET_LISTS_BY_USER, GET_LISTS_BY_USER,
GET_LISTS_BY_USER_NAME, GET_LISTS_BY_USER_NAME,
MOD_LIST_NAME, MOD_LIST_NAME,
DEL_LIST, DEL_LIST,
ADD_STAGE, ADD_STAGE,
GET_STAGE, GET_STAGE,
GET_STAGES_FOR_LIST, GET_STAGES_FOR_LIST,
DEL_STAGE, DEL_STAGE,
ADD_TASK, ADD_TASK,
GET_TASK, GET_TASK,
GET_TASKS, GET_TASKS,
GET_TASKS_FOR_LIST, GET_TASKS_FOR_LIST,
GET_TASKS_FOR_LIST_BY_NAME, GET_TASKS_FOR_LIST_BY_NAME,
MOD_TASK_NAME, MOD_TASK_NAME,
MOD_TASK_DESCRIPTION, MOD_TASK_DESCRIPTION,
DEL_TASK, DEL_TASK,
_KLIST_SQL_COUNT _KLIST_SQL_COUNT
}; };
const char *klist_sql_get(const enum KLIST_SQL); const char *klist_sql_get(const enum KLIST_SQL);

73
src/main/include/util.h
View file

@ -8,87 +8,76 @@
*/ */
enum klist_command { enum klist_command {
USER, USER,
LIST, LIST,
TASK, TASK,
}; };
struct klist { struct klist {
sqlite3 *db; sqlite3 *db;
sqlite3_stmt **stmts; sqlite3_stmt **stmts;
u_int cmd; u_int cmd;
void *cmd_ctx; void *cmd_ctx;
int error; int error;
}; };
typedef struct klist klist; typedef struct klist klist;
klist *klist_init(char *db); klist *klist_init(char *db);
void klist_deinit(klist *list); void klist_deinit(klist *list);
enum klist_user_command { USER_GET, USER_CREATE, USER_DELETE };
enum klist_user_command {
USER_GET,
USER_CREATE,
USER_DELETE
};
struct klist_user_context { struct klist_user_context {
enum klist_user_command cmd; enum klist_user_command cmd;
}; };
typedef struct klist_user_context klist_user_context; typedef struct klist_user_context klist_user_context;
klist_user_context *klist_user_context_init(klist *list); klist_user_context *klist_user_context_init(klist *list);
void klist_user_context_deinit(klist_user_context *ctx); void klist_user_context_deinit(klist_user_context *ctx);
enum klist_list_command { enum klist_list_command {
LIST_ADD, LIST_ADD,
LIST_EDIT, LIST_EDIT,
LIST_GET, LIST_GET,
LIST_DELETE, LIST_DELETE,
}; };
struct klist_list_context { struct klist_list_context {
enum klist_list_command cmd; enum klist_list_command cmd;
char *name; char *name;
char *desc; char *desc;
char **stages; char **stages;
size_t stages_len; size_t stages_len;
char *preset; char *preset;
}; };
typedef struct klist_list_context klist_list_context; typedef struct klist_list_context klist_list_context;
klist_list_context *klist_list_context_init(klist *list); klist_list_context *klist_list_context_init(klist *list);
klist_list_context *klist_list_context_get_by_id(klist_list_context *ctx, u_int id); klist_list_context *klist_list_context_get_by_id(klist_list_context *ctx,
u_int id);
void klist_list_context_deinit(klist_list_context *ctx); void klist_list_context_deinit(klist_list_context *ctx);
enum klist_task_command { enum klist_task_command {
TASK_ADD, TASK_ADD,
TASK_EDIT, TASK_EDIT,
TASK_GET, TASK_GET,
TASK_DELETE, TASK_DELETE,
}; };
struct klist_task_context { struct klist_task_context {
enum klist_task_command cmd; enum klist_task_command cmd;
char *list; char *list;
char *name; char *name;
char *desc; char *desc;
char *stage; char *stage;
}; };
typedef struct klist_task_context klist_task_context; typedef struct klist_task_context klist_task_context;
klist_task_context *klist_task_context_init(klist *list); klist_task_context *klist_task_context_init(klist *list);
void klist_task_context_deinit(klist_task_context *ctx); void klist_task_context_deinit(klist_task_context *ctx);
/* /*
* sql preparations * sql preparations
*/ */
void klist_sql_prepare(klist *, char *); void klist_sql_prepare(klist *, char *);
/* /*
* assuring things * assuring things
*/ */

628
src/main/main.c
View file

@ -1,7 +1,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <string.h> #include <string.h>
#include <unistd.h>
#include "models.h" #include "models.h"
#include "util.h" #include "util.h"
@ -10,312 +10,346 @@ void print_help(char **argv);
void setup(klist *ctx, int argc, char **argv); void setup(klist *ctx, int argc, char **argv);
int main(int argc, char **argv) { int main(int argc, char **argv) {
klist *ctx = klist_init("test.db"); klist *ctx = klist_init("test.db");
if (argc == 1) { if (argc == 1) {
print_help(argv); print_help(argv);
ctx->error = 1; ctx->error = 1;
} }
if (!ctx->error) { if (!ctx->error) {
setup(ctx, argc, argv); setup(ctx, argc, argv);
klist_user *user = klist_user_get_by_local(ctx, getuid()); klist_user *user = klist_user_get_by_local(ctx, getuid());
klist_list *list = NULL; klist_list *list = NULL;
int i = 0; int i = 0;
switch (ctx->cmd) { switch (ctx->cmd) {
case USER: case USER:
klist_user_context *user_ctx = ctx->cmd_ctx; klist_user_context *user_ctx = ctx->cmd_ctx;
switch (user_ctx->cmd) { switch (user_ctx->cmd) {
case USER_GET: case USER_GET:
if (user) { if (user) {
fprintf( fprintf(stderr, "User: %p\nID: %lu\n", user->name, user->id);
stderr, size_t lists_len, i = 0;
"User: %p\nID: %lu\n", user->name, user->id klist_list **lists =
); klist_list_get_all_by_user(ctx, user->id, &lists_len);
size_t lists_len, i = 0; fprintf(stderr, "Lists: %lu\n", lists_len);
klist_list **lists = klist_list_get_all_by_user(ctx, user->id, &lists_len); for (; i < lists_len; i++)
fprintf(stderr, "Lists: %lu\n", lists_len); klist_list_deinit(lists[i]);
for (; i < lists_len; i++) klist_list_deinit(lists[i]); } else
} else fprintf(stderr, "No user for '%s' found.\n", getlogin()); fprintf(stderr, "No user for '%s' found.\n", getlogin());
break; break;
case USER_CREATE: case USER_CREATE:
fprintf( fprintf(stderr, (klist_assure_user(ctx, getuid(), getlogin()))
stderr, ? "User created.\n"
(klist_assure_user(ctx, getuid(), getlogin())) : "User already exists.\n");
? "User created.\n" break;
: "User already exists.\n" case USER_DELETE:
); if (user) {
break; klist_user_delete(ctx, user);
case USER_DELETE: fprintf(stderr, "User deleted.\n");
if (user) { } else
klist_user_delete(ctx, user); fprintf(stderr, "User not found, no changes done.\n");
fprintf(stderr, "User deleted.\n"); break;
} else fprintf(stderr, "User not found, no changes done.\n"); }
break; klist_user_context_deinit(user_ctx);
} break;
klist_user_context_deinit(user_ctx); case LIST:
break; klist_list_context *list_ctx = ctx->cmd_ctx;
case LIST: if (!list_ctx->name) {
klist_list_context *list_ctx = ctx->cmd_ctx; fprintf(stderr, "Missing name.\n");
if (!list_ctx->name) { fprintf(stderr, "Missing name.\n"); break; } break;
switch (list_ctx->cmd) { }
case LIST_ADD: switch (list_ctx->cmd) {
if (!list_ctx->stages_len) { fprintf(stderr, "Missing stages.\n"); break; } case LIST_ADD:
list = klist_list_init(); if (!list_ctx->stages_len) {
list->name = (unsigned char*)list_ctx->name; fprintf(stderr, "Missing stages.\n");
list->desc = (unsigned char*)list_ctx->desc; break;
list->is_preset = false;
klist_list_save(ctx, list);
i = 0;
for (; i < list_ctx->stages_len; i++) {
klist_stage *stage = klist_stage_init();
stage->name = (unsigned char*)list_ctx->stages[i];
stage->list_id = list->id;
klist_stage_save(ctx, stage);
klist_stage_deinit(stage);
}
break;
case LIST_EDIT:
fprintf(stderr, "Not implemented\n");
break;
case LIST_GET:
klist_assure_user(ctx, getuid(), getlogin());
user = klist_user_get_by_local(ctx, getuid());
list = klist_list_get_by_user_and_name(ctx, user->id, list_ctx->name);
if (list) {
size_t tasks_len = 0;
klist_task **tasks = klist_task_get_for_list(ctx, list->id, &tasks_len);
fprintf(stderr, "Name: %s\nDescription: %s\nTasks: %ld\n", (char *)list->name, (char *)list->desc, tasks_len);
int i = 0;
for(; i < tasks_len; i++) klist_task_deinit(tasks[i]);
free(tasks);
} else
fprintf(stderr, "List '%s' not found.\n", list_ctx->name);
break;
case LIST_DELETE:
list = klist_list_get_by_user_and_name(ctx, user->id, list_ctx->name);
if (list) {
size_t tasks_len = 0;
klist_task **tasks = klist_task_get_for_list(ctx, list->id, &tasks_len);
int i = 0;
for (; i < tasks_len; i++) {
klist_task_delete(ctx, tasks[i]);
klist_task_deinit(tasks[i]);
}
free(tasks);
}
}
if (list_ctx) klist_list_context_deinit(list_ctx);
break;
case TASK:
klist_task_context *task_ctx = ctx->cmd_ctx;
switch (((klist_task_context *)ctx->cmd_ctx)->cmd) {
case TASK_ADD: // basically the same things happen and edit can create if nescessary
case TASK_EDIT:
klist_assure_user(ctx, getuid(), getlogin());
user = klist_user_get_by_local(ctx, getuid());
list = klist_list_get_by_user_and_name(ctx, user->id, task_ctx->list);
if (list) {
size_t stages_len = 0;
klist_stage **stages = klist_stage_get_all_for_list(ctx, list->id, &stages_len);
if (!task_ctx->stage) {
fprintf(stderr, "Stage missing/wrong, please pass one of: ");
i = 0;
for (; i < stages_len; i++)
fprintf(stderr, "%s ", (char *)stages[i]->name);
fprintf(stderr, "\n");
break;
}
i = 0;
ssize_t stage_id = -1;
for (; i < stages_len; i++)
if (strcmp((char *)stages[i]->name, (char *)task_ctx->stage) == 0)
stage_id = stages[i]->id;
if (stage_id == -1) {
fprintf(stderr, "Stage %s not found. Use one of: ", (char *)task_ctx->stage);
i = 0;
for (; i < stages_len; i++)
fprintf(stderr, "%s ", (char *)stages[i]->name);
fprintf(stderr, "\n");
}
i = 0;
for (; i < stages_len; i++)
klist_stage_deinit(stages[i]);
free(stages);
if (ctx->error) break;
klist_task *task = klist_task_get_for_list_by_name(ctx, list->id, task_ctx->name);
if (!task) task = klist_task_init();
task->name = (unsigned char*)task_ctx->name;
if (task_ctx->desc) task->desc = (unsigned char*)task_ctx->desc;
task->stage_id = stage_id;
klist_task_save(ctx, task);
klist_task_deinit(task);
} else fprintf(stderr, "List not found.\n");
break;
case TASK_GET:
klist_assure_user(ctx, getuid(), getlogin());
user = klist_user_get_by_local(ctx, getuid());
list = klist_list_get_by_user_and_name(ctx, user->id, task_ctx->list);
if (list) {
if (task_ctx->name) {
klist_task *task = klist_task_get_for_list_by_name(ctx, list->id, task_ctx->name);
if (task) {
fprintf(stderr, "Name: %s\n", (char *)task->name);
fprintf(stderr, "Description: %s\n", (char *)task->desc);
klist_stage *stage = klist_stage_get_by_id(ctx, task->stage_id);
fprintf(stderr, "Stage: %s\n", (char*)stage->name);
klist_stage_deinit(stage);
klist_task_deinit(task);
} else fprintf(stderr, "Task not found.\n");
} else {
size_t tasks_len = 0;
klist_task **tasks = klist_task_get_for_list(ctx, list->id, &tasks_len);
i = 0;
for (; i < tasks_len; i++) {
fprintf(stderr, "Name: %s\n", (char *)tasks[i]->name);
fprintf(stderr, "Description: %s\n", (char *)tasks[i]->desc);
klist_stage *stage = klist_stage_get_by_id(ctx, tasks[i]->stage_id);
fprintf(stderr, "Stage: %s\n", (char*)stage->name);
klist_stage_deinit(stage);
klist_task_deinit(tasks[i]);
if ((i+1) < tasks_len) fprintf(stderr, "\n");
}
}
} else fprintf(stderr, "List not found");
case TASK_DELETE:
klist_assure_user(ctx, getuid(), getlogin());
user = klist_user_get_by_local(ctx, getuid());
list = klist_list_get_by_user_and_name(ctx, user->id, task_ctx->list);
if (list) {
if (task_ctx) {
klist_task *task = klist_task_get_for_list_by_name(ctx, list->id, task_ctx->name);
if (task) {
fprintf(stderr, "Deleting task '%s'.\n", (char *)task->name);
klist_task_delete(ctx, task);
klist_task_deinit(task);
} else fprintf(stderr, "Task not found.\n");
} else fprintf(stderr, "Task not found, only deletion by name is currently supoprted.\n");
}
fprintf(stderr, "Not implemented\n");
}
klist_task_context_deinit(task_ctx);
default: ;
} }
if (list) klist_list_deinit(list); list = klist_list_init();
if (user) klist_user_deinit(user); list->name = (unsigned char *)list_ctx->name;
} list->desc = (unsigned char *)list_ctx->desc;
list->is_preset = false;
klist_list_save(ctx, list);
i = 0;
for (; i < list_ctx->stages_len; i++) {
klist_stage *stage = klist_stage_init();
stage->name = (unsigned char *)list_ctx->stages[i];
stage->list_id = list->id;
klist_stage_save(ctx, stage);
klist_stage_deinit(stage);
}
break;
case LIST_EDIT:
fprintf(stderr, "Not implemented\n");
break;
case LIST_GET:
klist_assure_user(ctx, getuid(), getlogin());
user = klist_user_get_by_local(ctx, getuid());
list = klist_list_get_by_user_and_name(ctx, user->id, list_ctx->name);
if (list) {
size_t tasks_len = 0;
klist_task **tasks =
klist_task_get_for_list(ctx, list->id, &tasks_len);
fprintf(stderr, "Name: %s\nDescription: %s\nTasks: %ld\n",
(char *)list->name, (char *)list->desc, tasks_len);
int i = 0;
for (; i < tasks_len; i++)
klist_task_deinit(tasks[i]);
free(tasks);
} else
fprintf(stderr, "List '%s' not found.\n", list_ctx->name);
break;
case LIST_DELETE:
list = klist_list_get_by_user_and_name(ctx, user->id, list_ctx->name);
if (list) {
size_t tasks_len = 0;
klist_task **tasks =
klist_task_get_for_list(ctx, list->id, &tasks_len);
int i = 0;
for (; i < tasks_len; i++) {
klist_task_delete(ctx, tasks[i]);
klist_task_deinit(tasks[i]);
}
free(tasks);
}
}
if (list_ctx)
klist_list_context_deinit(list_ctx);
break;
case TASK:
klist_task_context *task_ctx = ctx->cmd_ctx;
switch (((klist_task_context *)ctx->cmd_ctx)->cmd) {
case TASK_ADD: // basically the same things happen and edit can create if
// nescessary
case TASK_EDIT:
klist_assure_user(ctx, getuid(), getlogin());
user = klist_user_get_by_local(ctx, getuid());
list = klist_list_get_by_user_and_name(ctx, user->id, task_ctx->list);
if (list) {
size_t stages_len = 0;
klist_stage **stages =
klist_stage_get_all_for_list(ctx, list->id, &stages_len);
if (!task_ctx->stage) {
fprintf(stderr, "Stage missing/wrong, please pass one of: ");
i = 0;
for (; i < stages_len; i++)
fprintf(stderr, "%s ", (char *)stages[i]->name);
fprintf(stderr, "\n");
break;
}
i = 0;
ssize_t stage_id = -1;
for (; i < stages_len; i++)
if (strcmp((char *)stages[i]->name, (char *)task_ctx->stage) == 0)
stage_id = stages[i]->id;
const int error = ctx->error; if (stage_id == -1) {
klist_deinit(ctx); fprintf(stderr, "Stage %s not found. Use one of: ",
return error; (char *)task_ctx->stage);
i = 0;
for (; i < stages_len; i++)
fprintf(stderr, "%s ", (char *)stages[i]->name);
fprintf(stderr, "\n");
}
i = 0;
for (; i < stages_len; i++)
klist_stage_deinit(stages[i]);
free(stages);
if (ctx->error)
break;
klist_task *task =
klist_task_get_for_list_by_name(ctx, list->id, task_ctx->name);
if (!task)
task = klist_task_init();
task->name = (unsigned char *)task_ctx->name;
if (task_ctx->desc)
task->desc = (unsigned char *)task_ctx->desc;
task->stage_id = stage_id;
klist_task_save(ctx, task);
klist_task_deinit(task);
} else
fprintf(stderr, "List not found.\n");
break;
case TASK_GET:
klist_assure_user(ctx, getuid(), getlogin());
user = klist_user_get_by_local(ctx, getuid());
list = klist_list_get_by_user_and_name(ctx, user->id, task_ctx->list);
if (list) {
if (task_ctx->name) {
klist_task *task =
klist_task_get_for_list_by_name(ctx, list->id, task_ctx->name);
if (task) {
fprintf(stderr, "Name: %s\n", (char *)task->name);
fprintf(stderr, "Description: %s\n", (char *)task->desc);
klist_stage *stage = klist_stage_get_by_id(ctx, task->stage_id);
fprintf(stderr, "Stage: %s\n", (char *)stage->name);
klist_stage_deinit(stage);
klist_task_deinit(task);
} else
fprintf(stderr, "Task not found.\n");
} else {
size_t tasks_len = 0;
klist_task **tasks =
klist_task_get_for_list(ctx, list->id, &tasks_len);
i = 0;
for (; i < tasks_len; i++) {
fprintf(stderr, "Name: %s\n", (char *)tasks[i]->name);
fprintf(stderr, "Description: %s\n", (char *)tasks[i]->desc);
klist_stage *stage =
klist_stage_get_by_id(ctx, tasks[i]->stage_id);
fprintf(stderr, "Stage: %s\n", (char *)stage->name);
klist_stage_deinit(stage);
klist_task_deinit(tasks[i]);
if ((i + 1) < tasks_len)
fprintf(stderr, "\n");
}
}
} else
fprintf(stderr, "List not found");
case TASK_DELETE:
klist_assure_user(ctx, getuid(), getlogin());
user = klist_user_get_by_local(ctx, getuid());
list = klist_list_get_by_user_and_name(ctx, user->id, task_ctx->list);
if (list) {
if (task_ctx) {
klist_task *task =
klist_task_get_for_list_by_name(ctx, list->id, task_ctx->name);
if (task) {
fprintf(stderr, "Deleting task '%s'.\n", (char *)task->name);
klist_task_delete(ctx, task);
klist_task_deinit(task);
} else
fprintf(stderr, "Task not found.\n");
} else
fprintf(stderr, "Task not found, only deletion by name is "
"currently supoprted.\n");
}
fprintf(stderr, "Not implemented\n");
}
klist_task_context_deinit(task_ctx);
default:;
}
if (list)
klist_list_deinit(list);
if (user)
klist_user_deinit(user);
}
const int error = ctx->error;
klist_deinit(ctx);
return error;
} }
void print_help(char **argv) { void print_help(char **argv) {
fprintf(stderr, "Usage: %s <action>\n", argv[0]); fprintf(stderr, "Usage: %s <action>\n", argv[0]);
} }
void setup(klist *ctx, int argc, char **argv) { void setup(klist *ctx, int argc, char **argv) {
if (strcmp(argv[1], "user") == 0) if (strcmp(argv[1], "user") == 0)
ctx->cmd = USER; ctx->cmd = USER;
else if (strcmp(argv[1], "list") == 0) else if (strcmp(argv[1], "list") == 0)
ctx->cmd = LIST; ctx->cmd = LIST;
else if (strcmp(argv[1], "task") == 0) else if (strcmp(argv[1], "task") == 0)
ctx->cmd = TASK; ctx->cmd = TASK;
else print_help(argv); else
print_help(argv);
int opt; int opt;
switch (ctx->cmd) { switch (ctx->cmd) {
case USER: case USER:
optind = 2; optind = 2;
klist_user_context *user_ctx = klist_user_context_init(ctx); klist_user_context *user_ctx = klist_user_context_init(ctx);
while ((opt = getopt(argc, argv, "cdg")) != -1) while ((opt = getopt(argc, argv, "cdg")) != -1)
switch (opt) { switch (opt) {
case 'c': case 'c':
user_ctx->cmd = USER_CREATE; user_ctx->cmd = USER_CREATE;
break; break;
case 'd': case 'd':
user_ctx->cmd = USER_DELETE; user_ctx->cmd = USER_DELETE;
break; break;
case 'g': case 'g':
user_ctx->cmd = USER_GET; user_ctx->cmd = USER_GET;
break; break;
default: default:
print_help(argv); print_help(argv);
} }
ctx->cmd_ctx = user_ctx; ctx->cmd_ctx = user_ctx;
break; break;
case LIST: case LIST:
if (argc < 3) { if (argc < 3) {
fprintf(stderr, "Prints all lists.\n"); fprintf(stderr, "Prints all lists.\n");
break; break;
}
klist_list_context *list_ctx = malloc(sizeof(struct klist_list_context));
optind = 3;
while ((opt = getopt(argc, argv, "adep:s:")) != -1)
switch (opt) {
case 'a':
list_ctx->cmd = LIST_ADD;
break;
case 'e':
list_ctx->cmd = LIST_EDIT;
break;
case 'd':
list_ctx->cmd = LIST_DELETE;
break;
case 'p':
list_ctx->preset = malloc((strlen(optarg) + 1) * sizeof(char));
strcpy(list_ctx->preset, optarg);
break;
default:
print_help(argv);
fprintf(stderr, ""
"list options:\n"
"-a\t\tadd a list\n"
"-e\t\tedit a list\n"
"-d\t\tdelete a list\n"
"-p <preset>\tdefine as preset or use existing one with name <preset>"
"Not providing a parameter prints all lists and existing presets.");
}
ctx->cmd_ctx = list_ctx;
break;
case TASK:
if (argc < 3) {
fprintf(stderr, "Prints all lists.\n");
break;
}
klist_task_context *task_ctx = malloc(sizeof(struct klist_task_context));
optind = 3;
while ((opt = getopt(argc, argv, "aeds:")) != -1)
switch (opt) {
case 'a':
task_ctx->cmd = TASK_ADD;
break;
case 'e':
task_ctx->cmd = TASK_EDIT;
break;
case 'd':
task_ctx->cmd = TASK_DELETE;
break;
default:
print_help(argv);
fprintf(stderr, ""
"task options:"
"-a\tadd a task"
"-e\tedit a task"
"-d\tdelete a task"
"Not providing a parameter prints all tasks of a list.");
}
ctx->cmd_ctx = task_ctx;
break;
default:
fprintf(stderr, "How did we land here?! Pls report argv[1] = %s\n", argv[1]);
print_help(argv);
} }
klist_list_context *list_ctx = malloc(sizeof(struct klist_list_context));
optind = 3;
while ((opt = getopt(argc, argv, "adep:s:")) != -1)
switch (opt) {
case 'a':
list_ctx->cmd = LIST_ADD;
break;
case 'e':
list_ctx->cmd = LIST_EDIT;
break;
case 'd':
list_ctx->cmd = LIST_DELETE;
break;
case 'p':
list_ctx->preset = malloc((strlen(optarg) + 1) * sizeof(char));
strcpy(list_ctx->preset, optarg);
break;
default:
print_help(argv);
fprintf(
stderr,
""
"list options:\n"
"-a\t\tadd a list\n"
"-e\t\tedit a list\n"
"-d\t\tdelete a list\n"
"-p <preset>\tdefine as preset or use existing one with name "
"<preset>"
"Not providing a parameter prints all lists and existing presets.");
}
ctx->cmd_ctx = list_ctx;
break;
case TASK:
if (argc < 3) {
fprintf(stderr, "Prints all lists.\n");
break;
}
klist_task_context *task_ctx = malloc(sizeof(struct klist_task_context));
optind = 3;
while ((opt = getopt(argc, argv, "aeds:")) != -1)
switch (opt) {
case 'a':
task_ctx->cmd = TASK_ADD;
break;
case 'e':
task_ctx->cmd = TASK_EDIT;
break;
case 'd':
task_ctx->cmd = TASK_DELETE;
break;
default:
print_help(argv);
fprintf(stderr,
""
"task options:"
"-a\tadd a task"
"-e\tedit a task"
"-d\tdelete a task"
"Not providing a parameter prints all tasks of a list.");
}
ctx->cmd_ctx = task_ctx;
break;
default:
fprintf(stderr, "How did we land here?! Pls report argv[1] = %s\n",
argv[1]);
print_help(argv);
}
} }

474
src/main/models.c
View file

@ -7,312 +7,332 @@
#include "sql.h" #include "sql.h"
klist_user *klist_user_init() { klist_user *klist_user_init() {
klist_user *user = malloc(sizeof(klist_user)); klist_user *user = malloc(sizeof(klist_user));
user->id = -1; user->id = -1;
user->name = NULL; user->name = NULL;
user->local_id = -1; user->local_id = -1;
return user; return user;
} }
klist_user *klist_user_init_from_sql(sqlite3_stmt *stmt) { klist_user *klist_user_init_from_sql(sqlite3_stmt *stmt) {
klist_user *user = klist_user_init(); klist_user *user = klist_user_init();
size_t bytes; size_t bytes;
user->id = sqlite3_column_int(stmt, 0); user->id = sqlite3_column_int(stmt, 0);
if ((bytes = sqlite3_column_bytes(stmt, 1)) > 0) { if ((bytes = sqlite3_column_bytes(stmt, 1)) > 0) {
user->name = malloc(bytes); user->name = malloc(bytes);
memcpy(user->name, sqlite3_column_text(stmt, 1), bytes); memcpy(user->name, sqlite3_column_text(stmt, 1), bytes);
} }
return user; return user;
} }
klist_user *klist_user_get_by_id(klist *ctx, u_int id) { klist_user *klist_user_get_by_id(klist *ctx, u_int id) {
sqlite3_stmt *stmt = ctx->stmts[GET_USER]; sqlite3_stmt *stmt = ctx->stmts[GET_USER];
sqlite3_bind_int(stmt, 1, id); sqlite3_bind_int(stmt, 1, id);
if (sqlite3_step(stmt) == SQLITE_ROW) { if (sqlite3_step(stmt) == SQLITE_ROW) {
sqlite3_clear_bindings(stmt); sqlite3_clear_bindings(stmt);
return klist_user_init_from_sql(stmt); return klist_user_init_from_sql(stmt);
} }
return NULL; return NULL;
} }
klist_user *klist_user_get_by_local(klist *ctx, u_int local_id) { klist_user *klist_user_get_by_local(klist *ctx, u_int local_id) {
sqlite3_stmt *stmt = ctx->stmts[GET_USER_BY_LOCAL]; sqlite3_stmt *stmt = ctx->stmts[GET_USER_BY_LOCAL];
sqlite3_bind_int(stmt, 1, local_id); sqlite3_bind_int(stmt, 1, local_id);
if (sqlite3_step(stmt) == SQLITE_ROW) { if (sqlite3_step(stmt) == SQLITE_ROW) {
sqlite3_clear_bindings(stmt); sqlite3_clear_bindings(stmt);
return klist_user_init_from_sql(stmt); return klist_user_init_from_sql(stmt);
} }
return NULL; return NULL;
} }
void klist_user_save(klist *ctx, klist_user *user) { void klist_user_save(klist *ctx, klist_user *user) {
sqlite3_stmt *stmt = ctx->stmts[ADD_USER]; sqlite3_stmt *stmt = ctx->stmts[ADD_USER];
int result = 0; int result = 0;
sqlite3_bind_text(stmt, 1, (char*)user->name, -1, SQLITE_STATIC); sqlite3_bind_text(stmt, 1, (char *)user->name, -1, SQLITE_STATIC);
if ((result = sqlite3_step(stmt)) == SQLITE_ROW) if ((result = sqlite3_step(stmt)) == SQLITE_ROW)
user->id = sqlite3_column_int(stmt, 1); user->id = sqlite3_column_int(stmt, 1);
else else
fprintf(stderr, "failed to save user: %s - %d\n", sqlite3_errmsg(ctx->db), result); fprintf(stderr, "failed to save user: %s - %d\n", sqlite3_errmsg(ctx->db),
sqlite3_clear_bindings(stmt); result);
sqlite3_clear_bindings(stmt);
if (user->local_id != -1) { if (user->local_id != -1) {
sqlite3_stmt *stmt = ctx->stmts[ADD_LOGIN]; sqlite3_stmt *stmt = ctx->stmts[ADD_LOGIN];
int result = 0; int result = 0;
sqlite3_bind_int(stmt, 1, user->id); sqlite3_bind_int(stmt, 1, user->id);
sqlite3_bind_int(stmt, 2, user->local_id); sqlite3_bind_int(stmt, 2, user->local_id);
if ((result = sqlite3_step(stmt)) != SQLITE_ROW) if ((result = sqlite3_step(stmt)) != SQLITE_ROW)
fprintf(stderr, "failed to save logins for user: %s - %d\n", sqlite3_errmsg(ctx->db), result); fprintf(stderr, "failed to save logins for user: %s - %d\n",
sqlite3_clear_bindings(stmt); sqlite3_errmsg(ctx->db), result);
} sqlite3_clear_bindings(stmt);
}
} }
void klist_user_delete(klist *ctx, klist_user *user) { void klist_user_delete(klist *ctx, klist_user *user) {
sqlite3_stmt *stmt = ctx->stmts[DEL_USER]; sqlite3_stmt *stmt = ctx->stmts[DEL_USER];
sqlite3_bind_int(stmt, 1, (int)user->id); sqlite3_bind_int(stmt, 1, (int)user->id);
if (sqlite3_step(stmt) == SQLITE_ROW) if (sqlite3_step(stmt) == SQLITE_ROW)
sqlite3_clear_bindings(stmt); sqlite3_clear_bindings(stmt);
} }
void klist_user_deinit(klist_user *user) { void klist_user_deinit(klist_user *user) {
free(user->name); free(user->name);
free(user); free(user);
} }
klist_stage *klist_stage_init() { klist_stage *klist_stage_init() {
klist_stage *stage = malloc(sizeof(klist_stage)); klist_stage *stage = malloc(sizeof(klist_stage));
stage->id = -1; stage->id = -1;
stage->name = NULL; stage->name = NULL;
stage->desc = NULL; stage->desc = NULL;
stage->list_id = -1; stage->list_id = -1;
return stage; return stage;
} }
klist_stage *klist_stage_init_from_sql(sqlite3_stmt *stmt) { klist_stage *klist_stage_init_from_sql(sqlite3_stmt *stmt) {
klist_stage *stage = klist_stage_init(); klist_stage *stage = klist_stage_init();
size_t bytes; size_t bytes;
stage->id = sqlite3_column_int(stmt, 0); stage->id = sqlite3_column_int(stmt, 0);
if ((bytes = sqlite3_column_bytes(stmt, 1)) > 0) { if ((bytes = sqlite3_column_bytes(stmt, 1)) > 0) {
stage->name = malloc(bytes); stage->name = malloc(bytes);
memcpy(stage->name, sqlite3_column_text(stmt, 1), bytes); memcpy(stage->name, sqlite3_column_text(stmt, 1), bytes);
} }
if ((bytes = sqlite3_column_bytes(stmt, 2)) > 0) { if ((bytes = sqlite3_column_bytes(stmt, 2)) > 0) {
stage->desc = malloc(bytes); stage->desc = malloc(bytes);
memcpy(stage->desc, sqlite3_column_text(stmt, 2), bytes); memcpy(stage->desc, sqlite3_column_text(stmt, 2), bytes);
} }
return stage; return stage;
} }
klist_stage *klist_stage_get_by_id(klist *ctx, u_int id) { klist_stage *klist_stage_get_by_id(klist *ctx, u_int id) {
sqlite3_stmt *stmt = ctx->stmts[GET_STAGE]; sqlite3_stmt *stmt = ctx->stmts[GET_STAGE];
sqlite3_bind_int(stmt, 1, id); sqlite3_bind_int(stmt, 1, id);
if (sqlite3_step(stmt) == SQLITE_ROW) { if (sqlite3_step(stmt) == SQLITE_ROW) {
sqlite3_clear_bindings(stmt); sqlite3_clear_bindings(stmt);
return klist_stage_init_from_sql(stmt); return klist_stage_init_from_sql(stmt);
} }
return NULL; return NULL;
} }
klist_stage **klist_stage_get_all_for_list(klist *ctx, u_int id, size_t *count) { klist_stage **klist_stage_get_all_for_list(klist *ctx, u_int id,
sqlite3_stmt *stmt = ctx->stmts[GET_STAGES_FOR_LIST]; size_t *count) {
sqlite3_bind_int(stmt, 1, id); sqlite3_stmt *stmt = ctx->stmts[GET_STAGES_FOR_LIST];
klist_stage **stages = NULL; sqlite3_bind_int(stmt, 1, id);
size_t stages_len = 0; klist_stage **stages = NULL;
while (sqlite3_step(stmt) == SQLITE_ROW) { size_t stages_len = 0;
stages_len++; while (sqlite3_step(stmt) == SQLITE_ROW) {
klist_stage **_stages = realloc(stages, stages_len * sizeof(klist_stage *)); stages_len++;
if (_stages) { klist_stage **_stages = realloc(stages, stages_len * sizeof(klist_stage *));
stages = _stages; if (_stages) {
stages[stages_len - 1] = klist_stage_init(stmt); stages = _stages;
} stages[stages_len - 1] = klist_stage_init(stmt);
} }
if (count != NULL) *count = stages_len; }
return stages; if (count != NULL)
*count = stages_len;
return stages;
} }
void klist_stage_save(klist *ctx, klist_stage *stage) { void klist_stage_save(klist *ctx, klist_stage *stage) {
sqlite3_stmt *stmt = ctx->stmts[ADD_STAGE]; sqlite3_stmt *stmt = ctx->stmts[ADD_STAGE];
int result = 0; int result = 0;
sqlite3_bind_text(stmt, 1, (char*)stage->name, -1, SQLITE_STATIC); sqlite3_bind_text(stmt, 1, (char *)stage->name, -1, SQLITE_STATIC);
sqlite3_bind_text(stmt, 2, (char*)stage->name, -1, SQLITE_STATIC); sqlite3_bind_text(stmt, 2, (char *)stage->name, -1, SQLITE_STATIC);
if ((result = sqlite3_step(stmt)) == SQLITE_ROW) { if ((result = sqlite3_step(stmt)) == SQLITE_ROW) {
stage->id = sqlite3_column_int(stmt, 1); stage->id = sqlite3_column_int(stmt, 1);
sqlite3_clear_bindings(stmt); sqlite3_clear_bindings(stmt);
} else fprintf(stderr, "failed to save stage: %s - %d\n", sqlite3_errmsg(ctx->db), result); } else
fprintf(stderr, "failed to save stage: %s - %d\n", sqlite3_errmsg(ctx->db),
result);
} }
void klist_stage_deinit(klist_stage *stage) { void klist_stage_deinit(klist_stage *stage) {
if (stage->name) free(stage->name); if (stage->name)
if (stage->desc) free(stage->desc); free(stage->name);
free(stage); if (stage->desc)
free(stage->desc);
free(stage);
} }
klist_list *klist_list_init() { klist_list *klist_list_init() {
klist_list *list = malloc(sizeof(klist_list)); klist_list *list = malloc(sizeof(klist_list));
list->id = -1; list->id = -1;
list->name = NULL; list->name = NULL;
list->desc = NULL; list->desc = NULL;
list->is_preset = false; list->is_preset = false;
return list; return list;
} }
klist_list *klist_list_init_from_sql(sqlite3_stmt *stmt) { klist_list *klist_list_init_from_sql(sqlite3_stmt *stmt) {
klist_list *list = klist_list_init(); klist_list *list = klist_list_init();
size_t bytes; size_t bytes;
list->id = sqlite3_column_int(stmt, 0); list->id = sqlite3_column_int(stmt, 0);
if ((bytes = sqlite3_column_bytes(stmt, 1)) > 0) { if ((bytes = sqlite3_column_bytes(stmt, 1)) > 0) {
list->name = malloc(bytes); list->name = malloc(bytes);
memcpy(list->name, sqlite3_column_text(stmt, 1), bytes); memcpy(list->name, sqlite3_column_text(stmt, 1), bytes);
} }
if ((bytes = sqlite3_column_bytes(stmt, 2)) > 0) { if ((bytes = sqlite3_column_bytes(stmt, 2)) > 0) {
list->desc = malloc(bytes); list->desc = malloc(bytes);
memcpy(list->desc, sqlite3_column_text(stmt, 2), bytes); memcpy(list->desc, sqlite3_column_text(stmt, 2), bytes);
} }
list->is_preset = sqlite3_column_int(stmt, 3) ? true : false; list->is_preset = sqlite3_column_int(stmt, 3) ? true : false;
return list; return list;
} }
klist_list *klist_list_get_by_id(klist *ctx, u_int id) { klist_list *klist_list_get_by_id(klist *ctx, u_int id) {
sqlite3_stmt *stmt = ctx->stmts[GET_LIST]; sqlite3_stmt *stmt = ctx->stmts[GET_LIST];
sqlite3_bind_int(stmt, 1, id); sqlite3_bind_int(stmt, 1, id);
if (sqlite3_step(stmt) == SQLITE_ROW) { if (sqlite3_step(stmt) == SQLITE_ROW) {
sqlite3_clear_bindings(stmt); sqlite3_clear_bindings(stmt);
return klist_list_init_from_sql(stmt); return klist_list_init_from_sql(stmt);
} }
return NULL; return NULL;
} }
klist_list **klist_list_get_all_by_user(klist *ctx, u_int user_id, size_t *count) { klist_list **klist_list_get_all_by_user(klist *ctx, u_int user_id,
sqlite3_stmt *stmt = ctx->stmts[GET_LISTS_BY_USER]; size_t *count) {
sqlite3_bind_int(stmt, 1, user_id); sqlite3_stmt *stmt = ctx->stmts[GET_LISTS_BY_USER];
klist_list **lists = NULL; sqlite3_bind_int(stmt, 1, user_id);
size_t lists_len = 0; klist_list **lists = NULL;
while (sqlite3_step(stmt) == SQLITE_ROW) { size_t lists_len = 0;
lists_len++; while (sqlite3_step(stmt) == SQLITE_ROW) {
klist_list **_lists = realloc(lists, lists_len * sizeof(klist_list *)); lists_len++;
if (_lists) { klist_list **_lists = realloc(lists, lists_len * sizeof(klist_list *));
lists = _lists; if (_lists) {
lists[lists_len - 1] = klist_list_init(stmt); lists = _lists;
} lists[lists_len - 1] = klist_list_init(stmt);
} }
if (count != NULL) *count = lists_len; }
return lists; 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) { klist_list *klist_list_get_by_user_and_name(klist *ctx, u_int user_id,
sqlite3_stmt *stmt = ctx->stmts[GET_LISTS_BY_USER]; const char *name) {
sqlite3_bind_int(stmt, 1, user_id); sqlite3_stmt *stmt = ctx->stmts[GET_LISTS_BY_USER];
sqlite3_bind_text(stmt, 2, name, -1, SQLITE_STATIC); sqlite3_bind_int(stmt, 1, user_id);
sqlite3_bind_text(stmt, 2, name, -1, SQLITE_STATIC);
if (sqlite3_step(stmt) == SQLITE_ROW) { if (sqlite3_step(stmt) == SQLITE_ROW) {
sqlite3_clear_bindings(stmt); sqlite3_clear_bindings(stmt);
return klist_list_init(stmt); return klist_list_init(stmt);
} }
return NULL; return NULL;
} }
void klist_list_save(klist *ctx, klist_list *list) { void klist_list_save(klist *ctx, klist_list *list) {
sqlite3_stmt *stmt = ctx->stmts[ADD_LIST]; sqlite3_stmt *stmt = ctx->stmts[ADD_LIST];
int result = 0; int result = 0;
sqlite3_bind_text(stmt, 1, (char*)list->name, -1, SQLITE_STATIC); sqlite3_bind_text(stmt, 1, (char *)list->name, -1, SQLITE_STATIC);
sqlite3_bind_text(stmt, 2, (char*)list->desc, -1, SQLITE_STATIC); sqlite3_bind_text(stmt, 2, (char *)list->desc, -1, SQLITE_STATIC);
if ((result = sqlite3_step(stmt)) == SQLITE_ROW) { if ((result = sqlite3_step(stmt)) == SQLITE_ROW) {
list->id = sqlite3_column_int(stmt, 1); list->id = sqlite3_column_int(stmt, 1);
sqlite3_clear_bindings(stmt); sqlite3_clear_bindings(stmt);
} else fprintf(stderr, "failed to save list: %s - %d\n", sqlite3_errmsg(ctx->db), result); } else
fprintf(stderr, "failed to save list: %s - %d\n", sqlite3_errmsg(ctx->db),
result);
} }
void klist_list_deinit(klist_list *list) { void klist_list_deinit(klist_list *list) {
if (list->name) free(list->name); if (list->name)
if (list->desc) free(list->desc); free(list->name);
free(list); if (list->desc)
free(list->desc);
free(list);
} }
klist_task *klist_task_init() { klist_task *klist_task_init() {
klist_task *task = malloc(sizeof(klist_task)); klist_task *task = malloc(sizeof(klist_task));
task->id = -1; task->id = -1;
task->name = NULL; task->name = NULL;
task->desc = NULL; task->desc = NULL;
return task; return task;
} }
klist_task *klist_task_init_from_sql(sqlite3_stmt *stmt) { klist_task *klist_task_init_from_sql(sqlite3_stmt *stmt) {
klist_task *task = klist_task_init(); klist_task *task = klist_task_init();
size_t bytes; size_t bytes;
task->id = sqlite3_column_int(stmt, 0); task->id = sqlite3_column_int(stmt, 0);
if ((bytes = sqlite3_column_bytes(stmt, 1)) > 0) { if ((bytes = sqlite3_column_bytes(stmt, 1)) > 0) {
task->name = malloc(bytes); task->name = malloc(bytes);
memcpy(task->name, sqlite3_column_text(stmt, 1), bytes); memcpy(task->name, sqlite3_column_text(stmt, 1), bytes);
} }
if ((bytes = sqlite3_column_bytes(stmt, 2)) > 0) { if ((bytes = sqlite3_column_bytes(stmt, 2)) > 0) {
task->desc = malloc(bytes); task->desc = malloc(bytes);
memcpy(task->desc, sqlite3_column_text(stmt, 2), bytes); memcpy(task->desc, sqlite3_column_text(stmt, 2), bytes);
} }
return task; return task;
} }
klist_task *klist_task_get_by_id(klist *ctx, u_int id) { klist_task *klist_task_get_by_id(klist *ctx, u_int id) {
sqlite3_stmt *stmt = ctx->stmts[GET_TASK]; sqlite3_stmt *stmt = ctx->stmts[GET_TASK];
sqlite3_bind_int(stmt, 1, id); sqlite3_bind_int(stmt, 1, id);
if (sqlite3_step(stmt) == SQLITE_ROW) { if (sqlite3_step(stmt) == SQLITE_ROW) {
sqlite3_clear_bindings(stmt); sqlite3_clear_bindings(stmt);
return klist_task_init_from_sql(stmt); return klist_task_init_from_sql(stmt);
} }
return NULL; return NULL;
} }
klist_task **klist_task_get_for_list(klist *ctx, u_int list_id, size_t *count) { 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_stmt *stmt = ctx->stmts[GET_TASKS_FOR_LIST];
sqlite3_bind_int(stmt, 1, list_id); sqlite3_bind_int(stmt, 1, list_id);
klist_task **tasks = NULL; klist_task **tasks = NULL;
size_t tasks_len = 0; size_t tasks_len = 0;
while (sqlite3_step(stmt) == SQLITE_ROW) { while (sqlite3_step(stmt) == SQLITE_ROW) {
tasks_len++; tasks_len++;
tasks = realloc(tasks, tasks_len * sizeof(klist_task *)); tasks = realloc(tasks, tasks_len * sizeof(klist_task *));
tasks[tasks_len - 1] = klist_task_init_from_sql(stmt); tasks[tasks_len - 1] = klist_task_init_from_sql(stmt);
} }
sqlite3_clear_bindings(stmt); sqlite3_clear_bindings(stmt);
*count = tasks_len; *count = tasks_len;
return tasks; return tasks;
} }
klist_task *klist_task_get_for_list_by_name(klist *ctx, u_int list_id, const char *name) { klist_task *klist_task_get_for_list_by_name(klist *ctx, u_int list_id,
sqlite3_stmt *stmt = ctx->stmts[GET_TASKS_FOR_LIST_BY_NAME]; const char *name) {
sqlite3_bind_int(stmt, 1, list_id); sqlite3_stmt *stmt = ctx->stmts[GET_TASKS_FOR_LIST_BY_NAME];
sqlite3_bind_text(stmt, 2, name, -1, SQLITE_STATIC); sqlite3_bind_int(stmt, 1, list_id);
sqlite3_bind_text(stmt, 2, name, -1, SQLITE_STATIC);
if (sqlite3_step(stmt) == SQLITE_ROW) { if (sqlite3_step(stmt) == SQLITE_ROW) {
sqlite3_clear_bindings(stmt); sqlite3_clear_bindings(stmt);
return klist_task_init(stmt); return klist_task_init(stmt);
} }
return NULL; return NULL;
} }
void klist_task_save(klist *ctx, klist_task *task) { void klist_task_save(klist *ctx, klist_task *task) {
sqlite3_stmt *stmt = ctx->stmts[ADD_TASK]; sqlite3_stmt *stmt = ctx->stmts[ADD_TASK];
int result = 0; int result = 0;
sqlite3_bind_text(stmt, 1, (char*)task->name, -1, SQLITE_STATIC); sqlite3_bind_text(stmt, 1, (char *)task->name, -1, SQLITE_STATIC);
sqlite3_bind_text(stmt, 2, (char*)task->desc, -1, SQLITE_STATIC); sqlite3_bind_text(stmt, 2, (char *)task->desc, -1, SQLITE_STATIC);
sqlite3_bind_int(stmt, 3, task->stage_id); sqlite3_bind_int(stmt, 3, task->stage_id);
if (task->due) sqlite3_bind_int(stmt, 4, task->due); if (task->due)
if (task->target_stage) sqlite3_bind_int(stmt, 5, task->target_stage); sqlite3_bind_int(stmt, 4, task->due);
if ((result = sqlite3_step(stmt)) == SQLITE_ROW) { if (task->target_stage)
task->id = sqlite3_column_int(stmt, 1); sqlite3_bind_int(stmt, 5, task->target_stage);
sqlite3_clear_bindings(stmt); if ((result = sqlite3_step(stmt)) == SQLITE_ROW) {
} else fprintf(stderr, "failed to save list: %s - %d\n", sqlite3_errmsg(ctx->db), result); task->id = sqlite3_column_int(stmt, 1);
sqlite3_clear_bindings(stmt);
} else
fprintf(stderr, "failed to save list: %s - %d\n", sqlite3_errmsg(ctx->db),
result);
} }
void klist_task_delete(klist *ctx, klist_task *task) { void klist_task_delete(klist *ctx, klist_task *task) {
sqlite3_stmt *stmt = ctx->stmts[DEL_TASK]; sqlite3_stmt *stmt = ctx->stmts[DEL_TASK];
sqlite3_bind_int(stmt, 1, task->id); sqlite3_bind_int(stmt, 1, task->id);
if (sqlite3_step(stmt) == SQLITE_DONE) if (sqlite3_step(stmt) == SQLITE_DONE)
sqlite3_clear_bindings(stmt); sqlite3_clear_bindings(stmt);
else fprintf(stderr, "failed to delete task: %s\n", sqlite3_errmsg(ctx->db)); else
fprintf(stderr, "failed to delete task: %s\n", sqlite3_errmsg(ctx->db));
} }
void klist_task_deinit(klist_task *task) { void klist_task_deinit(klist_task *task) {
if (task->name) free(task->name); if (task->name)
if (task->desc) free(task->desc); free(task->name);
free(task); if (task->desc)
free(task->desc);
free(task);
} }

181
src/main/sql.c
View file

@ -1,77 +1,114 @@
#include "include/sql.h" #include "include/sql.h"
const char *klist_sql_get(const enum KLIST_SQL sql) { const char *klist_sql_get(const enum KLIST_SQL sql) {
switch (sql) { switch (sql) {
case INIT: return case INIT:
"create table if not exists users (\n" return "create table if not exists users (\n"
" id integer primary key,\n" " id integer primary key,\n"
" name text not null\n" " name text not null\n"
");\n" ");\n"
"create table if not exists user_logins (\n" "create table if not exists user_logins (\n"
" id integer primary key,\n" " id integer primary key,\n"
" user_id integer not null,\n" " user_id integer not null,\n"
" local_id integer,\n" " local_id integer,\n"
" foreign key (user_id) references users(id)" " foreign key (user_id) references users(id)"
");\n" ");\n"
"create table if not exists user_lists (\n" "create table if not exists user_lists (\n"
" id integer primary key,\n" " id integer primary key,\n"
" user_id integer not null,\n" " user_id integer not null,\n"
" list_id integer not null,\n" " list_id integer not null,\n"
" foreign key (user_id) references users(id),\n" " foreign key (user_id) references users(id),\n"
" foreign key (list_id) references lists(id)\n" " foreign key (list_id) references lists(id)\n"
");\n" ");\n"
"create table if not exists lists (\n" "create table if not exists lists (\n"
" id integer primary key,\n" " id integer primary key,\n"
" name text not null,\n" " name text not null,\n"
" desc text,\n" " desc text,\n"
" is_preset int not null\n" " is_preset int not null\n"
");\n" ");\n"
"create table if not exists task_stages (\n" "create table if not exists task_stages (\n"
" id integer primary key,\n" " id integer primary key,\n"
" name text not null,\n" " name text not null,\n"
" desc text,\n" " desc text,\n"
" list_id integer not null,\n" " list_id integer not null,\n"
" foreign key (list_id) references lists(id)\n" " foreign key (list_id) references lists(id)\n"
");\n" ");\n"
"-- this currently enables moving tasks _between lists_ (planned of course)\n" "-- this currently enables moving tasks _between lists_ (planned of "
"create table if not exists tasks (\n" "course)\n"
" id integer primary key,\n" "create table if not exists tasks (\n"
" name text not null,\n" " id integer primary key,\n"
" desc text,\n" " name text not null,\n"
" stage integer not null,\n" " desc text,\n"
" due date,\n" " stage integer not null,\n"
" target_stage integer, -- more like target stage\n" " due date,\n"
" foreign key (stage) references task_stages(id),\n" " target_stage integer, -- more like target stage\n"
" foreign key (target_stage) references task_stages(id)\n" " foreign key (stage) references task_stages(id),\n"
")"; " foreign key (target_stage) references task_stages(id)\n"
case ADD_LOGIN: return "insert into user_logins (user_id, local_id) values (?1, ?2) on conflict (id) do update set user_id=excluded.user_id, local_id=excluded.local_id returning id"; ")";
case ADD_USER: return "insert into users (name) values (?1) on conflict (id) do update set name=excluded.name returning id"; case ADD_LOGIN:
case GET_USER: return "select users.*, user_logins.local_id from users inner join user_logins on user_logins.user_id = users.id where users.id = ?1"; return "insert into user_logins (user_id, local_id) values (?1, ?2) on "
case GET_USER_BY_LOCAL: return "select * from users inner join user_logins on user_logins.user_id = users.id where user_logins.local_id = ?1"; "conflict (id) do update set user_id=excluded.user_id, "
case GET_USERS: return "select * from users"; "local_id=excluded.local_id returning id";
case MOD_USER_NAME: return "update users set name = ?1 where id = ?2"; case ADD_USER:
case DEL_USER: return "delete from users where id = ?1"; return "insert into users (name) values (?1) on conflict (id) do update "
case ADD_LIST: return "insert into lists (name, desc, is_preset) values (?1, ?2, ?3)"; "set name=excluded.name returning id";
case GET_LIST: return "select * from lists where id = ?1"; case GET_USER:
case GET_LISTS: return "select * from lists"; return "select users.*, user_logins.local_id from users inner join "
case GET_LISTS_BY_USER: return "select * from lists inner join user_lists on user_lists.list_id = lists.id where user_lists.user_id = ?1"; "user_logins on user_logins.user_id = users.id where users.id = ?1";
case GET_LISTS_BY_USER_NAME: return "select * from lists inner join user_lists on user_lists.list_id = lists.id where user_lists.user_id = ?1 and lists.name like '?2'"; case GET_USER_BY_LOCAL:
case MOD_LIST_NAME: return "update lists set name = ?1 where id = ?2"; return "select * from users inner join user_logins on user_logins.user_id "
case DEL_LIST: return "delete from lists where id = ?1"; "= users.id where user_logins.local_id = ?1";
case ADD_STAGE: return "insert into task_stages (name, desc, list_id) values (?1, ?2, ?3)"; case GET_USERS:
case GET_STAGE: return "select * from task_stages where id = ?1"; return "select * from users";
case GET_STAGES_FOR_LIST: return "select * from task_stages where list_id = ?1"; case MOD_USER_NAME:
case DEL_STAGE: return "delete from task_stages where id = ?1"; return "update users set name = ?1 where id = ?2";
case ADD_TASK: return "insert into tasks (name, desc, stage, due, target_stage) values (?1, ?2, ?3, ?4, ?5);"; case DEL_USER:
case GET_TASK: return "select * from tasks where id = ?1"; return "delete from users where id = ?1";
case GET_TASKS: return "select * from tasks;"; case ADD_LIST:
case GET_TASKS_FOR_LIST: return "select tasks.* from tasks join task_stages on task_stages.id = tasks.stage where task_stages.list_id = ?1"; return "insert into lists (name, desc, is_preset) values (?1, ?2, ?3)";
case GET_TASKS_FOR_LIST_BY_NAME: return "select tasks.* from tasks join task_stages on task_stages.id = tasks.stage where task_stages.list_id = ?1 and tasks.name like ?2"; case GET_LIST:
case MOD_TASK_NAME: return "update tasks set name = ?1 where id = ?2"; return "select * from lists where id = ?1";
case MOD_TASK_DESCRIPTION: return "update tasks set desc = ?1 where id = ?2"; case GET_LISTS:
case DEL_TASK: return "delete from tasks where id = ?1"; return "select * from lists";
case _KLIST_SQL_COUNT: return ""; case GET_LISTS_BY_USER:
} return "select * from lists inner join user_lists on user_lists.list_id = "
"lists.id where user_lists.user_id = ?1";
case GET_LISTS_BY_USER_NAME:
return "select * from lists inner join user_lists on user_lists.list_id = "
"lists.id where user_lists.user_id = ?1 and lists.name like '?2'";
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 (name, desc, list_id) values (?1, ?2, ?3)";
case GET_STAGE:
return "select * from task_stages where id = ?1";
case GET_STAGES_FOR_LIST:
return "select * from task_stages where list_id = ?1";
case DEL_STAGE:
return "delete from task_stages where id = ?1";
case ADD_TASK:
return "insert into tasks (name, desc, stage, due, target_stage) values "
"(?1, ?2, ?3, ?4, ?5);";
case GET_TASK:
return "select * from tasks where id = ?1";
case GET_TASKS:
return "select * from tasks;";
case GET_TASKS_FOR_LIST:
return "select tasks.* from tasks join task_stages on task_stages.id = "
"tasks.stage where task_stages.list_id = ?1";
case GET_TASKS_FOR_LIST_BY_NAME:
return "select tasks.* from tasks join task_stages on task_stages.id = "
"tasks.stage where task_stages.list_id = ?1 and tasks.name like ?2";
case MOD_TASK_NAME:
return "update tasks set name = ?1 where id = ?2";
case MOD_TASK_DESCRIPTION:
return "update tasks set desc = ?1 where id = ?2";
case DEL_TASK:
return "delete from tasks where id = ?1";
case _KLIST_SQL_COUNT:
return ""; return "";
}
return "";
} }

157
src/main/util.c
View file

@ -1,5 +1,5 @@
#include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include "util.h" #include "util.h"
@ -13,69 +13,74 @@
*/ */
klist *klist_init(char *db) { klist *klist_init(char *db) {
klist *ctx = malloc(sizeof(klist)); klist *ctx = malloc(sizeof(klist));
ctx->stmts = malloc(_KLIST_SQL_COUNT * sizeof(sqlite3_stmt *)); ctx->stmts = malloc(_KLIST_SQL_COUNT * sizeof(sqlite3_stmt *));
ctx->cmd_ctx = NULL; ctx->cmd_ctx = NULL;
ctx->error = 0; ctx->error = 0;
klist_sql_prepare(ctx, db); klist_sql_prepare(ctx, db);
return ctx; return ctx;
} }
void klist_deinit(klist *ctx) { void klist_deinit(klist *ctx) {
int i = 0; int i = 0;
for (; i < _KLIST_SQL_COUNT; i++) for (; i < _KLIST_SQL_COUNT; i++)
sqlite3_finalize(ctx->stmts[i]); sqlite3_finalize(ctx->stmts[i]);
sqlite3_close(ctx->db); sqlite3_close(ctx->db);
//if (ctx->cmd_ctx) free(ctx->cmd_ctx); // if (ctx->cmd_ctx) free(ctx->cmd_ctx);
free(ctx->stmts); free(ctx->stmts);
free(ctx); free(ctx);
} }
klist_user_context *klist_user_context_init(klist *list) { klist_user_context *klist_user_context_init(klist *list) {
klist_user_context *ctx = malloc(sizeof(klist_user_context)); klist_user_context *ctx = malloc(sizeof(klist_user_context));
ctx->cmd = -1; ctx->cmd = -1;
return ctx; return ctx;
}
void klist_user_context_deinit(klist_user_context *ctx) {
free(ctx);
} }
void klist_user_context_deinit(klist_user_context *ctx) { free(ctx); }
klist_list_context *klist_list_context_init(klist *list) { klist_list_context *klist_list_context_init(klist *list) {
klist_list_context *ctx = malloc(sizeof(klist_list_context)); klist_list_context *ctx = malloc(sizeof(klist_list_context));
ctx->cmd = -1; ctx->cmd = -1;
ctx->name = NULL; ctx->name = NULL;
ctx->desc = NULL; ctx->desc = NULL;
ctx->stages = NULL; ctx->stages = NULL;
ctx->stages_len = 0; ctx->stages_len = 0;
ctx->preset = NULL; ctx->preset = NULL;
return ctx; return ctx;
} }
void klist_list_context_deinit(klist_list_context *ctx) { void klist_list_context_deinit(klist_list_context *ctx) {
if (ctx->name) free(ctx->name); if (ctx->name)
if (ctx->desc) free(ctx->desc); free(ctx->name);
if (ctx->preset) free(ctx->preset); if (ctx->desc)
if (ctx->stages) { free(ctx->desc);
int i = 0; if (ctx->preset)
for (; i < ctx->stages_len; i++) free(ctx->stages[i]); free(ctx->preset);
free(ctx->stages); if (ctx->stages) {
} int i = 0;
free(ctx); for (; i < ctx->stages_len; i++)
free(ctx->stages[i]);
free(ctx->stages);
}
free(ctx);
} }
klist_task_context *klist_task_context_init(klist *list) { klist_task_context *klist_task_context_init(klist *list) {
klist_task_context *ctx = malloc(sizeof(klist_task_context)); klist_task_context *ctx = malloc(sizeof(klist_task_context));
ctx->cmd = -1; ctx->cmd = -1;
ctx->name = NULL; ctx->name = NULL;
ctx->list = NULL; ctx->list = NULL;
ctx->stage = NULL; ctx->stage = NULL;
return ctx; return ctx;
} }
void klist_task_context_deinit(klist_task_context *ctx) { void klist_task_context_deinit(klist_task_context *ctx) {
if (ctx->name) free(ctx->name); if (ctx->name)
if (ctx->list) free(ctx->list); free(ctx->name);
if (ctx->stage) free(ctx->stage); if (ctx->list)
free(ctx); free(ctx->list);
if (ctx->stage)
free(ctx->stage);
free(ctx);
} }
/* /*
@ -83,43 +88,43 @@ void klist_task_context_deinit(klist_task_context *ctx) {
*/ */
void klist_sql_prepare(klist *ctx, char *db) { void klist_sql_prepare(klist *ctx, char *db) {
if (sqlite3_open(db ? db : ":memory:", &ctx->db) != SQLITE_OK) { if (sqlite3_open(db ? db : ":memory:", &ctx->db) != SQLITE_OK) {
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(ctx->db)); fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(ctx->db));
return; return;
} }
char *errmsg = NULL; char *errmsg = NULL;
sqlite3_exec(ctx->db, klist_sql_get(INIT), NULL, NULL, &errmsg); sqlite3_exec(ctx->db, klist_sql_get(INIT), NULL, NULL, &errmsg);
if (errmsg) { if (errmsg) {
fprintf(stderr, "Database initialization failed (%s), expect issues.\n", sqlite3_errmsg(ctx->db)); fprintf(stderr, "Database initialization failed (%s), expect issues.\n",
sqlite3_free(errmsg); sqlite3_errmsg(ctx->db));
} sqlite3_free(errmsg);
int i = 0; }
for (; i < _KLIST_SQL_COUNT; i++) int i = 0;
if (sqlite3_prepare(ctx->db, klist_sql_get(i), -1, &ctx->stmts[i], NULL) != SQLITE_OK) for (; i < _KLIST_SQL_COUNT; i++)
fprintf(stderr, "sqlite3_prepare: %s\n", sqlite3_errmsg(ctx->db)); if (sqlite3_prepare(ctx->db, klist_sql_get(i), -1, &ctx->stmts[i], NULL) !=
SQLITE_OK)
fprintf(stderr, "sqlite3_prepare: %s\n", sqlite3_errmsg(ctx->db));
} }
void klist_sql_seed(klist *ctx) { void klist_sql_seed(klist *ctx) {}
}
/* /*
* assuring things * assuring things
*/ */
bool klist_assure_user(klist *ctx, __uid_t id, char *name) { bool klist_assure_user(klist *ctx, __uid_t id, char *name) {
klist_user *user = klist_user_get_by_local(ctx, id); klist_user *user = klist_user_get_by_local(ctx, id);
bool created = false; bool created = false;
if (!user) { if (!user) {
user = klist_user_init(); user = klist_user_init();
user->name = malloc((strlen(name) + 1) * sizeof(char)); user->name = malloc((strlen(name) + 1) * sizeof(char));
strcpy((char *)user->name, name); strcpy((char *)user->name, name);
user->local_id = id; user->local_id = id;
klist_user_save(ctx, user); klist_user_save(ctx, user);
created = true; created = true;
} }
klist_user_deinit(user); klist_user_deinit(user);
return created; return created;
} }
void klist_assure_list(klist *, char *); void klist_assure_list(klist *, char *);
void klist_assure_task(klist *, char *); void klist_assure_task(klist *, char *);