fy59/trainlog
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions
trainlog/tui/src/web_analysis.c

791 lines
40 KiB
C
Raw Blame History

#include "trainlog/web_analysis.h"
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sqlite3.h>
#include <yyjson.h>
#include "database_internal.h"
#include "trainlog/body_zone_catalog.h"
#define SECONDS_PER_DAY INT64_C(86400)
typedef struct MeasurementDefinition {
const char *id;
const char *column;
const char *unit;
} MeasurementDefinition;
static const MeasurementDefinition MEASUREMENTS[] = {
{"weight", "body_weight_kg", "kg"},
{"neck", "neck_cm", "cm"},
{"shoulders", "shoulders_cm", "cm"},
{"chest", "chest_cm", "cm"},
{"waist", "waist_cm", "cm"},
{"hips", "hips_cm", "cm"},
{"left_arm", "left_arm_cm", "cm"},
{"right_arm", "right_arm_cm", "cm"},
{"left_forearm", "left_forearm_cm", "cm"},
{"right_forearm", "right_forearm_cm", "cm"},
{"left_thigh", "left_thigh_cm", "cm"},
{"right_thigh", "right_thigh_cm", "cm"},
{"left_calf", "left_calf_cm", "cm"},
{"right_calf", "right_calf_cm", "cm"},
};
static const MeasurementDefinition *measurement_definition(const char *id) {
size_t index;
for (index = 0U; index < sizeof(MEASUREMENTS) / sizeof(MEASUREMENTS[0]); ++index) {
if (strcmp(id, MEASUREMENTS[index].id) == 0) {
return &MEASUREMENTS[index];
}
}
return NULL;
}
static bool prepare(TrainlogDatabase *database, const char *sql, sqlite3_stmt **statement) {
return sqlite3_prepare_v2(database->connection, sql, -1, statement, NULL) == SQLITE_OK;
}
static bool bind_interval(sqlite3_stmt *statement, const TrainlogWebAnalysisQuery *query) {
if (query->period == TRAINLOG_WEB_ANALYSIS_ALL) {
if (sqlite3_bind_null(statement, 1) != SQLITE_OK) {
return false;
}
} else {
int64_t days = (int64_t)query->period;
int64_t start = query->reference_unix_second - ((days - 1) * SECONDS_PER_DAY);
if (sqlite3_bind_int64(statement, 1, start) != SQLITE_OK) {
return false;
}
}
return sqlite3_bind_int64(statement, 2, query->reference_unix_second) == SQLITE_OK;
}
static bool add_nullable_real(yyjson_mut_doc *document,
yyjson_mut_val *object,
const char *key,
sqlite3_stmt *statement,
int column) {
if (sqlite3_column_type(statement, column) == SQLITE_NULL) {
return yyjson_mut_obj_add_null(document, object, key);
}
return yyjson_mut_obj_add_real(document, object, key, sqlite3_column_double(statement, column));
}
static bool add_overview(TrainlogDatabase *database,
const TrainlogWebAnalysisQuery *query,
yyjson_mut_doc *document,
yyjson_mut_val *root) {
static const char SQL[] =
"WITH eligible AS (SELECT s.id,s.started_at,s.ended_at FROM sessions s WHERE "
"(?1 IS NULL OR unixepoch(s.started_at)>=?1) AND unixepoch(s.started_at)<=?2 AND "
"(EXISTS(SELECT 1 FROM session_exercises x JOIN performed_sets p ON "
"p.session_exercise_row_id=x.id WHERE x.session_row_id=s.id) OR EXISTS(SELECT 1 FROM "
"session_exercises x JOIN continuous_activity c ON c.session_exercise_row_id=x.id WHERE "
"x.session_row_id=s.id) OR EXISTS(SELECT 1 FROM session_exercises x JOIN max_results m ON "
"m.session_exercise_row_id=x.id WHERE x.session_row_id=s.id))) SELECT COUNT(*),"
"(SELECT COUNT(*) FROM performed_sets ps JOIN session_exercises se ON "
"se.id=ps.session_exercise_row_id JOIN eligible e ON e.id=se.session_row_id),"
"CASE WHEN COUNT(*)>0 AND COUNT(*)=SUM(CASE WHEN ended_at IS NOT NULL AND "
"unixepoch(ended_at)>=unixepoch(started_at) THEN 1 ELSE 0 END) THEN "
"SUM(unixepoch(ended_at)-unixepoch(started_at)) ELSE NULL END,"
"(SELECT COUNT(DISTINCT se.exercise_row_id) FROM session_exercises se JOIN eligible e "
"ON e.id=se.session_row_id WHERE EXISTS(SELECT 1 FROM performed_sets p WHERE "
"p.session_exercise_row_id=se.id) OR EXISTS(SELECT 1 FROM continuous_activity c WHERE "
"c.session_exercise_row_id=se.id) OR EXISTS(SELECT 1 FROM max_results m WHERE "
"m.session_exercise_row_id=se.id)) FROM eligible";
sqlite3_stmt *statement = NULL;
yyjson_mut_val *overview = yyjson_mut_obj(document);
bool ok;
if (overview == NULL || !prepare(database, SQL, &statement) ||
!bind_interval(statement, query) || sqlite3_step(statement) != SQLITE_ROW) {
if (statement != NULL) {
(void)sqlite3_finalize(statement);
}
return false;
}
ok = yyjson_mut_obj_add_sint(
document, overview, "sessions", sqlite3_column_int64(statement, 0)) &&
yyjson_mut_obj_add_sint(document, overview, "sets", sqlite3_column_int64(statement, 1)) &&
(sqlite3_column_type(statement, 2) == SQLITE_NULL
? yyjson_mut_obj_add_null(document, overview, "duration_seconds")
: yyjson_mut_obj_add_sint(
document, overview, "duration_seconds", sqlite3_column_int64(statement, 2))) &&
yyjson_mut_obj_add_sint(
document, overview, "distinct_exercises", sqlite3_column_int64(statement, 3)) &&
yyjson_mut_obj_add_val(document, root, "overview", overview) &&
sqlite3_step(statement) == SQLITE_DONE && sqlite3_finalize(statement) == SQLITE_OK;
return ok;
}
static bool add_activity(TrainlogDatabase *database,
const TrainlogWebAnalysisQuery *query,
yyjson_mut_doc *document,
yyjson_mut_val *root,
bool *partial) {
static const char SQL[] =
"SELECT substr(s.started_at,1,10),COUNT(DISTINCT s.id),COUNT(DISTINCT ps.id),"
"COUNT(DISTINCT se.id) FROM "
"sessions s LEFT JOIN session_exercises se ON se.session_row_id=s.id LEFT JOIN "
"performed_sets ps ON ps.session_exercise_row_id=se.id WHERE (?1 IS NULL OR "
"unixepoch(s.started_at)>=?1) AND unixepoch(s.started_at)<=?2 AND (ps.id IS NOT NULL OR "
"EXISTS(SELECT 1 FROM session_exercises x JOIN continuous_activity c ON "
"c.session_exercise_row_id=x.id WHERE x.session_row_id=s.id) OR EXISTS(SELECT 1 FROM "
"session_exercises x JOIN max_results m ON m.session_exercise_row_id=x.id WHERE "
"x.session_row_id=s.id)) GROUP BY substr(s.started_at,1,10) ORDER BY 1 DESC LIMIT ?3";
sqlite3_stmt *statement = NULL;
yyjson_mut_val *activity = yyjson_mut_arr(document);
size_t count = 0U;
int step;
if (activity == NULL || !prepare(database, SQL, &statement) ||
!bind_interval(statement, query) ||
sqlite3_bind_int64(statement, 3, (sqlite3_int64)(TRAINLOG_WEB_ANALYSIS_POINTS_MAX + 1U)) !=
SQLITE_OK) {
if (statement != NULL) {
(void)sqlite3_finalize(statement);
}
return false;
}
while ((step = sqlite3_step(statement)) == SQLITE_ROW) {
yyjson_mut_val *day;
if (count == TRAINLOG_WEB_ANALYSIS_POINTS_MAX) {
*partial = true;
continue;
}
day = yyjson_mut_obj(document);
if (day == NULL ||
!yyjson_mut_obj_add_strcpy(
document, day, "date", (const char *)sqlite3_column_text(statement, 0)) ||
!yyjson_mut_obj_add_sint(
document, day, "sessions", sqlite3_column_int64(statement, 1)) ||
!yyjson_mut_obj_add_sint(document, day, "sets", sqlite3_column_int64(statement, 2)) ||
!yyjson_mut_obj_add_sint(
document, day, "exercises", sqlite3_column_int64(statement, 3)) ||
!yyjson_mut_arr_add_val(activity, day)) {
(void)sqlite3_finalize(statement);
return false;
}
++count;
}
return step == SQLITE_DONE && sqlite3_finalize(statement) == SQLITE_OK &&
yyjson_mut_obj_add_val(document, root, "activity", activity);
}
/* WHY: the analysis entry point must progress from primary BODY ZONE to
* exercise before showing an individual curve. CONTRACT: measured_seconds is
* derived only from imported occurrence start/end timestamps. INVARIANT: no
* duration is inferred from sets, repetitions, rest targets or session time. */
static bool add_exercise_groups(TrainlogDatabase *database,
const TrainlogWebAnalysisQuery *query,
yyjson_mut_doc *document,
yyjson_mut_val *root) {
static const char SQL[] =
"SELECT z.zone_id,e.exercise_id,e.name,"
"COUNT(DISTINCT CASE WHEN s.id IS NOT NULL THEN se.id END),"
"COUNT(DISTINCT s.id),COUNT(DISTINCT ps.id),"
"COALESCE((SELECT SUM(unixepoch(tt.ended_at)-unixepoch(tt.started_at)) FROM "
"session_exercise_timeline tt JOIN sessions ts ON ts.session_id=tt.session_id WHERE "
"tt.exercise_id=e.exercise_id AND tt.ended_at>=tt.started_at AND (?1 IS NULL OR "
"unixepoch(ts.started_at)>=?1) AND unixepoch(ts.started_at)<=?2),0),"
"(SELECT COUNT(*) FROM session_exercise_timeline tt JOIN sessions ts ON "
"ts.session_id=tt.session_id WHERE tt.exercise_id=e.exercise_id AND "
"tt.ended_at>=tt.started_at AND (?1 IS NULL OR unixepoch(ts.started_at)>=?1) AND "
"unixepoch(ts.started_at)<=?2) "
"FROM exercise_body_zones z JOIN exercises e ON e.id=z.exercise_row_id AND "
"z.role='primary' LEFT JOIN session_exercises se ON se.exercise_row_id=e.id "
"LEFT JOIN sessions s ON s.id=se.session_row_id AND (?1 IS NULL OR "
"unixepoch(s.started_at)>=?1) AND unixepoch(s.started_at)<=?2 "
"LEFT JOIN performed_sets ps ON ps.session_exercise_row_id=se.id AND s.id IS NOT NULL "
"GROUP BY z.zone_id,e.exercise_id,e.name "
"HAVING COUNT(DISTINCT s.id)>0 ORDER BY z.zone_id,e.name COLLATE NOCASE,e.exercise_id";
sqlite3_stmt *statement = NULL;
yyjson_mut_val *groups = yyjson_mut_arr(document);
yyjson_mut_val *group = NULL;
yyjson_mut_val *exercises = NULL;
char current_zone[64] = "";
int step;
if (groups == NULL || !prepare(database, SQL, &statement) || !bind_interval(statement, query)) {
if (statement != NULL) {
(void)sqlite3_finalize(statement);
}
return false;
}
while ((step = sqlite3_step(statement)) == SQLITE_ROW) {
const char *zone_id = (const char *)sqlite3_column_text(statement, 0);
const TrainlogBodyZone *zone = trainlog_body_zone_catalog_lookup(zone_id);
yyjson_mut_val *exercise;
if (zone == NULL) {
(void)sqlite3_finalize(statement);
return false;
}
if (strcmp(current_zone, zone_id) != 0) {
if (group != NULL && !yyjson_mut_obj_add_val(document, group, "exercises", exercises)) {
(void)sqlite3_finalize(statement);
return false;
}
group = yyjson_mut_obj(document);
exercises = yyjson_mut_arr(document);
if (group == NULL || exercises == NULL ||
!yyjson_mut_obj_add_strcpy(document, group, "zone_id", zone_id) ||
!yyjson_mut_obj_add_strcpy(document, group, "label", zone->display_name) ||
!yyjson_mut_arr_add_val(groups, group)) {
(void)sqlite3_finalize(statement);
return false;
}
(void)snprintf(current_zone, sizeof(current_zone), "%s", zone_id);
}
exercise = yyjson_mut_obj(document);
if (exercise == NULL ||
!yyjson_mut_obj_add_strcpy(document,
exercise,
"exercise_id",
(const char *)sqlite3_column_text(statement, 1)) ||
!yyjson_mut_obj_add_strcpy(
document, exercise, "name", (const char *)sqlite3_column_text(statement, 2)) ||
!yyjson_mut_obj_add_sint(
document, exercise, "occurrences", sqlite3_column_int64(statement, 3)) ||
!yyjson_mut_obj_add_sint(
document, exercise, "sessions", sqlite3_column_int64(statement, 4)) ||
!yyjson_mut_obj_add_sint(
document, exercise, "sets", sqlite3_column_int64(statement, 5)) ||
!yyjson_mut_obj_add_sint(
document, exercise, "measured_seconds", sqlite3_column_int64(statement, 6)) ||
!yyjson_mut_obj_add_sint(
document, exercise, "measured_occurrences", sqlite3_column_int64(statement, 7)) ||
!yyjson_mut_arr_add_val(exercises, exercise)) {
(void)sqlite3_finalize(statement);
return false;
}
}
if (group != NULL && !yyjson_mut_obj_add_val(document, group, "exercises", exercises)) {
(void)sqlite3_finalize(statement);
return false;
}
return step == SQLITE_DONE && sqlite3_finalize(statement) == SQLITE_OK &&
yyjson_mut_obj_add_val(document, root, "exercise_groups", groups);
}
static bool add_exercises(TrainlogDatabase *database,
const TrainlogWebAnalysisQuery *query,
yyjson_mut_doc *document,
yyjson_mut_val *root,
char selected_id[64],
bool *partial) {
static const char LIST_SQL[] =
"SELECT e.exercise_id,e.name,e.tracking_mode,e.recording_mode FROM exercises e ORDER BY "
"e.name COLLATE NOCASE,e.exercise_id LIMIT ?1";
static const char RECENT_SQL[] =
"SELECT e.exercise_id FROM session_exercises se JOIN sessions s ON s.id=se.session_row_id "
"JOIN exercises e ON e.id=se.exercise_row_id WHERE (?1 IS NULL OR "
"unixepoch(s.started_at)>=?1) AND unixepoch(s.started_at)<=?2 AND "
"(EXISTS(SELECT 1 FROM performed_sets p WHERE p.session_exercise_row_id=se.id) OR "
"EXISTS(SELECT 1 FROM continuous_activity c WHERE c.session_exercise_row_id=se.id) OR "
"EXISTS(SELECT 1 FROM max_results m WHERE m.session_exercise_row_id=se.id)) ORDER BY "
"unixepoch(s.started_at) DESC,s.session_id DESC LIMIT 1";
sqlite3_stmt *statement = NULL;
yyjson_mut_val *items = yyjson_mut_arr(document);
size_t count = 0U;
int step;
if (query->exercise_id != NULL) {
(void)snprintf(selected_id, 64U, "%s", query->exercise_id);
} else if (prepare(database, RECENT_SQL, &statement) && bind_interval(statement, query)) {
if (sqlite3_step(statement) == SQLITE_ROW) {
(void)snprintf(selected_id, 64U, "%s", (const char *)sqlite3_column_text(statement, 0));
}
(void)sqlite3_finalize(statement);
statement = NULL;
} else {
if (statement != NULL) {
(void)sqlite3_finalize(statement);
}
return false;
}
if (items == NULL || !prepare(database, LIST_SQL, &statement) ||
sqlite3_bind_int64(statement, 1, TRAINLOG_WEB_ANALYSIS_EXERCISES_MAX + 1U) != SQLITE_OK) {
if (statement != NULL) {
(void)sqlite3_finalize(statement);
}
return false;
}
while ((step = sqlite3_step(statement)) == SQLITE_ROW) {
yyjson_mut_val *item;
if (count == TRAINLOG_WEB_ANALYSIS_EXERCISES_MAX) {
*partial = true;
continue;
}
item = yyjson_mut_obj(document);
if (item == NULL ||
!yyjson_mut_obj_add_strcpy(
document, item, "exercise_id", (const char *)sqlite3_column_text(statement, 0)) ||
!yyjson_mut_obj_add_strcpy(
document, item, "name", (const char *)sqlite3_column_text(statement, 1)) ||
!yyjson_mut_obj_add_strcpy(
document, item, "tracking_mode", (const char *)sqlite3_column_text(statement, 2)) ||
!yyjson_mut_obj_add_strcpy(document,
item,
"recording_mode",
(const char *)sqlite3_column_text(statement, 3)) ||
!yyjson_mut_arr_add_val(items, item)) {
(void)sqlite3_finalize(statement);
return false;
}
++count;
}
return step == SQLITE_DONE && sqlite3_finalize(statement) == SQLITE_OK &&
yyjson_mut_obj_add_val(document, root, "exercises", items);
}
static bool add_exercise_detail(TrainlogDatabase *database,
const TrainlogWebAnalysisQuery *query,
const char *exercise_id,
yyjson_mut_doc *document,
yyjson_mut_val *root,
bool *partial) {
static const char PROFILE_SQL[] =
"SELECT name,tracking_mode,recording_mode FROM exercises WHERE exercise_id=?1";
static const char POINT_SQL[] =
"SELECT s.session_id,s.started_at,se.load_mode,COUNT(ps.id),SUM(ps.reps),"
"SUM(ps.duration_seconds),CASE WHEN se.load_mode='external' THEN AVG(ps.weight_kg) ELSE "
"NULL END,CASE WHEN se.load_mode='external' AND COUNT(ps.id)>0 AND "
"COUNT(ps.id)=COUNT(ps.weight_kg) THEN SUM(ps.reps*ps.weight_kg) ELSE NULL END,"
"SUM(c.duration_seconds),SUM(c.distance_km),AVG(c.speed_kmh),m.max_weight_kg FROM "
"session_exercises se JOIN sessions s ON s.id=se.session_row_id JOIN exercises e ON "
"e.id=se.exercise_row_id LEFT JOIN performed_sets ps ON ps.session_exercise_row_id=se.id "
"LEFT JOIN continuous_activity c ON c.session_exercise_row_id=se.id LEFT JOIN max_results "
"m ON m.session_exercise_row_id=se.id WHERE e.exercise_id=?3 AND (?1 IS NULL OR "
"unixepoch(s.started_at)>=?1) AND unixepoch(s.started_at)<=?2 AND (ps.id IS NOT NULL OR "
"c.id IS NOT NULL OR m.session_exercise_row_id IS NOT NULL) GROUP BY se.id ORDER BY "
"unixepoch(s.started_at) DESC,s.session_id DESC LIMIT ?4";
sqlite3_stmt *statement = NULL;
yyjson_mut_val *detail = yyjson_mut_obj(document);
yyjson_mut_val *points = yyjson_mut_arr(document);
size_t count = 0U;
int step;
if (detail == NULL || points == NULL) {
return false;
}
if (exercise_id[0] == '\0') {
return yyjson_mut_obj_add_null(document, root, "exercise");
}
if (!prepare(database, PROFILE_SQL, &statement) ||
sqlite3_bind_text(statement, 1, exercise_id, -1, SQLITE_TRANSIENT) != SQLITE_OK) {
if (statement != NULL) {
(void)sqlite3_finalize(statement);
}
return false;
}
step = sqlite3_step(statement);
if (step == SQLITE_DONE) {
(void)sqlite3_finalize(statement);
return yyjson_mut_obj_add_null(document, root, "exercise");
}
if (step != SQLITE_ROW ||
!yyjson_mut_obj_add_strcpy(document, detail, "exercise_id", exercise_id) ||
!yyjson_mut_obj_add_strcpy(
document, detail, "name", (const char *)sqlite3_column_text(statement, 0)) ||
!yyjson_mut_obj_add_strcpy(
document, detail, "tracking_mode", (const char *)sqlite3_column_text(statement, 1)) ||
!yyjson_mut_obj_add_strcpy(
document, detail, "recording_mode", (const char *)sqlite3_column_text(statement, 2)) ||
sqlite3_step(statement) != SQLITE_DONE || sqlite3_finalize(statement) != SQLITE_OK) {
return false;
}
statement = NULL;
if (!prepare(database, POINT_SQL, &statement) || !bind_interval(statement, query) ||
sqlite3_bind_text(statement, 3, exercise_id, -1, SQLITE_TRANSIENT) != SQLITE_OK ||
sqlite3_bind_int64(statement, 4, TRAINLOG_WEB_ANALYSIS_POINTS_MAX + 1U) != SQLITE_OK) {
if (statement != NULL) {
(void)sqlite3_finalize(statement);
}
return false;
}
while ((step = sqlite3_step(statement)) == SQLITE_ROW) {
yyjson_mut_val *point;
if (count == TRAINLOG_WEB_ANALYSIS_POINTS_MAX) {
*partial = true;
continue;
}
point = yyjson_mut_obj(document);
if (point == NULL ||
!yyjson_mut_obj_add_strcpy(
document, point, "session_id", (const char *)sqlite3_column_text(statement, 0)) ||
!yyjson_mut_obj_add_strcpy(
document, point, "timestamp", (const char *)sqlite3_column_text(statement, 1)) ||
!yyjson_mut_obj_add_strcpy(
document, point, "load_mode", (const char *)sqlite3_column_text(statement, 2)) ||
!yyjson_mut_obj_add_sint(document, point, "sets", sqlite3_column_int64(statement, 3)) ||
!add_nullable_real(document, point, "reps", statement, 4) ||
!add_nullable_real(document, point, "set_duration_seconds", statement, 5) ||
!add_nullable_real(document, point, "external_load_kg", statement, 6) ||
!add_nullable_real(document, point, "external_volume_kg", statement, 7) ||
!add_nullable_real(document, point, "continuous_duration_seconds", statement, 8) ||
!add_nullable_real(document, point, "distance_km", statement, 9) ||
!add_nullable_real(document, point, "speed_kmh", statement, 10) ||
!add_nullable_real(document, point, "explicit_max_kg", statement, 11) ||
!yyjson_mut_arr_add_val(points, point)) {
(void)sqlite3_finalize(statement);
return false;
}
++count;
}
return step == SQLITE_DONE && sqlite3_finalize(statement) == SQLITE_OK &&
yyjson_mut_obj_add_val(document, detail, "points", points) &&
yyjson_mut_obj_add_val(document, root, "exercise", detail);
}
static bool add_zones(TrainlogDatabase *database,
const TrainlogWebAnalysisQuery *query,
yyjson_mut_doc *document,
yyjson_mut_val *root) {
static const char SQL[] =
"SELECT z.zone_id,COUNT(DISTINCT se.id),COUNT(DISTINCT ps.id) FROM sessions s JOIN "
"session_exercises se ON se.session_row_id=s.id JOIN exercise_body_zones z ON "
"z.exercise_row_id=se.exercise_row_id AND z.role='primary' LEFT JOIN performed_sets ps ON "
"ps.session_exercise_row_id=se.id WHERE (?1 IS NULL OR unixepoch(s.started_at)>=?1) AND "
"unixepoch(s.started_at)<=?2 AND (ps.id IS NOT NULL OR EXISTS(SELECT 1 FROM "
"continuous_activity c WHERE c.session_exercise_row_id=se.id) OR EXISTS(SELECT 1 FROM "
"max_results m WHERE m.session_exercise_row_id=se.id)) GROUP BY z.zone_id ORDER BY "
"COUNT(DISTINCT se.id) DESC,z.zone_id";
sqlite3_stmt *statement = NULL;
yyjson_mut_val *zones = yyjson_mut_arr(document);
int step;
if (zones == NULL || !prepare(database, SQL, &statement) || !bind_interval(statement, query)) {
if (statement != NULL) {
(void)sqlite3_finalize(statement);
}
return false;
}
while ((step = sqlite3_step(statement)) == SQLITE_ROW) {
const char *id = (const char *)sqlite3_column_text(statement, 0);
const TrainlogBodyZone *zone = trainlog_body_zone_catalog_lookup(id);
yyjson_mut_val *item = yyjson_mut_obj(document);
if (zone == NULL || item == NULL ||
!yyjson_mut_obj_add_strcpy(document, item, "zone_id", id) ||
!yyjson_mut_obj_add_strcpy(document, item, "label", zone->display_name) ||
!yyjson_mut_obj_add_sint(
document, item, "exposures", sqlite3_column_int64(statement, 1)) ||
!yyjson_mut_obj_add_sint(
document, item, "associated_sets", sqlite3_column_int64(statement, 2)) ||
!yyjson_mut_arr_add_val(zones, item)) {
(void)sqlite3_finalize(statement);
return false;
}
}
return step == SQLITE_DONE && sqlite3_finalize(statement) == SQLITE_OK &&
yyjson_mut_obj_add_val(document, root, "body_zones", zones);
}
static bool add_measurements(TrainlogDatabase *database,
const TrainlogWebAnalysisQuery *query,
yyjson_mut_doc *document,
yyjson_mut_val *root,
bool *partial) {
yyjson_mut_val *measurements = yyjson_mut_obj(document);
yyjson_mut_val *summaries = yyjson_mut_arr(document);
yyjson_mut_val *series = yyjson_mut_arr(document);
yyjson_mut_val *points = yyjson_mut_arr(document);
const MeasurementDefinition *selected = measurement_definition(query->measurement_metric);
size_t index;
if (measurements == NULL || summaries == NULL || series == NULL || points == NULL ||
selected == NULL) {
return false;
}
for (index = 0U; index < sizeof(MEASUREMENTS) / sizeof(MEASUREMENTS[0]); ++index) {
char sql[512];
sqlite3_stmt *statement = NULL;
yyjson_mut_val *summary = yyjson_mut_obj(document);
int written = snprintf(
sql,
sizeof(sql),
"WITH filtered AS (SELECT observed_at,observation_id,%s AS value FROM "
"body_observations WHERE %s IS NOT NULL AND (?1 IS NULL OR "
"unixepoch(observed_at)>=?1) AND unixepoch(observed_at)<=?2) SELECT COUNT(*),"
"(SELECT value FROM filtered ORDER BY unixepoch(observed_at),observation_id LIMIT 1),"
"(SELECT value FROM filtered ORDER BY unixepoch(observed_at) DESC,observation_id DESC "
"LIMIT 1) FROM filtered",
MEASUREMENTS[index].column,
MEASUREMENTS[index].column);
if (written < 0 || (size_t)written >= sizeof(sql) || summary == NULL ||
!prepare(database, sql, &statement) || !bind_interval(statement, query) ||
sqlite3_step(statement) != SQLITE_ROW ||
!yyjson_mut_obj_add_strcpy(document, summary, "metric", MEASUREMENTS[index].id) ||
!yyjson_mut_obj_add_strcpy(document, summary, "unit", MEASUREMENTS[index].unit) ||
!yyjson_mut_obj_add_sint(
document, summary, "count", sqlite3_column_int64(statement, 0)) ||
!add_nullable_real(document, summary, "first", statement, 1) ||
!add_nullable_real(document, summary, "last", statement, 2) ||
!(sqlite3_column_int64(statement, 0) < 2
? yyjson_mut_obj_add_null(document, summary, "delta")
: yyjson_mut_obj_add_real(document,
summary,
"delta",
sqlite3_column_double(statement, 2) -
sqlite3_column_double(statement, 1))) ||
!yyjson_mut_arr_add_val(summaries, summary) || sqlite3_step(statement) != SQLITE_DONE ||
sqlite3_finalize(statement) != SQLITE_OK) {
if (statement != NULL) {
(void)sqlite3_finalize(statement);
}
return false;
}
}
for (index = 0U; index < sizeof(MEASUREMENTS) / sizeof(MEASUREMENTS[0]); ++index) {
char sql[512];
sqlite3_stmt *statement = NULL;
yyjson_mut_val *metric_points = yyjson_mut_arr(document);
yyjson_mut_val *metric_series;
size_t count = 0U;
int step;
int written = snprintf(
sql,
sizeof(sql),
"SELECT observed_at,%s FROM body_observations WHERE %s IS NOT NULL "
"AND (?1 IS NULL OR unixepoch(observed_at)>=?1) AND unixepoch(observed_at)<=?2 "
"ORDER BY unixepoch(observed_at),observation_id LIMIT ?3",
MEASUREMENTS[index].column,
MEASUREMENTS[index].column);
if (metric_points == NULL || written < 0 || (size_t)written >= sizeof(sql) ||
!prepare(database, sql, &statement) || !bind_interval(statement, query) ||
sqlite3_bind_int64(statement, 3, TRAINLOG_WEB_ANALYSIS_POINTS_MAX + 1U) != SQLITE_OK) {
if (statement != NULL) {
(void)sqlite3_finalize(statement);
}
return false;
}
while ((step = sqlite3_step(statement)) == SQLITE_ROW) {
yyjson_mut_val *point;
if (count == TRAINLOG_WEB_ANALYSIS_POINTS_MAX) {
*partial = true;
continue;
}
point = yyjson_mut_obj(document);
if (point == NULL ||
!yyjson_mut_obj_add_strcpy(document,
point,
"timestamp",
(const char *)sqlite3_column_text(statement, 0)) ||
!yyjson_mut_obj_add_real(
document, point, "value", sqlite3_column_double(statement, 1)) ||
!yyjson_mut_arr_add_val(metric_points, point)) {
(void)sqlite3_finalize(statement);
return false;
}
++count;
}
if (step != SQLITE_DONE || sqlite3_finalize(statement) != SQLITE_OK) {
return false;
}
if (count < 2U) {
continue;
}
metric_series = yyjson_mut_obj(document);
if (metric_series == NULL ||
!yyjson_mut_obj_add_strcpy(document, metric_series, "metric", MEASUREMENTS[index].id) ||
!yyjson_mut_obj_add_strcpy(document, metric_series, "unit", MEASUREMENTS[index].unit) ||
!yyjson_mut_obj_add_val(document, metric_series, "points", metric_points) ||
!yyjson_mut_arr_add_val(series, metric_series)) {
return false;
}
}
{
char sql[512];
sqlite3_stmt *statement = NULL;
size_t count = 0U;
int step;
int written = snprintf(sql,
sizeof(sql),
"SELECT observed_at,%s FROM body_observations WHERE %s IS NOT NULL "
"AND (?1 IS NULL OR unixepoch(observed_at)>=?1) AND "
"unixepoch(observed_at)<=?2 ORDER BY unixepoch(observed_at) DESC,"
"observation_id DESC LIMIT ?3",
selected->column,
selected->column);
if (written < 0 || (size_t)written >= sizeof(sql) || !prepare(database, sql, &statement) ||
!bind_interval(statement, query) ||
sqlite3_bind_int64(statement, 3, TRAINLOG_WEB_ANALYSIS_POINTS_MAX + 1U) != SQLITE_OK) {
if (statement != NULL) {
(void)sqlite3_finalize(statement);
}
return false;
}
while ((step = sqlite3_step(statement)) == SQLITE_ROW) {
yyjson_mut_val *point;
if (count == TRAINLOG_WEB_ANALYSIS_POINTS_MAX) {
*partial = true;
continue;
}
point = yyjson_mut_obj(document);
if (point == NULL ||
!yyjson_mut_obj_add_strcpy(document,
point,
"timestamp",
(const char *)sqlite3_column_text(statement, 0)) ||
!yyjson_mut_obj_add_real(
document, point, "value", sqlite3_column_double(statement, 1)) ||
!yyjson_mut_arr_add_val(points, point)) {
(void)sqlite3_finalize(statement);
return false;
}
++count;
}
if (step != SQLITE_DONE || sqlite3_finalize(statement) != SQLITE_OK) {
return false;
}
}
return yyjson_mut_obj_add_val(document, measurements, "summaries", summaries) &&
yyjson_mut_obj_add_val(document, measurements, "series", series) &&
yyjson_mut_obj_add_strcpy(document, measurements, "selected_metric", selected->id) &&
yyjson_mut_obj_add_strcpy(document, measurements, "unit", selected->unit) &&
yyjson_mut_obj_add_val(document, measurements, "points", points) &&
yyjson_mut_obj_add_val(document, root, "measurements", measurements);
}
static bool
add_program(TrainlogDatabase *database, yyjson_mut_doc *document, yyjson_mut_val *root) {
static const char SQL[] =
/* WHY: imported dates are historical after Program rescheduling.
* CONTRACT: select one pending, non-ceded session with its current date.
* INVARIANT: a present planning row with NULL current_for stays undated. */
"WITH eligible AS (SELECT ps2.program_id,ps2.program_session_id,ps2.title,ps2.position,"
"CASE WHEN pp.program_session_id IS NULL THEN ps2.planned_for ELSE pp.current_for END "
"AS current_for FROM program_sessions ps2 LEFT JOIN program_session_planning pp ON "
"pp.program_session_id=ps2.program_session_id LEFT JOIN program_session_executions pe2 "
"ON pe2.program_session_id=ps2.program_session_id WHERE COALESCE(pp.state,'active')"
"!='ceded' AND COALESCE(pe2.state,'todo') NOT IN('completed','deleted')),"
"ranked AS (SELECT eligible.*,ROW_NUMBER() OVER (PARTITION BY program_id ORDER BY "
"CASE WHEN current_for IS NULL THEN 1 ELSE 0 END,current_for,position,"
"program_session_id) AS rank FROM eligible) "
"SELECT p.program_id,p.title,COUNT(ps.program_session_id),"
"SUM(CASE WHEN pe.state='completed' THEN 1 ELSE 0 END),"
"next.title,next.program_session_id,next.current_for "
"FROM programs p LEFT JOIN program_sessions ps ON ps.program_id=p.program_id LEFT JOIN "
"program_session_executions pe ON pe.program_session_id=ps.program_session_id LEFT JOIN "
"ranked next ON next.program_id=p.program_id AND next.rank=1 WHERE "
"p.state='active' AND p.deleted_at IS NULL GROUP BY p.program_id ORDER BY p.updated_at "
"DESC,p.program_id "
"LIMIT 1";
sqlite3_stmt *statement = NULL;
yyjson_mut_val *program = yyjson_mut_obj(document);
int step;
if (program == NULL || !prepare(database, SQL, &statement)) {
if (statement != NULL) {
(void)sqlite3_finalize(statement);
}
return false;
}
step = sqlite3_step(statement);
if (step == SQLITE_DONE) {
(void)sqlite3_finalize(statement);
return yyjson_mut_obj_add_null(document, root, "active_program");
}
if (step != SQLITE_ROW ||
!yyjson_mut_obj_add_strcpy(
document, program, "program_id", (const char *)sqlite3_column_text(statement, 0)) ||
!yyjson_mut_obj_add_strcpy(
document, program, "title", (const char *)sqlite3_column_text(statement, 1)) ||
!yyjson_mut_obj_add_sint(
document, program, "total_sessions", sqlite3_column_int64(statement, 2)) ||
!yyjson_mut_obj_add_sint(
document, program, "completed_sessions", sqlite3_column_int64(statement, 3)) ||
!(sqlite3_column_type(statement, 4) == SQLITE_NULL
? yyjson_mut_obj_add_null(document, program, "next_session_title")
: yyjson_mut_obj_add_strcpy(document,
program,
"next_session_title",
(const char *)sqlite3_column_text(statement, 4))) ||
!(sqlite3_column_type(statement, 5) == SQLITE_NULL
? yyjson_mut_obj_add_null(document, program, "next_session_id")
: yyjson_mut_obj_add_strcpy(document,
program,
"next_session_id",
(const char *)sqlite3_column_text(statement, 5))) ||
!(sqlite3_column_type(statement, 6) == SQLITE_NULL
? yyjson_mut_obj_add_null(document, program, "next_session_planned_for")
: yyjson_mut_obj_add_strcpy(document,
program,
"next_session_planned_for",
(const char *)sqlite3_column_text(statement, 6))) ||
!yyjson_mut_obj_add_val(document, root, "active_program", program) ||
sqlite3_step(statement) != SQLITE_DONE || sqlite3_finalize(statement) != SQLITE_OK) {
return false;
}
return true;
}
TrainlogStatus trainlog_web_analysis_json(TrainlogDatabase *database,
const TrainlogWebAnalysisQuery *query,
char *output,
size_t capacity,
size_t *output_size) {
yyjson_mut_doc *document;
yyjson_mut_val *root;
yyjson_mut_val *meta;
char selected_id[64] = "";
bool partial = false;
char *json;
size_t json_size;
yyjson_write_err error;
if (database == NULL || query == NULL || output == NULL || capacity == 0U ||
output_size == NULL || query->reference_unix_second < 0 ||
(query->period != TRAINLOG_WEB_ANALYSIS_7_DAYS &&
query->period != TRAINLOG_WEB_ANALYSIS_14_DAYS &&
query->period != TRAINLOG_WEB_ANALYSIS_21_DAYS &&
query->period != TRAINLOG_WEB_ANALYSIS_30_DAYS &&
query->period != TRAINLOG_WEB_ANALYSIS_90_DAYS &&
query->period != TRAINLOG_WEB_ANALYSIS_ALL) ||
query->measurement_metric == NULL ||
measurement_definition(query->measurement_metric) == NULL ||
(query->exercise_id != NULL && strlen(query->exercise_id) >= sizeof(selected_id))) {
return TRAINLOG_STATUS_INVALID_ARGUMENT;
}
*output_size = 0U;
output[0] = '\0';
document = yyjson_mut_doc_new(NULL);
root = document == NULL ? NULL : yyjson_mut_obj(document);
meta = document == NULL ? NULL : yyjson_mut_obj(document);
if (document == NULL || root == NULL || meta == NULL) {
yyjson_mut_doc_free(document);
return TRAINLOG_STATUS_SYSTEM_ERROR;
}
yyjson_mut_doc_set_root(document, root);
if (!yyjson_mut_obj_add_uint(document, root, "api_version", 1U) ||
!yyjson_mut_obj_add_strcpy(document,
root,
"period",
query->period == TRAINLOG_WEB_ANALYSIS_ALL ? "all"
: query->period == TRAINLOG_WEB_ANALYSIS_7_DAYS ? "7d"
: query->period == TRAINLOG_WEB_ANALYSIS_14_DAYS ? "14d"
: query->period == TRAINLOG_WEB_ANALYSIS_21_DAYS ? "21d"
: query->period == TRAINLOG_WEB_ANALYSIS_30_DAYS ? "30d"
: "90d") ||
!add_overview(database, query, document, root) ||
!add_activity(database, query, document, root, &partial) ||
!add_exercise_groups(database, query, document, root) ||
!add_exercises(database, query, document, root, selected_id, &partial) ||
!add_exercise_detail(database, query, selected_id, document, root, &partial) ||
!add_zones(database, query, document, root) ||
!add_measurements(database, query, document, root, &partial) ||
!add_program(database, document, root) ||
!yyjson_mut_obj_add_bool(document, meta, "partial", partial) ||
!yyjson_mut_obj_add_sint(
document, meta, "reference_unix_second", query->reference_unix_second) ||
!yyjson_mut_obj_add_val(document, root, "meta", meta)) {
yyjson_mut_doc_free(document);
return TRAINLOG_STATUS_DATABASE_ERROR;
}
json = yyjson_mut_write_opts(document, YYJSON_WRITE_NOFLAG, NULL, &json_size, &error);
yyjson_mut_doc_free(document);
if (json == NULL || json_size + 2U > capacity) {
free(json);
return TRAINLOG_STATUS_SYSTEM_ERROR;
}
(void)memcpy(output, json, json_size);
output[json_size] = '\n';
output[json_size + 1U] = '\0';
*output_size = json_size + 1U;
free(json);
return TRAINLOG_STATUS_OK;
}
Reference in a new issue View git blame Copy permalink