WT1.1.10 compact test, paralell test

lib/bloc/exercise_control/exercise_control_bloc.dart

@@ -13,7 +13,6 @@ class ExerciseControlBloc extends Bloc<ExerciseControlEvent, ExerciseControlStat
   final TimerBloc timerBloc;
   final ExerciseRepository exerciseRepository;
   final bool readonly;
-  final double percentToCalculate;
   int step = 1;
 
   double initialRM;
@@ -29,18 +28,18 @@ class ExerciseControlBloc extends Bloc<ExerciseControlEvent, ExerciseControlStat
   double scrollOffset = 0;
 
   @override
-  ExerciseControlBloc({this.exerciseRepository, this.readonly, this.percentToCalculate, @required this.timerBloc})
-      : super(ExerciseControlInitial()) {
+  ExerciseControlBloc({this.exerciseRepository, this.readonly, @required this.timerBloc}) : super(ExerciseControlInitial()) {
+    print("Exercise ${exerciseRepository.exercise.toJson()}");
     oneRepQuantity = exerciseRepository.exercise.quantity;
     oneRepUnitQuantity = exerciseRepository.exercise.unitQuantity;
     initialRM = this.calculate1RM(percent75: false);
     unitQuantity = this.calculate1RM(percent75: true).roundToDouble();
-    quantity = percentToCalculate == 0.75 ? 12 : 35;
+    quantity = 12;
     origQuantity = quantity;
 
     exerciseRepository.setUnitQuantity(unitQuantity);
     exerciseRepository.setQuantity(quantity);
-    print("init quantity: " + quantity.toString());
+
     timerBloc.add(TimerStart(duration: 300));
   }
 
@@ -49,7 +48,6 @@ class ExerciseControlBloc extends Bloc<ExerciseControlEvent, ExerciseControlStat
     try {
       if (event is ExerciseControlLoad) {
         yield ExerciseControlLoading();
-        print("init quantity: " + quantity.toString());
         step = 1;
         yield ExerciseControlReady();
       } else if (event is ExerciseControlQuantityChange) {
@@ -83,9 +81,8 @@ class ExerciseControlBloc extends Bloc<ExerciseControlEvent, ExerciseControlStat
           }
           exerciseRepository.end = DateTime.now();
           await exerciseRepository.addExercise();
+          exerciseRepository.initExercise();
 
-          exerciseRepository.setQuantity(quantity);
-          exerciseRepository.exercise.exerciseId = null;
           step <= 3 ? timerBloc.add(TimerStart(duration: 300)) : timerBloc.add(TimerEnd());
         }
         yield ExerciseControlReady();
@@ -110,7 +107,7 @@ class ExerciseControlBloc extends Bloc<ExerciseControlEvent, ExerciseControlStat
     print("Weight: $weight repeat: $repeat,  $rmWendler, Oconner: $rmOconner");
     double average = (rmWendler + rmOconner) / 2;
 
-    return percent75 ? average * this.percentToCalculate : average;
+    return percent75 ? average * 0.75 : average;
   }
 
   int calculateQuantityByUnitQuantity() {

lib/bloc/exercise_execute_plan_add/exercise_execute_plan_add_bloc.dart

@@ -74,6 +74,7 @@ class ExerciseExecutePlanAddBloc extends Bloc<ExerciseExecutePlanAddEvent, Exerc
         exerciseRepository.exercise.unit = workoutTree.exerciseType.unit;
         workoutTree.executed = true;
         await exerciseRepository.addExercise();
+        exerciseRepository.initExercise();
         Track().track(TrackingEvent.my_exercise_plan_execute_save);
         step++;
         scrollOffset = step * 200.0;

lib/bloc/exercise_new/exercise_new_bloc.dart

@@ -1,7 +1,6 @@
 import 'dart:async';
 import 'package:aitrainer_app/bloc/menu/menu_bloc.dart';
 import 'package:aitrainer_app/model/cache.dart';
-import 'package:aitrainer_app/model/exercise_ability.dart';
 import 'package:aitrainer_app/model/exercise_type.dart';
 import 'package:aitrainer_app/model/fitness_state.dart';
 import 'package:aitrainer_app/repository/customer_repository.dart';
@@ -62,6 +61,7 @@ class ExerciseNewBloc extends Bloc<ExerciseNewEvent, ExerciseNewState> with Logg
     exerciseRepository.exerciseType = exerciseType;
     exerciseRepository.setUnit(exerciseType.unit);
     exerciseRepository.setUnitQuantity(unitQuantity);
+    exerciseRepository.setQuantity(quantity);
     exerciseRepository.exercise.exercisePlanDetailId = 0;
     exerciseRepository.start = DateTime.now();
     if (Cache().userLoggedIn != null) {
@@ -74,30 +74,6 @@ class ExerciseNewBloc extends Bloc<ExerciseNewEvent, ExerciseNewState> with Logg
     if (exerciseType.unit == "second") {
       stopWatchTimer.rawTime.listen((value) => {timerValue = value, this.setQuantity((value / 1000).toDouble())});
     }
-    this.setExerciseTask(init: true);
-  }
-
-  String setExerciseTask({bool init = false}) {
-    if (this.exerciseRepository.exerciseType == null) {
-      print("WTF, exerciseType is null");
-      return "";
-    }
-    if (this.exerciseRepository.exerciseType.unit != "second") {
-      if (menuBloc.ability.toString() == ExerciseAbility.oneRepMax.toString()) {
-        this.exerciseTask = "Please take a relative bigger weight and repeat 12-20 times";
-        if (init == true) {
-          this.setQuantity(12);
-        }
-      } else if (this.exerciseRepository.exerciseType.isEndurance() &&
-          menuBloc.ability.toString() == ExerciseAbility.endurance.toString() &&
-          exerciseRepository.exerciseType.unitQuantity == "1") {
-        this.exerciseTask = "Please take a medium weight and repeat 20-30 times";
-        if (init == true) {
-          this.setQuantity(20);
-        }
-      }
-    }
-    return this.exerciseTask;
   }
 
   void setQuantity(double quantity) {
@@ -171,10 +147,11 @@ class ExerciseNewBloc extends Bloc<ExerciseNewEvent, ExerciseNewState> with Logg
         yield ExerciseNewLoading();
         exerciseRepository.end = DateTime.now();
         await exerciseRepository.addExercise();
+        exerciseRepository.initExercise();
         menuBloc.add(MenuTreeDown(parent: 0));
         Cache().initBadges();
         Track().track(TrackingEvent.exercise_new, eventValue: exerciseRepository.exerciseType.name);
-        yield ExerciseNewReady();
+        yield ExerciseNewSaved();
       } else if (event is ExerciseNewBMIAnimate) {
         yield ExerciseNewLoading();
         yield ExerciseNewReady();

lib/bloc/exercise_new/exercise_new_state.dart

@@ -20,10 +20,14 @@ class ExerciseNewReady extends ExerciseNewState {
   const ExerciseNewReady();
 }
 
+class ExerciseNewSaved extends ExerciseNewState {
+  const ExerciseNewSaved();
+}
+
 class ExerciseNewError extends ExerciseNewState {
   final String message;
   const ExerciseNewError({this.message});
 
   @override
   List<Object> get props => [message];
-}
+}

lib/bloc/menu/menu_bloc.dart

@@ -166,7 +166,7 @@ class MenuBloc extends Bloc<MenuEvent, MenuState> with Trans, Logging {
 
   void setAbility(String name) {
     switch (name) {
-      case "One Rep Max":
+      case "Muscle Build / Shape Toning":
         ability = ExerciseAbility.oneRepMax;
         break;
       case "Endurance":
@@ -176,13 +176,13 @@ class MenuBloc extends Bloc<MenuEvent, MenuState> with Trans, Logging {
         ability = ExerciseAbility.running;
         break;
       case "Test Center":
-        ability = ExerciseAbility.mini_test;
+        ability = ExerciseAbility.mini_test_set;
         break;
       case "My Body":
         ability = ExerciseAbility.none;
         break;
     }
-    log("Ability: " + ability.toString() + " name:" + name);
+    log("Ability: " + ability.toString() + " name: " + name);
   }
 
   Future<void> getImages(LinkedHashMap<String, WorkoutMenuTree> branch) async {
@@ -231,7 +231,6 @@ class MenuBloc extends Bloc<MenuEvent, MenuState> with Trans, Logging {
         }
       }
     });
-
     return filtered;
   }
 }

lib/bloc/settings/settings_bloc.dart

@@ -37,7 +37,6 @@ class SettingsBloc extends Bloc<SettingsEvent, SettingsState> with Logging {
     if (event is SettingsChangeLanguage) {
       yield SettingsLoading();
       await _changeLang(event.language);
-      Track().track(TrackingEvent.settings_lang);
       yield SettingsReady(_locale);
     } else if (event is SettingsGetLanguage) {
       await AppLanguage().fetchLocale();
@@ -47,7 +46,7 @@ class SettingsBloc extends Bloc<SettingsEvent, SettingsState> with Logging {
       yield SettingsLoading();
       final bool live = event.live;
       Cache().setServer(live);
-      Track().track(TrackingEvent.settings_server);
+      Track().track(TrackingEvent.settings_server, eventValue: live.toString());
       yield SettingsReady(_locale);
     } else if (event is SettingsSetHardware) {
       yield SettingsLoading();

lib/bloc/test_set_control/test_set_control_bloc.dart

@@ -0,0 +1,69 @@
+import 'dart:async';
+
+import 'package:aitrainer_app/bloc/test_set_execute/test_set_execute_bloc.dart';
+import 'package:aitrainer_app/model/cache.dart';
+import 'package:aitrainer_app/model/exercise.dart';
+import 'package:aitrainer_app/model/exercise_plan_detail.dart';
+import 'package:aitrainer_app/model/exercise_type.dart';
+import 'package:aitrainer_app/repository/exercise_repository.dart';
+import 'package:bloc/bloc.dart';
+import 'package:equatable/equatable.dart';
+
+part 'test_set_control_event.dart';
+part 'test_set_control_state.dart';
+
+class TestSetControlBloc extends Bloc<TestSetControlEvent, TestSetControlState> {
+  final ExercisePlanDetail exercisePlanDetail;
+  final TestSetExecuteBloc executeBloc;
+  final ExerciseType exerciseType;
+  final ExerciseRepository exerciseRepository = ExerciseRepository();
+  TestSetControlBloc({this.exercisePlanDetail, this.executeBloc, this.exerciseType}) : super(TestSetControlInitial()) {
+    initBloc();
+  }
+
+  void initBloc() {
+    if (exercisePlanDetail.exerciseType.unitQuantity != null) {
+      oneRepMax = executeBloc.calculate1RM(exercisePlanDetail.exercises.last.unitQuantity, exercisePlanDetail.exercises.last.quantity);
+      initQuantity = 12;
+      quantity = initQuantity;
+      initUnitQuantity = oneRepMax * 0.75;
+      unitQuantity = initUnitQuantity;
+    }
+    step = exercisePlanDetail.exercises.length;
+    exerciseRepository.customer = Cache().userLoggedIn;
+    exerciseRepository.exerciseType = exerciseType;
+  }
+
+  double initQuantity;
+  double initUnitQuantity;
+  double quantity;
+  double unitQuantity;
+  double oneRepMax;
+  int step;
+
+  @override
+  Stream<TestSetControlState> mapEventToState(
+    TestSetControlEvent event,
+  ) async* {
+    try {
+      if (event is TestSetControlQuantityChange) {
+        quantity = event.quantity;
+      } else if (event is TestSetControlUnitQuantityChange) {
+        unitQuantity = event.quantity;
+      } else if (event is TestSetControlSubmit) {
+        final Exercise exercise = Exercise();
+        exercise.quantity = quantity;
+        exercise.unit = exerciseType.unit;
+        exercise.unitQuantity = unitQuantity;
+        exercise.dateAdd = DateTime.now();
+        exerciseRepository.exercise = exercise;
+
+        await exerciseRepository.addExercise();
+        executeBloc.add(
+            TestSetExecuteExerciseFinished(exerciseTypeId: exerciseType.exerciseTypeId, quantity: quantity, unitQuantity: unitQuantity));
+      }
+    } on Exception catch (e) {
+      yield TestSetControlError(message: e.toString());
+    }
+  }
+}

lib/bloc/test_set_control/test_set_control_event.dart

@@ -0,0 +1,32 @@
+part of 'test_set_control_bloc.dart';
+
+abstract class TestSetControlEvent extends Equatable {
+  const TestSetControlEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class TestSetControlLoad extends TestSetControlEvent {
+  const TestSetControlLoad();
+}
+
+class TestSetControlQuantityChange extends TestSetControlEvent {
+  final double quantity;
+  const TestSetControlQuantityChange({this.quantity});
+
+  @override
+  List<Object> get props => [quantity];
+}
+
+class TestSetControlUnitQuantityChange extends TestSetControlEvent {
+  final double quantity;
+  const TestSetControlUnitQuantityChange({this.quantity});
+
+  @override
+  List<Object> get props => [quantity];
+}
+
+class TestSetControlSubmit extends TestSetControlEvent {
+  const TestSetControlSubmit();
+}

lib/bloc/test_set_control/test_set_control_state.dart

@@ -0,0 +1,28 @@
+part of 'test_set_control_bloc.dart';
+
+abstract class TestSetControlState extends Equatable {
+  const TestSetControlState();
+
+  @override
+  List<Object> get props => [];
+}
+
+class TestSetControlInitial extends TestSetControlState {
+  const TestSetControlInitial();
+}
+
+class TestSetControlLoading extends TestSetControlState {
+  const TestSetControlLoading();
+}
+
+class TestSetControlReady extends TestSetControlState {
+  const TestSetControlReady();
+}
+
+class TestSetControlError extends TestSetControlState {
+  final String message;
+  const TestSetControlError({this.message});
+
+  @override
+  List<Object> get props => [message];
+}

lib/bloc/test_set_edit/test_set_edit_bloc.dart

@@ -10,6 +10,8 @@ import 'package:aitrainer_app/model/exercise_plan_template.dart';
 import 'package:aitrainer_app/model/exercise_type.dart';
 import 'package:aitrainer_app/repository/workout_tree_repository.dart';
 import 'package:aitrainer_app/service/exercise_plan_service.dart';
+import 'package:aitrainer_app/util/enums.dart';
+import 'package:aitrainer_app/util/track.dart';
 import 'package:bloc/bloc.dart';
 import 'package:equatable/equatable.dart';
 
@@ -18,12 +20,15 @@ part 'test_set_edit_state.dart';
 
 class TestSetEditBloc extends Bloc<TestSetEditEvent, TestSetEditState> {
   final String templateName;
+  final String templateNameTranslation;
   final WorkoutTreeRepository workoutTreeRepository;
   final MenuBloc menuBloc;
   final List<ExerciseType> _exerciseTypes = List();
+  final List<ExerciseType> _actualExerciseTypes = List();
   final HashMap<int, ExerciseType> _exercisePlanDetails = HashMap();
 
-  TestSetEditBloc({this.templateName, this.workoutTreeRepository, this.menuBloc}) : super(TestSetEditInitial()) {
+  TestSetEditBloc({this.templateName, this.templateNameTranslation, this.workoutTreeRepository, this.menuBloc})
+      : super(TestSetEditInitial()) {
     if (Cache().exercisePlanTemplates.isNotEmpty) {
       Cache().exercisePlanTemplates.forEach((element) {
         final ExercisePlanTemplate template = element as ExercisePlanTemplate;
@@ -31,6 +36,7 @@ class TestSetEditBloc extends Bloc<TestSetEditEvent, TestSetEditState> {
           template.exerciseTypes.forEach((id) {
             final ExerciseType exerciseType = Cache().getExerciseTypeById(id);
             _exerciseTypes.add(exerciseType);
+            _actualExerciseTypes.add(exerciseType);
             _exercisePlanDetails[exerciseType.exerciseTypeId] = exerciseType;
           });
         }
@@ -42,22 +48,36 @@ class TestSetEditBloc extends Bloc<TestSetEditEvent, TestSetEditState> {
   Stream<TestSetEditState> mapEventToState(TestSetEditEvent event) async* {
     try {
       if (event is TestSetEditChangeExerciseType) {
+        yield TestSetEditLoading();
         final List<ExerciseType> alternatives = workoutTreeRepository.getExerciseTypeAlternatives(event.exerciseTypeId);
         final ExerciseType exerciseType = Cache().getExerciseTypeById(event.exerciseTypeId);
-        if (event.index > alternatives.length) {
-          /// skip
-          _exercisePlanDetails[exerciseType.exerciseTypeId] = null;
-        } else if (event.index == 0) {
+
+        if (_exercisePlanDetails[event.exerciseTypeId] == null) {
+          /// it was skipped
           _exercisePlanDetails[exerciseType.exerciseTypeId] = exerciseType;
         } else {
-          final changedExerciseType = alternatives[event.index - 1];
-          _exercisePlanDetails[exerciseType.exerciseTypeId] = changedExerciseType;
+          if (event.index == 0) {
+            _exercisePlanDetails[exerciseType.exerciseTypeId] = exerciseType;
+          } else {
+            final changedExerciseType = alternatives[event.index - 1];
+            _exercisePlanDetails[exerciseType.exerciseTypeId] = changedExerciseType;
+          }
         }
+
+        // to keep the slider accurate
+        refreshActualPlan();
+        yield TestSetEditReady();
+      } else if (event is TestSetEditDeleteExerciseType) {
+        yield TestSetEditLoading();
+        final ExerciseType exerciseType = Cache().getExerciseTypeById(event.exerciseTypeId);
+        _exercisePlanDetails[exerciseType.exerciseTypeId] = null;
+        refreshActualPlan();
+        yield TestSetEditReady();
       } else if (event is TestSetEditSubmit) {
         yield TestSetEditLoading();
-        ExercisePlan exercisePlan = ExercisePlan(templateName, Cache().userLoggedIn.customerId);
+        ExercisePlan exercisePlan = ExercisePlan(templateNameTranslation, Cache().userLoggedIn.customerId);
         exercisePlan.private = true;
-        exercisePlan.type = ExerciseAbility.mini_test.toString();
+        exercisePlan.type = ExerciseAbility.mini_test_set.toString();
         exercisePlan.dateAdd = DateTime.now();
         ExercisePlan savedExercisePlan = await ExercisePlanApi().saveExercisePlan(exercisePlan);
 
@@ -67,11 +87,15 @@ class TestSetEditBloc extends Bloc<TestSetEditEvent, TestSetEditState> {
             ExercisePlanDetail exercisePlanDetail = ExercisePlanDetail(entry.value.exerciseTypeId);
             exercisePlanDetail.exercisePlanId = savedExercisePlan.exercisePlanId;
             exercisePlanDetail.serie = 1;
+
             ExercisePlanDetail savedDetail = await ExercisePlanApi().saveExercisePlanDetail(exercisePlanDetail);
-            details.add(savedDetail);
+            exercisePlanDetail.exercisePlanDetailId = savedDetail.exercisePlanDetailId;
+            exercisePlanDetail.exercises = List();
+            details.add(exercisePlanDetail);
           }
         }
         Cache().saveActiveExercisePlan(exercisePlan, details);
+        Track().track(TrackingEvent.test_set_edit, eventValue: templateName);
         yield TestSetEditSaved();
       }
     } on Exception catch (e) {
@@ -80,4 +104,14 @@ class TestSetEditBloc extends Bloc<TestSetEditEvent, TestSetEditState> {
   }
 
   List get exerciseTypes => this._exerciseTypes;
+  List get actualExerciseTypes => this._actualExerciseTypes;
+  HashMap get exercisePlanDetails => this._exercisePlanDetails;
+
+  void refreshActualPlan() {
+    _actualExerciseTypes.removeRange(0, _actualExerciseTypes.length - 1);
+    _exercisePlanDetails.keys.forEach((element) {
+      final ExerciseType exerciseType = Cache().getExerciseTypeById(element);
+      _actualExerciseTypes.add(exerciseType);
+    });
+  }
 }

lib/bloc/test_set_edit/test_set_edit_event.dart

@@ -20,6 +20,14 @@ class TestSetEditChangeExerciseType extends TestSetEditEvent {
   List<Object> get props => [index, exerciseTypeId];
 }
 
+class TestSetEditDeleteExerciseType extends TestSetEditEvent {
+  final int exerciseTypeId;
+  const TestSetEditDeleteExerciseType({this.exerciseTypeId});
+
+  @override
+  List<Object> get props => [exerciseTypeId];
+}
+
 class TestSetEditSkipExerciseType extends TestSetEditEvent {
   final int exerciseTypeId;
   const TestSetEditSkipExerciseType({this.exerciseTypeId});

lib/bloc/test_set_execute/test_set_execute_bloc.dart

@@ -0,0 +1,358 @@
+import 'dart:async';
+import 'dart:collection';
+
+import 'package:aitrainer_app/bloc/menu/menu_bloc.dart';
+import 'package:aitrainer_app/model/cache.dart';
+import 'package:aitrainer_app/model/exercise.dart';
+import 'package:aitrainer_app/model/exercise_ability.dart';
+import 'package:aitrainer_app/model/exercise_plan.dart';
+import 'package:aitrainer_app/model/exercise_plan_detail.dart';
+import 'package:aitrainer_app/model/exercise_type.dart';
+import 'package:aitrainer_app/model/workout_menu_tree.dart';
+import 'package:aitrainer_app/service/exercise_plan_service.dart';
+import 'package:bloc/bloc.dart';
+import 'package:equatable/equatable.dart';
+
+part 'test_set_execute_event.dart';
+part 'test_set_execute_state.dart';
+
+class TestSetExecuteBloc extends Bloc<TestSetExecuteEvent, TestSetExecuteState> {
+  // ignore: close_sinks
+  MenuBloc menuBloc;
+  int exerciseTypeId;
+  String testName;
+  String testType = "";
+  bool miniTestSet = false;
+  bool paralellTest = false;
+  double scrollOffset = 0;
+  ExercisePlan exercisePlan;
+  bool isDone100 = false;
+
+  List<ExercisePlanDetail> exercisePlanDetails;
+
+  TestSetExecuteBloc() : super(TestSetExecuteInitial());
+
+  void setExerciseTypeId(int id) => exerciseTypeId = id;
+
+  void initExercisePlan() {
+    exercisePlan = Cache().activeExercisePlan;
+    if (exercisePlan != null) {
+      testName = exercisePlan.name;
+      this.miniTestSet = exercisePlan.type != null && ExerciseAbility.mini_test_set.equalsStringTo(exercisePlan.type);
+      this.paralellTest = exercisePlan.type != null && ExerciseAbility.paralell_test.equalsStringTo(exercisePlan.type);
+
+      testType = ExerciseAbility.mini_test_set.equalsStringTo(exercisePlan.type)
+          ? ExerciseAbility.mini_test_set.description
+          : ExerciseAbility.paralell_test.description;
+      print("exercisePlan: $testName type: $testType");
+    }
+    exercisePlanDetails = Cache().activeExercisePlanDetails;
+    if (exercisePlanDetails != null) {
+      exercisePlanDetails.forEach((element) {
+        final ExerciseType exerciseType = Cache().getExerciseTypeById(element.exerciseTypeId);
+        if (exerciseType != null) {
+          element.exerciseType = exerciseType;
+        }
+        this.setPlanDetailState(element);
+        print("exercises of ${element.exerciseTypeId}: ${element.exercises}");
+      });
+    }
+  }
+
+  @override
+  Stream<TestSetExecuteState> mapEventToState(
+    TestSetExecuteEvent event,
+  ) async* {
+    try {
+      if (event is TestSetExecuteLoad) {
+        yield TestSetExecuteLoading();
+        initExercisePlan();
+        if (exerciseTypeId != null) {
+          int step = 0;
+          if (exercisePlanDetails != null) {
+            exercisePlanDetails.forEach((element) {
+              if (element.exerciseTypeId == this.exerciseTypeId) {
+                scrollOffset = (step * 85).toDouble() + 10;
+              }
+              step++;
+            });
+          }
+        }
+        yield TestSetExecuteReady();
+      } else if (event is TestSetExecuteDeleteActive) {
+        print("Delete: ${exercisePlan.type} paralellTest: $paralellTest");
+        if (exercisePlan != null && ExerciseAbility.mini_test_set.equalsStringTo(exercisePlan.type)) {
+          exercisePlan = null;
+          if (exercisePlanDetails != null) {
+            exercisePlanDetails.removeRange(0, exercisePlanDetails.length - 1);
+          }
+          await Cache().deleteActiveExercisePlan();
+        }
+      } else if (event is TestSetExecuteExerciseFinished) {
+        yield TestSetExecuteLoading();
+        exercisePlanDetails.forEach((element) {
+          if (element.exerciseTypeId == event.exerciseTypeId) {
+            element.repeats = event.quantity.toInt();
+            element.weightEquation = event.unitQuantity.toString();
+            if (element.exercises == null) {
+              element.exercises = List();
+            }
+            final Exercise exercise = Exercise();
+            exercise.customerId = Cache().userLoggedIn.customerId;
+            exercise.exerciseTypeId = event.exerciseTypeId;
+            exercise.quantity = event.quantity;
+            exercise.unit = element.exerciseType.unit;
+            exercise.unitQuantity = event.unitQuantity;
+            exercise.dateAdd = DateTime.now();
+            element.exercises.add(exercise);
+            setPlanDetailState(element);
+          }
+        });
+        Cache().saveActiveExercisePlan(exercisePlan, exercisePlanDetails);
+        if (this.isDone100Percent()) {
+          add(TestSetExecuteFinish());
+        } else {
+          yield TestSetExecuteReady();
+        }
+      } else if (event is TestSetExecuteNewExercise) {
+        yield TestSetExecuteLoading();
+        if (exercisePlan == null) {
+          exercisePlan = ExercisePlan(Cache().userLoggedIn.name + " Custom Test", Cache().userLoggedIn.customerId);
+          exercisePlan.private = true;
+          exercisePlan.dateAdd = DateTime.now();
+          ExercisePlan savedExercisePlan = await ExercisePlanApi().saveExercisePlan(exercisePlan);
+          exercisePlan = savedExercisePlan;
+          exercisePlanDetails = List();
+        }
+        exercisePlan.type = ExerciseAbility.paralell_test.enumToString();
+
+        if (!this.existsInPlanDetails(event.exerciseTypeId)) {
+          ExercisePlanDetail exercisePlanDetail = ExercisePlanDetail(event.exerciseTypeId);
+          exercisePlanDetail.exercisePlanId = exercisePlan.exercisePlanId;
+          final ExerciseType exerciseType = Cache().getExerciseTypeById(event.exerciseTypeId);
+          exercisePlanDetail.serie = exerciseType.unitQuantityUnit == null ? 1 : 4;
+          exercisePlanDetail.exerciseType = exerciseType;
+          exercisePlanDetail.exerciseTypeId = event.exerciseTypeId;
+          ExercisePlanDetail savedDetail = await ExercisePlanApi().saveExercisePlanDetail(exercisePlanDetail);
+          exercisePlanDetail.exercisePlanDetailId = savedDetail.exercisePlanDetailId;
+          exercisePlanDetail.state = ExercisePlanDetailState.start;
+          exercisePlanDetail.exercises = List();
+          exercisePlanDetails.add(exercisePlanDetail);
+          await Cache().saveActiveExercisePlan(exercisePlan, exercisePlanDetails);
+          paralellTest = true;
+        }
+        yield TestSetExecuteReady();
+      } else if (event is TestSetExecuteDeleteExercise) {
+        yield TestSetExecuteLoading();
+        ExercisePlanDetail deleteDetail;
+        exercisePlanDetails.forEach((element) {
+          if (element.exerciseTypeId == event.exerciseTypeId) {
+            deleteDetail = element;
+          }
+        });
+        if (deleteDetail != null) {
+          exercisePlanDetails.remove(deleteDetail);
+          if (exercisePlanDetails.isEmpty) {
+            exercisePlan = null;
+            exercisePlanDetails = null;
+            Cache().deleteActiveExercisePlan();
+          }
+        }
+        yield TestSetExecuteReady();
+      } else if (event is TestSetExecuteFinish) {
+        Cache().deleteActiveExercisePlan();
+        isDone100 = isDone100Percent();
+        // Animation
+        // Home
+        yield TestSetExecuteFinished();
+      }
+    } on Exception catch (e) {
+      yield TestSetExecuteError(message: e.toString());
+    }
+  }
+
+  bool hasBegun() {
+    if (exercisePlanDetails == null ||
+        exercisePlanDetails.isEmpty ||
+        exercisePlanDetails[0].exercises == null ||
+        exercisePlanDetails[0].exercises.length == 0) {
+      return false;
+    }
+
+    return true;
+  }
+
+  void setPlanDetailState(ExercisePlanDetail exercisePlanDetail) {
+    if (exercisePlanDetail.exercises == null || exercisePlanDetail.exercises.length == 0) {
+      exercisePlanDetail.state = ExercisePlanDetailState.start;
+    } else {
+      int maxLength = 1;
+      if (exercisePlanDetail.exerciseType.unitQuantityUnit != null) {
+        maxLength = 4;
+      }
+      if (exercisePlanDetail.exercises.length >= maxLength) {
+        exercisePlanDetail.state = ExercisePlanDetailState.finished;
+      } else {
+        exercisePlanDetail.state = ExercisePlanDetailState.inProgress;
+      }
+    }
+  }
+
+  ExercisePlanDetailState actualState(int exerciseTypeId) {
+    ExercisePlanDetailState state = ExercisePlanDetailState.start;
+    exercisePlanDetails.forEach((element) {
+      if (element.exerciseTypeId == exerciseTypeId) {
+        state = element.state;
+      }
+    });
+    return state;
+  }
+
+  bool existsInPlanDetails(int exerciseTypeId) {
+    bool found = false;
+    exercisePlanDetails.forEach((element) {
+      if (element.exerciseTypeId == exerciseTypeId) {
+        found = true;
+      }
+    });
+    return found;
+  }
+
+  ExercisePlanDetail actualExercisePlanDetail(int exerciseTypeId) {
+    ExercisePlanDetail found;
+    exercisePlanDetails.forEach((element) {
+      if (element.exerciseTypeId == exerciseTypeId) {
+        found = element;
+      }
+    });
+    return found;
+  }
+
+  bool isDone100Percent() {
+    bool done = true;
+    if (exercisePlanDetails == null || exercisePlanDetails.isEmpty) {
+      return false;
+    }
+    exercisePlanDetails.forEach((element) {
+      if (!element.state.equalsTo(ExercisePlanDetailState.finished)) {
+        done = false;
+      }
+    });
+    return done;
+  }
+
+  HashMap canAddNewExercise() {
+    HashMap ret = HashMap();
+    if (exercisePlan != null && ExerciseAbility.mini_test_set.equalsStringTo(exercisePlan.type)) {
+      final String message = "You have an active Test Set!";
+      final String message2 = "Do you want you to override it?";
+      ret['message'] = message;
+      ret['message2'] = message2;
+      ret['canAdd'] = false;
+    } else {
+      ret['canAdd'] = true;
+    }
+
+    return ret;
+  }
+
+  int getActualWorkoutTreeId(int exerciseTypeId) {
+    final WorkoutMenuTree workoutTree = this.menuBloc.menuTreeRepository.getMenuItemByExerciseTypeId(exerciseTypeId);
+    if (workoutTree == null) {
+      return null;
+    }
+    return workoutTree.id;
+  }
+
+  String getActualImageName(int exerciseTypeId) {
+    if (exerciseTypeId <= 0) {
+      return "";
+    }
+    final WorkoutMenuTree workoutTree = this.menuBloc.menuTreeRepository.getMenuItemByExerciseTypeId(exerciseTypeId);
+    if (workoutTree == null) {
+      return "";
+    }
+
+    return workoutTree.imageName;
+  }
+
+  bool isFirst() {
+    if (exercisePlanDetails == null) {
+      return true;
+    }
+    if (exercisePlanDetails.isEmpty) {
+      return true;
+    }
+    return (exercisePlanDetails[0].exercises == null || exercisePlanDetails[0].exercises.length == 0);
+  }
+
+  bool existsActivePlan() {
+    final bool exists = exercisePlan != null && exercisePlanDetails.length > 0;
+    print("Exists active plan: $exists");
+    return exists;
+  }
+
+  bool isDone(ExercisePlanDetail exercisePlanDetail) {
+    return (exercisePlanDetail.state.equalsTo(ExercisePlanDetailState.finished));
+  }
+
+  ExercisePlanDetail getNext() {
+    ExercisePlanDetail nextExercisePlanDetail;
+    int minStep = 99;
+    for (final detail in this.exercisePlanDetails) {
+      if (!detail.state.equalsTo(ExercisePlanDetailState.finished)) {
+        if (detail.exercises == null) {
+          nextExercisePlanDetail = detail;
+          minStep = 1;
+          break;
+        } else {
+          final int step = detail.exercises.length;
+          if (step < minStep) {
+            nextExercisePlanDetail = detail;
+            minStep = step;
+          }
+        }
+      }
+    }
+    return nextExercisePlanDetail;
+  }
+
+  double calculate1RM(double quantity, double unitQuantity) {
+    double weight = unitQuantity;
+    double repeat = quantity;
+    if (weight == 0 || repeat == 0) {
+      return 0;
+    }
+
+    double rmWendler = weight * repeat * 0.0333 + weight;
+    double rmOconner = weight * (1 + repeat / 40);
+    double average = (rmWendler + rmOconner) / 2;
+
+    return average;
+  }
+
+  String repeatTimesText(ExercisePlanDetail exercisePlanDetail) {
+    String text = "maximum";
+    if (!hasBegun() || exercisePlanDetail.exerciseType.unitQuantityUnit == null) {
+      return text;
+    }
+    int step = exercisePlanDetail.exercises.length;
+    print("repeatTimes step $step");
+    if (step == 2) {
+      text = "12";
+    }
+    return text;
+  }
+
+  String getExerciseWeight(ExercisePlanDetail exercisePlanDetail) {
+    String text = "you are able to do 12-20 repeats with";
+    if (!hasBegun() || exercisePlanDetail.exercises.length < 2) {
+      return text;
+    }
+    final double unitQuantity = exercisePlanDetail.exercises.last.unitQuantity;
+    final double quantity = exercisePlanDetail.exercises.last.quantity;
+    double oneRepMax = this.calculate1RM(quantity, unitQuantity);
+    text = (oneRepMax * 0.75).round().toStringAsFixed(0) + " " + exercisePlanDetail.exerciseType.unitQuantityUnit;
+    return text;
+  }
+}

lib/bloc/test_set_execute/test_set_execute_event.dart

@@ -0,0 +1,54 @@
+part of 'test_set_execute_bloc.dart';
+
+abstract class TestSetExecuteEvent extends Equatable {
+  const TestSetExecuteEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class TestSetExecuteLoad extends TestSetExecuteEvent {
+  const TestSetExecuteLoad();
+}
+
+class TestSetExecuteExecute extends TestSetExecuteEvent {
+  final int exerciseTypeId;
+  const TestSetExecuteExecute({this.exerciseTypeId});
+
+  @override
+  List<Object> get props => [exerciseTypeId];
+}
+
+class TestSetExecuteFinish extends TestSetExecuteEvent {
+  const TestSetExecuteFinish();
+}
+
+class TestSetExecuteExerciseFinished extends TestSetExecuteEvent {
+  final int exerciseTypeId;
+  final double quantity;
+  final double unitQuantity;
+  const TestSetExecuteExerciseFinished({this.exerciseTypeId, this.quantity, this.unitQuantity});
+
+  @override
+  List<Object> get props => [exerciseTypeId, quantity, unitQuantity];
+}
+
+class TestSetExecuteNewExercise extends TestSetExecuteEvent {
+  final int exerciseTypeId;
+  const TestSetExecuteNewExercise({this.exerciseTypeId});
+
+  @override
+  List<Object> get props => [exerciseTypeId];
+}
+
+class TestSetExecuteDeleteExercise extends TestSetExecuteEvent {
+  final int exerciseTypeId;
+  const TestSetExecuteDeleteExercise({this.exerciseTypeId});
+
+  @override
+  List<Object> get props => [exerciseTypeId];
+}
+
+class TestSetExecuteDeleteActive extends TestSetExecuteEvent {
+  const TestSetExecuteDeleteActive();
+}

lib/bloc/test_set_execute/test_set_execute_state.dart

@@ -0,0 +1,32 @@
+part of 'test_set_execute_bloc.dart';
+
+abstract class TestSetExecuteState extends Equatable {
+  const TestSetExecuteState();
+
+  @override
+  List<Object> get props => [];
+}
+
+class TestSetExecuteInitial extends TestSetExecuteState {
+  const TestSetExecuteInitial();
+}
+
+class TestSetExecuteLoading extends TestSetExecuteState {
+  const TestSetExecuteLoading();
+}
+
+class TestSetExecuteFinished extends TestSetExecuteState {
+  const TestSetExecuteFinished();
+}
+
+class TestSetExecuteReady extends TestSetExecuteState {
+  const TestSetExecuteReady();
+}
+
+class TestSetExecuteError extends TestSetExecuteState {
+  final String message;
+  const TestSetExecuteError({this.message});
+
+  @override
+  List<Object> get props => [message];
+}

lib/bloc/test_set_new/test_set_new_bloc.dart

@@ -0,0 +1,59 @@
+import 'dart:async';
+
+import 'package:aitrainer_app/bloc/test_set_execute/test_set_execute_bloc.dart';
+import 'package:aitrainer_app/model/cache.dart';
+import 'package:aitrainer_app/model/exercise_type.dart';
+import 'package:aitrainer_app/repository/exercise_repository.dart';
+import 'package:aitrainer_app/util/enums.dart';
+import 'package:aitrainer_app/util/track.dart';
+import 'package:bloc/bloc.dart';
+import 'package:equatable/equatable.dart';
+
+part 'test_set_new_event.dart';
+part 'test_set_new_state.dart';
+
+class TestSetNewBloc extends Bloc<TestSetNewEvent, TestSetNewState> {
+  final ExerciseRepository exerciseRepository;
+  final ExerciseType exerciseType;
+  final int exercisePlanDetailId;
+  final TestSetExecuteBloc executeBloc;
+
+  TestSetNewBloc({this.exerciseRepository, this.exerciseType, this.exercisePlanDetailId, this.executeBloc}) : super(TestSetNewInitial()) {
+    exerciseRepository.exerciseType = exerciseType;
+    quantity = 12;
+    unitQuantity = 30;
+    exerciseRepository.setQuantity(quantity);
+    exerciseRepository.setUnit(exerciseType.unit);
+    exerciseRepository.setUnitQuantity(unitQuantity);
+    exerciseRepository.exercise.exercisePlanDetailId = exercisePlanDetailId;
+    exerciseRepository.start = DateTime.now();
+    exerciseRepository.setCustomer(Cache().userLoggedIn);
+  }
+
+  double quantity;
+  double unitQuantity;
+
+  @override
+  Stream<TestSetNewState> mapEventToState(
+    TestSetNewEvent event,
+  ) async* {
+    try {
+      if (event is TestSetNewChangeQuantity) {
+        quantity = event.quantity;
+        exerciseRepository.setQuantity(quantity);
+      } else if (event is TestSetNewChangeQuantityUnit) {
+        unitQuantity = event.quantity;
+        exerciseRepository.setUnitQuantity(unitQuantity);
+      } else if (event is TestSetNewSubmit) {
+        yield TestSetNewLoading();
+        exerciseRepository.end = DateTime.now();
+        await exerciseRepository.addExercise();
+        executeBloc.add(
+            TestSetExecuteExerciseFinished(exerciseTypeId: exerciseType.exerciseTypeId, quantity: quantity, unitQuantity: unitQuantity));
+        Track().track(TrackingEvent.test_set_new, eventValue: exerciseType.name);
+      }
+    } on Exception catch (e) {
+      yield TestSetNewError(message: e.toString());
+    }
+  }
+}

lib/bloc/test_set_new/test_set_new_event.dart

@@ -0,0 +1,32 @@
+part of 'test_set_new_bloc.dart';
+
+abstract class TestSetNewEvent extends Equatable {
+  const TestSetNewEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class TestSetNewLoad extends TestSetNewEvent {
+  const TestSetNewLoad();
+}
+
+class TestSetNewChangeQuantity extends TestSetNewEvent {
+  final double quantity;
+  const TestSetNewChangeQuantity({this.quantity});
+
+  @override
+  List<Object> get props => [quantity];
+}
+
+class TestSetNewChangeQuantityUnit extends TestSetNewEvent {
+  final double quantity;
+  const TestSetNewChangeQuantityUnit({this.quantity});
+
+  @override
+  List<Object> get props => [quantity];
+}
+
+class TestSetNewSubmit extends TestSetNewEvent {
+  const TestSetNewSubmit();
+}

lib/bloc/test_set_new/test_set_new_state.dart

@@ -0,0 +1,28 @@
+part of 'test_set_new_bloc.dart';
+
+abstract class TestSetNewState extends Equatable {
+  const TestSetNewState();
+
+  @override
+  List<Object> get props => [];
+}
+
+class TestSetNewInitial extends TestSetNewState {
+  const TestSetNewInitial();
+}
+
+class TestSetNewLoading extends TestSetNewState {
+  const TestSetNewLoading();
+}
+
+class TestSetNewReady extends TestSetNewState {
+  const TestSetNewReady();
+}
+
+class TestSetNewError extends TestSetNewState {
+  final String message;
+  const TestSetNewError({this.message});
+
+  @override
+  List<Object> get props => [message];
+}