wt1.1.1 ExercisePlan + ExercisePlan detail, Trainee

lib/bloc/account/account_bloc.dart

@@ -3,6 +3,7 @@ import 'dart:async';
 import 'package:aitrainer_app/model/cache.dart';
 import 'package:aitrainer_app/model/customer.dart';
 import 'package:aitrainer_app/repository/customer_repository.dart';
+import 'package:aitrainer_app/repository/exercise_repository.dart';
 import 'package:bloc/bloc.dart';
 import 'package:equatable/equatable.dart';
 import 'package:meta/meta.dart';
@@ -13,6 +14,7 @@ part 'account_state.dart';
 class AccountBloc extends Bloc<AccountEvent, AccountState> {
   final CustomerRepository customerRepository;
   bool loggedIn = false;
+  int traineeId = 0;
   AccountBloc({this.customerRepository}) : super(AccountInitial()) {
     if ( Cache().userLoggedIn != null ) {
       customerRepository.customer = Cache().userLoggedIn;
@@ -36,8 +38,21 @@ class AccountBloc extends Bloc<AccountEvent, AccountState> {
       } else if (event is AccountLogout) {
         await Cache().logout();
         customerRepository.customer = null;
+        customerRepository.emptyTrainees();
         loggedIn = false;
         yield AccountLoggedOut();
+      } else if ( event is AccountGetTrainees) {
+        yield AccountLoading();
+        await customerRepository.getTrainees();
+        yield AccountReady();
+      } else if ( event is AccountSelectTrainee ) {
+        yield AccountLoading();
+        customerRepository.setTrainee(event.traineeId);
+        Cache().setTrainee(customerRepository.getTraineeById(event.traineeId));
+        ExerciseRepository exerciseRepository = ExerciseRepository();
+        await exerciseRepository.getExercisesByCustomer(event.traineeId);
+        this.traineeId = event.traineeId;
+        yield AccountReady();
       }
     } on Exception catch(e) {
       yield AccountError(message: e.toString());

lib/bloc/account/account_event.dart

@@ -43,4 +43,16 @@ class AccountLogInFinished extends AccountEvent {
 
   @override
   List<Object> get props => [customer];
+}
+
+class AccountGetTrainees extends AccountEvent {
+  const AccountGetTrainees();
+}
+
+class AccountSelectTrainee extends AccountEvent {
+  final int traineeId;
+  const AccountSelectTrainee({this.traineeId});
+
+  @override
+  List<Object> get props => [traineeId];
 }

lib/bloc/exercise_add_by_plan_bloc.dart

@@ -0,0 +1,81 @@
+import 'package:aitrainer_app/model/cache.dart';
+import 'package:aitrainer_app/model/customer.dart';
+import 'package:aitrainer_app/model/workout_tree.dart';
+import 'package:aitrainer_app/repository/exercise_plan_repository.dart';
+import 'package:aitrainer_app/repository/exercise_repository.dart';
+import 'package:flutter_form_bloc/flutter_form_bloc.dart';
+
+class ExerciseAddByPlanFormBloc extends FormBloc<String, String> {
+  final ExerciseRepository exerciseRepository;
+  final ExercisePlanRepository exercisePlanRepository;
+  final WorkoutTree workoutTree;
+  final customerId;
+  Customer customer;
+  int step = 1;
+  int countSteps = 1;
+
+  final quantity1Field = TextFieldBloc(
+  );
+
+  final unitQuantity1Field = TextFieldBloc(
+  );
+
+  ExerciseAddByPlanFormBloc({this.exerciseRepository, this.exercisePlanRepository, this.customerId, this.workoutTree}) {
+    addFieldBlocs(fieldBlocs: [
+      quantity1Field,
+      unitQuantity1Field,
+    ]);
+
+    quantity1Field.onValueChanges(onData: (previous, current) async* {
+      exerciseRepository.setQuantity(current.valueToDouble);
+    });
+
+    unitQuantity1Field.onValueChanges(onData: (previous, current) async* {
+      exerciseRepository.setUnitQuantity(unitQuantity1Field.valueToDouble);
+    });
+
+    exerciseRepository.exerciseType = workoutTree.exerciseType;
+    if ( Cache().userLoggedIn.customerId == customerId) {
+      customer = Cache().userLoggedIn;
+    } else if ( Cache().getTrainee().customerId == customerId) {
+      customer = Cache().getTrainee();
+    }
+    exercisePlanRepository.setActualPlanDetail(workoutTree.exerciseType);
+    exerciseRepository.customer = customer;
+    countSteps = exercisePlanRepository.actualPlanDetail.serie;
+
+    unitQuantity1Field.updateInitialValue(exercisePlanRepository.actualPlanDetail.weightEquation);
+    quantity1Field.updateInitialValue(exercisePlanRepository.actualPlanDetail.repeats.toString());
+
+  }
+
+  @override
+  void onSubmitting() async {
+
+    try {
+      emitLoading(progress: 30);
+      step++;
+
+      exerciseRepository.setUnitQuantity(unitQuantity1Field.valueToDouble);
+      exerciseRepository.setQuantity(quantity1Field.valueToDouble);
+      exerciseRepository.exercise.exercisePlanDetailId =
+        exercisePlanRepository.actualPlanDetail.exercisePlanDetailId;
+      exerciseRepository.exercise.unit = workoutTree.exerciseType.unit;
+      workoutTree.executed = true;
+      print("On Submitting Add Exercise By Plan " + exerciseRepository.exercise.toJson().toString());
+      await exerciseRepository.addExercise();
+
+      emitSuccess(canSubmitAgain: true);
+    } on Exception catch (ex) {
+      emitFailure(failureResponse: ex.toString());
+    }
+  }
+
+  //@override
+  Future<void> close() {
+    quantity1Field.close();
+    unitQuantity1Field.close();
+
+    return super.close();
+  }
+}

lib/bloc/exercise_by_plan/exercise_by_plan_bloc.dart

@@ -0,0 +1,58 @@
+import 'dart:async';
+import 'package:aitrainer_app/model/exercise_type.dart';
+import 'package:aitrainer_app/model/workout_tree.dart';
+import 'package:aitrainer_app/repository/exercise_plan_repository.dart';
+import 'package:aitrainer_app/repository/exercise_repository.dart';
+import 'package:aitrainer_app/repository/menu_tree_repository.dart';
+import 'package:bloc/bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:meta/meta.dart';
+
+part 'exercise_by_plan_event.dart';
+
+part 'exercise_by_plan_state.dart';
+
+class ExerciseByPlanBloc extends Bloc<ExerciseByPlanEvent, ExerciseByPlanState> {
+  final ExerciseRepository exerciseRepository;
+  final MenuTreeRepository menuTreeRepository;
+  final ExercisePlanRepository exercisePlanRepository = ExercisePlanRepository();
+  int customerId;
+  @override
+  ExerciseByPlanBloc({this.exerciseRepository, this.menuTreeRepository}) : super(ExerciseByPlanStateInitial());
+
+  Future<void> getData() async {
+    exercisePlanRepository.setCustomerId(customerId);
+    await exercisePlanRepository.getLastExercisePlan();
+    await exercisePlanRepository.getExercisePlanDetails();
+    menuTreeRepository.sortedTree = null;
+    menuTreeRepository.sortByMuscleType();
+
+    menuTreeRepository.sortedTree.forEach((key, value) {
+      List<WorkoutTree> listWorkoutTree = value;
+      listWorkoutTree.forEach((workoutTree) {
+        workoutTree.selected = false;
+        if (exercisePlanRepository.exercisePlanDetails.length > 0) {
+          if (exercisePlanRepository.exercisePlanDetails[workoutTree.exerciseTypeId] != null) {
+            workoutTree.selected = true;
+          }
+        }
+      });
+    });
+  }
+
+  @override
+  Stream<ExerciseByPlanState> mapEventToState(ExerciseByPlanEvent event) async* {
+    try {
+      if (event is ExerciseByPlanLoad) {
+        yield ExerciseByPlanLoading();
+        await this.getData();
+        yield ExerciseByPlanReady();
+      } else if (event is AddExerciseByPlanEvent) {
+        yield ExerciseByPlanLoading();
+        yield ExerciseByPlanReady();
+      }
+    } on Exception catch (e) {
+      yield ExerciseByPlanError(message: e.toString());
+    }
+  }
+}

lib/bloc/exercise_by_plan/exercise_by_plan_event.dart

@@ -0,0 +1,21 @@
+part of 'exercise_by_plan_bloc.dart';
+
+@immutable
+abstract class ExerciseByPlanEvent extends Equatable {
+  const ExerciseByPlanEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class AddExerciseByPlanEvent extends ExerciseByPlanEvent {
+  final ExerciseType exerciseType;
+  const AddExerciseByPlanEvent({this.exerciseType});
+
+  @override
+  List<Object> get props => [exerciseType];
+}
+
+class ExerciseByPlanLoad extends ExerciseByPlanEvent {
+  const ExerciseByPlanLoad();
+}

lib/bloc/exercise_by_plan/exercise_by_plan_state.dart

@@ -0,0 +1,31 @@
+part of 'exercise_by_plan_bloc.dart';
+
+@immutable
+abstract class ExerciseByPlanState extends Equatable {
+  const ExerciseByPlanState();
+
+  @override
+  List<Object> get props => [];
+}
+
+class ExerciseByPlanStateInitial extends ExerciseByPlanState {
+  const ExerciseByPlanStateInitial();
+}
+
+class ExerciseByPlanLoading extends ExerciseByPlanState {
+  const ExerciseByPlanLoading();
+}
+
+// updated screen
+class ExerciseByPlanReady extends ExerciseByPlanState {
+  const ExerciseByPlanReady();
+}
+
+// error splash screen
+class ExerciseByPlanError extends ExerciseByPlanState {
+  final String message;
+  const ExerciseByPlanError({this.message});
+
+  @override
+  List<Object> get props => [message];
+}

lib/bloc/exercise_plan/exercise_plan_bloc.dart

@@ -0,0 +1,89 @@
+import 'dart:async';
+import 'package:aitrainer_app/model/exercise_plan_detail.dart';
+import 'package:aitrainer_app/model/exercise_type.dart';
+import 'package:aitrainer_app/model/workout_tree.dart';
+import 'package:aitrainer_app/repository/exercise_plan_repository.dart';
+import 'package:aitrainer_app/repository/exercise_repository.dart';
+import 'package:aitrainer_app/repository/menu_tree_repository.dart';
+import 'package:bloc/bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:meta/meta.dart';
+
+part 'exercise_plan_event.dart';
+
+part 'exercise_plan_state.dart';
+
+class ExercisePlanBloc extends Bloc<ExercisePlanEvent, ExercisePlanState> {
+  final MenuTreeRepository menuTreeRepository;
+  final ExerciseRepository exerciseRepository;
+  final ExercisePlanRepository exercisePlanRepository = ExercisePlanRepository();
+  int customerId;
+
+  ExercisePlanBloc({this.exerciseRepository, this.menuTreeRepository}) : super(ExercisePlanInitial());
+
+  Future<void> getData() async {
+    exercisePlanRepository.setCustomerId(customerId);
+    await exercisePlanRepository.getLastExercisePlan();
+    await exercisePlanRepository.getExercisePlanDetails();
+    menuTreeRepository.sortedTree = null;
+    menuTreeRepository.sortByMuscleType();
+
+    menuTreeRepository.sortedTree.forEach((key, value) {
+      List<WorkoutTree> listWorkoutTree = value;
+      listWorkoutTree.forEach((workoutTree) {
+        workoutTree.selected = false;
+        if (exercisePlanRepository.exercisePlanDetails.length > 0) {
+          if (exercisePlanRepository.exercisePlanDetails[workoutTree.exerciseTypeId] != null) {
+            //print("bingo");
+            workoutTree.selected = true;
+          }
+        }
+      });
+    });
+  }
+
+  @override
+  Stream<ExercisePlanState> mapEventToState(ExercisePlanEvent event) async* {
+    try {
+      if (event is ExercisePlanLoad) {
+        yield ExercisePlanLoading();
+        await this.getData();
+        yield ExercisePlanReady();
+      }
+      if (event is ExercisePlanUpdate) {
+        yield ExercisePlanLoading();
+        WorkoutTree workoutTree = event.workoutTree;
+        if (workoutTree != null) {
+            exercisePlanRepository.addExerciseTypeToPlan(workoutTree.exerciseType);
+            workoutTree.selected = true;
+        }
+        yield ExercisePlanReady();
+      } else if (event is ExercisePlanRemoveExercise) {
+        yield ExercisePlanLoading();
+        ExercisePlanDetail planDetail = event.exercisePlanDetail;
+        exercisePlanRepository.removeExerciseTypeFromPlan(planDetail.exerciseType);
+        this.menuTreeRepository.sortedTree.forEach((key, value) {
+          List<WorkoutTree> listTreeItem = value;
+          listTreeItem.forEach((element) {
+            if ( element.exerciseType.exerciseTypeId == planDetail.exerciseTypeId) {
+              element.selected = false;
+            }
+          });
+        });
+        yield ExercisePlanReady();
+      } else if (event is ExercisePlanUpdateExercise) {
+        yield ExercisePlanReady();
+      } else if (event is ExercisePlanSave) {
+        if (exercisePlanRepository.getExercisePlanDetailSize() == 0) {
+          throw Exception("Please select an exercise");
+        } else {
+          yield ExercisePlanLoading();
+          exercisePlanRepository.saveExercisePlan();
+          yield ExercisePlanReady();
+        }
+      }
+    } on Exception catch (e) {
+      yield ExercisePlanError(message: e.toString());
+    }
+  }
+}

lib/bloc/exercise_plan/exercise_plan_event.dart

@@ -0,0 +1,49 @@
+part of 'exercise_plan_bloc.dart';
+
+@immutable
+abstract class ExercisePlanEvent extends Equatable {
+  const ExercisePlanEvent();
+  @override
+  List<Object> get props => [];
+}
+
+class ExercisePlanLoad extends ExercisePlanEvent {
+  const ExercisePlanLoad();
+}
+
+class ExercisePlanUpdate extends ExercisePlanEvent {
+  final WorkoutTree workoutTree;
+  const ExercisePlanUpdate({this.workoutTree});
+
+  @override
+  List<Object> get props => [workoutTree];
+}
+
+class ExercisePlanAddExercise extends ExercisePlanEvent {
+  final ExerciseType exerciseType;
+  const ExercisePlanAddExercise({this.exerciseType});
+
+  @override
+  List<Object> get props => [exerciseType];
+}
+
+class ExercisePlanRemoveExercise extends ExercisePlanEvent {
+  final ExercisePlanDetail exercisePlanDetail;
+  const ExercisePlanRemoveExercise({this.exercisePlanDetail});
+
+  @override
+  List<Object> get props => [exercisePlanDetail];
+}
+
+class ExercisePlanUpdateExercise extends ExercisePlanEvent {
+  final ExercisePlanDetail exercisePlanDetail;
+  const ExercisePlanUpdateExercise({this.exercisePlanDetail});
+
+  @override
+  List<Object> get props => [exercisePlanDetail];
+}
+
+class ExercisePlanSave extends ExercisePlanEvent {
+  const ExercisePlanSave();
+}
+

lib/bloc/exercise_plan/exercise_plan_state.dart

@@ -0,0 +1,37 @@
+part of 'exercise_plan_bloc.dart';
+
+@immutable
+abstract class ExercisePlanState  extends Equatable{
+  const ExercisePlanState();
+
+  @override
+  List<Object> get props => [];
+}
+
+// Display the last saved exercise plan
+class ExercisePlanInitial extends ExercisePlanState {
+  const ExercisePlanInitial();
+}
+
+// Loading screen
+class ExercisePlanLoading extends ExercisePlanState {
+  const ExercisePlanLoading();
+}
+
+// updated screen
+class ExercisePlanReady extends ExercisePlanState {
+  const ExercisePlanReady();
+}
+
+// error splash screen
+class ExercisePlanError extends ExercisePlanState {
+  final String message;
+  const ExercisePlanError({this.message});
+
+  @override
+  List<Object> get props => [message];
+}
+
+
+
+

lib/bloc/exercise_plan_custom_form.dart

@@ -0,0 +1,94 @@
+import 'package:aitrainer_app/bloc/exercise_plan/exercise_plan_bloc.dart';
+import 'package:aitrainer_app/repository/exercise_plan_repository.dart';
+import 'package:flutter_form_bloc/flutter_form_bloc.dart';
+
+class ExercisePlanCustomerFormBloc extends FormBloc<String, String> {
+  final ExercisePlanRepository exercisePlanRepository;
+  final ExercisePlanBloc planBloc;
+  final serieField = TextFieldBloc(
+    validators: [
+      FieldBlocValidators.required,
+    ],
+  );
+
+  final quantityField = TextFieldBloc(
+    validators: [
+      FieldBlocValidators.required,
+    ],
+  );
+
+  final weightField = TextFieldBloc(
+    validators: [
+      FieldBlocValidators.required,
+    ],
+  );
+
+  final exerciseTypeField = TextFieldBloc(
+    validators: [
+      FieldBlocValidators.required,
+    ],
+  );
+
+  ExercisePlanCustomerFormBloc({this.exercisePlanRepository, this.planBloc}) {
+    addFieldBlocs(fieldBlocs: [
+      quantityField,
+      serieField,
+      weightField
+    ]);
+
+    String repeatsInitial = exercisePlanRepository.actualPlanDetail != null &&
+        exercisePlanRepository.actualPlanDetail.repeats != null ?
+    exercisePlanRepository.actualPlanDetail.repeats.toString() : "12";
+    quantityField.updateInitialValue(repeatsInitial);
+
+    String serieInitial = exercisePlanRepository.actualPlanDetail != null &&
+      exercisePlanRepository.actualPlanDetail.serie != null ?
+    exercisePlanRepository.actualPlanDetail.serie.toString() : "3";
+    serieField.updateInitialValue(serieInitial);
+
+    String weightInitial = exercisePlanRepository.actualPlanDetail != null &&
+      exercisePlanRepository.actualPlanDetail.weightEquation != null ?
+    exercisePlanRepository.actualPlanDetail.weightEquation : "30";
+    weightField.updateInitialValue(weightInitial);
+
+    quantityField.onValueChanges(onData: (previous, current) async* {
+      exercisePlanRepository.actualPlanDetail.repeats = current.valueToInt;
+    });
+    serieField.onValueChanges(onData: (previous, current) async* {
+      exercisePlanRepository.actualPlanDetail.serie = current.valueToInt;
+    });
+    weightField.onValueChanges(onData: (previous, current) async* {
+      exercisePlanRepository.actualPlanDetail.weightEquation = current.value;
+    });
+  }
+
+  @override
+  void onSubmitting() async {
+    print("On Submitting Custom Plan form");
+    try {
+      emitLoading(progress: 30);
+      // Emit either Loaded or Error
+
+      exercisePlanRepository.actualPlanDetail.repeats = quantityField.valueToInt;
+      exercisePlanRepository.actualPlanDetail.serie = serieField.valueToInt;
+      exercisePlanRepository.actualPlanDetail.weightEquation = weightField.value;
+
+      exercisePlanRepository.addToPlan();
+      planBloc.add(ExercisePlanUpdate());
+
+      emitSuccess(canSubmitAgain: false);
+    } on Exception catch (ex) {
+      emitFailure(failureResponse: ex.toString());
+    }
+  }
+
+
+  //@override
+  Future<void> close() {
+    quantityField.close();
+    serieField.close();
+    weightField.close();
+    exerciseTypeField.close();
+    return super.close();
+  }
+}

lib/bloc/settings/settings_bloc.dart

@@ -34,6 +34,10 @@ class SettingsBloc extends Bloc<SettingsEvent, SettingsState> {
       yield SettingsLoading();
       await _changeLang( event.language);
       yield SettingsReady(_locale);
+    } else if ( event is SettingsGetLanguage) {
+      await AppLanguage().fetchLocale();
+      _locale = AppLanguage().appLocal;
+      yield SettingsReady(_locale);
     }
   }
 
@@ -50,12 +54,13 @@ class SettingsBloc extends Bloc<SettingsEvent, SettingsState> {
         break;
     }
     this.language = lang;
+    final AppLanguage appLanguage = AppLanguage();
+    appLanguage.changeLanguage(_locale);
     await loadLang();
   }
 
   Future<void> loadLang() async{
-    final AppLanguage appLanguage = AppLanguage();
-    appLanguage.changeLanguage(_locale);
+    print (" -- Loading lang $_locale");
     if ( context != null ) {
       AppLocalizations.of(context).setLocale(_locale);
       await AppLocalizations.of(context).load();

lib/bloc/settings/settings_event.dart

@@ -11,3 +11,7 @@ class SettingsChangeLanguage extends SettingsEvent {
   final String language;
   const SettingsChangeLanguage({this.language});
 }
+
+class SettingsGetLanguage extends SettingsEvent {
+  const SettingsGetLanguage();
+}