Workout templates (#920)

* feat(frontend): change name of route

* feat(backend): change path of user uploads

* build(backend): add `mime_guess` deps

* fix(backend): make correct put request from backend

* ci: switch to using bun

* ci: remove references to yarn

* Revert "ci: switch to using bun"

This reverts commit c2f991e.

* Revert "ci: remove references to yarn"

This reverts commit dd5bfa6.

* feat(frontend): adapt to allow creating templates

* fix(frontend): change dynamically

* fix(backend): remove alias

* feat(database): remove workout comment from top level

* feat(backend): adapt to new database schema

* chore(frontend): adapt to new gql schema

* fix(frontend): duplicate comment as well

* refactor(backend): generate default argon

* fix(frontend): hide menu entry when creating template

* refactor(backend): to account for new workout templates

* fix(backend): skip correct input

* chore(frontend): adapt to new gql schema

* feat(*): use better types

* fix(frontend): remove heading

* feat(backend): make fields nullable

* chore(frontend): adapt to new gql schema

* fix(frontend): change name of btn

* feat(frontend): add conditionals

* chore(frontend): remove title

* chore(frontend): change page title

* fix(frontend): send workout create event only when it actually happens

* refactor(frontend): use functions

* feat(frontend): adapt to new templates

* fix(frontend): add more clarifying text

* feat(backend): make more fields nullanble

* feat(*): change lot to be non nullable

* fix(backend): do not serialize nulls

* refactor(frontend): change name of module

* feat(frontend): start adjusting for new endpoint

* feat(frontend): duplicate workout accurately

* feat(graphql): extract information into fragment

* fix(frontend): invalidate query correctly

* fix(frontend): extract type

* feat(frontend): hide done on when not applicable

* refactor(frontend): remove duplicated code

* fix(frontend): show done on always

* fix(frontend): no conditional

* feat(frontend): enhance cookie for storing workout

* refactor(frontend): fn to perform decision

* fix(frontend): change word

* fix(backend): remove useless extra line

* fix(frontend): change text when disabled

* feat(frontend): make workout list page dynamic

* fix(frontend): display dynamic title

* feat(frontend): make page more dynamic

* feat(frontend): make page more accepting to changes

* feat(frontend): make stuff plural

* feat(frontend): redirect to correct page

* fix(frontend): inline invariant

* refactor(backend): change name of query

* chore(frontend): adapt to new gql schema

* fix(frontend): make plural

* fix(frontend): more changes

* feat(database): remove `is_demo` column from user

* feat(backend): adapt to new gql schema

* feat(frontend): adapt to new gql schema

Author: IgnisDa

Cargo.lock

@@ -49,6 +49,7 @@ lettre = { version = "=0.11.7", features = [
     "builder",
 ], default-features = false }
 markdown = "=1.0.0-alpha.18"
+mime_guess = "=2.0.5"
 nanoid = { workspace = true }
 openidconnect = "=3.5.0"
 paginate = "=1.1.11"

apps/backend/Cargo.toml

@@ -12,10 +12,6 @@ use serde::{Deserialize, Serialize};
 
 use crate::users::UserPreferences;
 
-fn get_hasher() -> Argon2<'static> {
-    Argon2::default()
-}
-
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize, SimpleObject)]
 #[graphql(name = "User")]
 #[sea_orm(table_name = "user")]
@@ -27,7 +23,6 @@ pub struct Model {
     pub password: Option<String>,
     pub oidc_issuer_id: Option<String>,
     pub created_on: DateTimeUtc,
-    pub is_demo: Option<bool>,
     pub lot: UserLot,
     pub is_disabled: Option<bool>,
     #[graphql(skip)]
@@ -157,7 +152,7 @@ impl ActiveModelBehavior for ActiveModel {
             let cloned_password = self.password.clone().unwrap();
             if let Some(password) = cloned_password {
                 let salt = SaltString::generate(&mut OsRng);
-                let password_hash = get_hasher()
+                let password_hash = Argon2::default()
                     .hash_password(password.as_bytes(), &salt)
                     .map_err(|_| DbErr::Custom("Unable to hash password".to_owned()))?
                     .to_string();

apps/backend/src/entities/user.rs

@@ -34,27 +34,33 @@ pub struct Model {
     pub summary: WorkoutSummary,
     pub information: WorkoutInformation,
     pub name: String,
-    pub comment: Option<String>,
 }
 
 #[async_trait]
 impl GraphqlRepresentation for Model {
-    async fn graphql_representation(self, file_storage_service: &Arc<FileStorageService>) -> Result<Self> {
+    async fn graphql_representation(
+        self,
+        file_storage_service: &Arc<FileStorageService>,
+    ) -> Result<Self> {
         let mut cnv_workout = self.clone();
-        for image in cnv_workout.information.assets.images.iter_mut() {
-            *image = file_storage_service.get_presigned_url(image.clone()).await;
-        }
-        for video in cnv_workout.information.assets.videos.iter_mut() {
-            *video = file_storage_service.get_presigned_url(video.clone()).await;
-        }
-        for exercise in cnv_workout.information.exercises.iter_mut() {
-            for image in exercise.assets.images.iter_mut() {
+        if let Some(ref mut assets) = cnv_workout.information.assets {
+            for image in assets.images.iter_mut() {
                 *image = file_storage_service.get_presigned_url(image.clone()).await;
             }
-            for video in exercise.assets.videos.iter_mut() {
+            for video in assets.videos.iter_mut() {
                 *video = file_storage_service.get_presigned_url(video.clone()).await;
             }
         }
+        for exercise in cnv_workout.information.exercises.iter_mut() {
+            if let Some(ref mut assets) = exercise.assets {
+                for image in assets.images.iter_mut() {
+                    *image = file_storage_service.get_presigned_url(image.clone()).await;
+                }
+                for video in assets.videos.iter_mut() {
+                    *video = file_storage_service.get_presigned_url(video.clone()).await;
+                }
+            }
+        }
         Ok(cnv_workout)
     }
 }

apps/backend/src/entities/workout.rs

@@ -4,7 +4,10 @@ use apalis::prelude::MessageQueue;
 use async_graphql::{Context, Error, Object, Result, SimpleObject};
 use chrono::{DateTime, Utc};
 use nanoid::nanoid;
-use reqwest::{Body, Client};
+use reqwest::{
+    header::{CONTENT_LENGTH, CONTENT_TYPE},
+    Body, Client,
+};
 use rs_utils::IsFeatureEnabled;
 use sea_orm::prelude::DateTimeUtc;
 use serde::{Deserialize, Serialize};
@@ -146,7 +149,7 @@ impl ExporterService {
         writer.end_object().unwrap();
         writer.finish_document().unwrap();
         let ended_at = Utc::now();
-        let (_, url) = self
+        let (_key, url) = self
             .file_storage_service
             .get_presigned_put_url(
                 export_path
@@ -155,7 +158,7 @@ impl ExporterService {
                     .to_str()
                     .unwrap()
                     .to_string(),
-                format!("exports/user__{}", user_id),
+                format!("exports/{}", user_id),
                 false,
                 Some(HashMap::from([
                     ("started_at".to_string(), started_at.to_rfc2822()),
@@ -168,11 +171,15 @@ impl ExporterService {
             )
             .await;
         let file = File::open(&export_path).await.unwrap();
+        let content_length = file.metadata().await.unwrap().len();
+        let content_type = mime_guess::from_path(&export_path).first_or_octet_stream();
         let stream = FramedRead::new(file, BytesCodec::new());
         let body = Body::wrap_stream(stream);
         let client = Client::new();
         client
             .put(url)
+            .header(CONTENT_TYPE, content_type.to_string())
+            .header(CONTENT_LENGTH, content_length)
             .header("x-amz-meta-started_at", started_at.to_rfc2822())
             .header("x-amz-meta-ended_at", ended_at.to_rfc2822())
             .header(
@@ -193,7 +200,7 @@ impl ExporterService {
         let mut resp = vec![];
         let objects = self
             .file_storage_service
-            .list_objects_at_prefix(format!("exports/user__{}", user_id))
+            .list_objects_at_prefix(format!("exports/{}", user_id))
             .await;
         for object in objects {
             let url = self

apps/backend/src/exporter.rs

@@ -198,11 +198,11 @@ impl UserWorkoutInput {
                     totals.weight = Some(we * re);
                 }
                 let mut value = WorkoutSetRecord {
-                    totals,
                     lot: set.lot,
                     actual_rest_time,
+                    totals: Some(totals),
                     note: set.note.clone(),
-                    personal_bests: vec![],
+                    personal_bests: Some(vec![]),
                     confirmed_at: set.confirmed_at,
                     statistic: set.statistic.clone(),
                 };
@@ -244,32 +244,38 @@ impl UserWorkoutInput {
                     let workout_set =
                         workout.information.exercises[r.exercise_idx].sets[r.set_idx].clone();
                     if set.get_personal_best(best_type) > workout_set.get_personal_best(best_type) {
-                        set.personal_bests.push(*best_type);
+                        if let Some(ref mut set_personal_bests) = set.personal_bests {
+                            set_personal_bests.push(*best_type);
+                        }
                         total.personal_bests_achieved += 1;
                     }
                 } else {
-                    set.personal_bests.push(*best_type);
+                    if let Some(ref mut set_personal_bests) = set.personal_bests {
+                        set_personal_bests.push(*best_type);
+                    }
                     total.personal_bests_achieved += 1;
                 }
             }
             workout_totals.push(total.clone());
             for (set_idx, set) in sets.iter().enumerate() {
-                for best in set.personal_bests.iter() {
-                    let to_insert_record = ExerciseBestSetRecord {
-                        workout_id: id.clone(),
-                        exercise_idx,
-                        set_idx,
-                    };
-                    if let Some(record) = personal_bests.iter_mut().find(|pb| pb.lot == *best) {
-                        let mut data =
-                            LengthVec::from_vec_and_length(record.sets.clone(), save_history);
-                        data.push_front(to_insert_record);
-                        record.sets = data.into_vec();
-                    } else {
-                        personal_bests.push(UserToExerciseBestSetExtraInformation {
-                            lot: *best,
-                            sets: vec![to_insert_record],
-                        });
+                if let Some(set_personal_bests) = &set.personal_bests {
+                    for best in set_personal_bests.iter() {
+                        let to_insert_record = ExerciseBestSetRecord {
+                            workout_id: id.clone(),
+                            exercise_idx,
+                            set_idx,
+                        };
+                        if let Some(record) = personal_bests.iter_mut().find(|pb| pb.lot == *best) {
+                            let mut data =
+                                LengthVec::from_vec_and_length(record.sets.clone(), save_history);
+                            data.push_front(to_insert_record);
+                            record.sets = data.into_vec();
+                        } else {
+                            personal_bests.push(UserToExerciseBestSetExtraInformation {
+                                lot: *best,
+                                sets: vec![to_insert_record],
+                            });
+                        }
                     }
                 }
             }
@@ -286,40 +292,40 @@ impl UserWorkoutInput {
             exercises.push((
                 db_ex.lot,
                 ProcessedExercise {
-                    name: db_ex.id,
-                    lot: db_ex.lot,
                     sets,
+                    lot: db_ex.lot,
+                    name: db_ex.id,
+                    total: Some(total),
                     notes: ex.notes.clone(),
                     rest_time: ex.rest_time,
                     assets: ex.assets.clone(),
                     superset_with: ex.superset_with.clone(),
-                    total,
                 },
             ));
         }
-        let summary_total = workout_totals.into_iter().sum();
+        let summary_total = Some(workout_totals.into_iter().sum());
         let model = workout::Model {
             id,
             end_time: input.end_time,
             start_time: input.start_time,
             repeated_from: input.repeated_from,
             user_id: user_id.clone(),
             name: input.name,
-            comment: input.comment,
             summary: WorkoutSummary {
                 total: summary_total,
                 exercises: exercises
                     .iter()
                     .map(|(lot, e)| WorkoutSummaryExercise {
-                        num_sets: e.sets.len(),
+                        lot: Some(*lot),
                         id: e.name.clone(),
-                        lot: *lot,
-                        best_set: e.sets[get_best_set_index(&e.sets).unwrap()].clone(),
+                        num_sets: e.sets.len(),
+                        best_set: Some(e.sets[get_best_set_index(&e.sets).unwrap()].clone()),
                     })
                     .collect(),
             },
             information: WorkoutInformation {
-                assets: input.assets.clone(),
+                comment: input.comment,
+                assets: input.assets,
                 exercises: exercises.into_iter().map(|(_, ex)| ex).collect(),
             },
         };

apps/backend/src/fitness/logic.rs

@@ -141,14 +141,14 @@ impl ExerciseQuery {
     }
 
     /// Get a paginated list of workouts done by the user.
-    async fn user_workout_list(
+    async fn user_workouts_list(
         &self,
         gql_ctx: &Context<'_>,
         input: SearchInput,
     ) -> Result<SearchResults<WorkoutListItem>> {
         let service = gql_ctx.data_unchecked::<Arc<ExerciseService>>();
         let user_id = self.user_id_from_ctx(gql_ctx).await?;
-        service.user_workout_list(user_id, input).await
+        service.user_workouts_list(user_id, input).await
     }
 
     /// Get details about an exercise.
@@ -403,7 +403,7 @@ impl ExerciseService {
         Ok(resp)
     }
 
-    async fn user_workout_list(
+    async fn user_workouts_list(
         &self,
         user_id: String,
         input: SearchInput,
@@ -793,9 +793,8 @@ impl ExerciseService {
     }
 
     pub async fn delete_user_workout(&self, user_id: String, workout_id: String) -> Result<bool> {
-        if let Some(wkt) = Workout::find()
+        if let Some(wkt) = Workout::find_by_id(workout_id)
             .filter(workout::Column::UserId.eq(&user_id))
-            .filter(workout::Column::Id.eq(workout_id))
             .one(&self.db)
             .await?
         {
@@ -829,12 +828,13 @@ impl ExerciseService {
 
     pub fn db_workout_to_workout_input(&self, user_workout: workout::Model) -> UserWorkoutInput {
         UserWorkoutInput {
-            id: Some(user_workout.id),
             name: user_workout.name,
-            comment: user_workout.comment,
+            id: Some(user_workout.id),
+            end_time: user_workout.end_time,
             start_time: user_workout.start_time,
+            assets: user_workout.information.assets,
             repeated_from: user_workout.repeated_from,
-            end_time: user_workout.end_time,
+            comment: user_workout.information.comment,
             exercises: user_workout
                 .information
                 .exercises
@@ -857,7 +857,6 @@ impl ExerciseService {
                     superset_with: e.superset_with,
                 })
                 .collect(),
-            assets: user_workout.information.assets,
         }
     }
 

apps/backend/src/fitness/resolver.rs

@@ -12,8 +12,7 @@ use serde::{Deserialize, Serialize};
 use crate::{
     importer::{utils, DeployStrongAppImportInput, ImportResult},
     models::fitness::{
-        EntityAssets, SetLot, UserExerciseInput, UserWorkoutInput, UserWorkoutSetRecord,
-        WorkoutSetStatistic,
+        SetLot, UserExerciseInput, UserWorkoutInput, UserWorkoutSetRecord, WorkoutSetStatistic,
     },
 };
 
@@ -99,8 +98,8 @@ pub async fn import(
                 exercise_id: target_exercise.target_name.clone(),
                 sets,
                 notes,
+                assets: None,
                 rest_time: None,
-                assets: EntityAssets::default(),
                 superset_with: vec![],
             });
             sets = vec![];
@@ -130,7 +129,7 @@ pub async fn import(
                 start_time: ndt,
                 end_time: ndt + workout_duration,
                 exercises,
-                assets: EntityAssets::default(),
+                assets: None,
             });
             exercises = vec![];
         }