wt1.1.2d ProgressInfo+

2020-10-09 07:54:54 +02:00
parent 0cdc3a9d24
commit 35f0d0042f
66 changed files with 1615 additions and 576 deletions
@@ -8,6 +8,7 @@ import 'package:aitrainer_app/repository/exercise_repository.dart';
 import 'package:aitrainer_app/repository/workout_tree_repository.dart';
 import 'package:aitrainer_app/util/calculate.dart';
 import 'package:aitrainer_app/util/common.dart';
+import 'package:aitrainer_app/util/group_data.dart';

 import 'package:bloc/bloc.dart';
 import 'package:equatable/equatable.dart';
@@ -20,19 +21,240 @@ part 'development_by_muscle_event.dart';

 part 'development_by_muscle_state.dart';

-class DateRate {
-  static String daily = "daily";
-  static String weekly = "weekly";
-  static String monthly = "monthly";
-  static String yearly = "yearly";
-}
-
 class DiagramType {
  static String sumMass = "sumMass";
  static String oneRepMax = "oneRepMax";
  static String percent = "percent";
 }

+/*
+ =========== GROUPDATE CLASS
+ */
+
+class GroupDate extends GroupData with Calculate, Common {
+  final List<dynamic> inputList;
+  final List<dynamic> outputList;
+
+  String _origDatePart;
+  int _origExerciseTypeId;
+  Exercise _origExercise;
+
+  double _sumQuantity;
+  double _maxQuantity;
+  int _countExercises;
+
+  String diagramType;
+  String dateRate;
+
+  GroupDate({this.inputList, this.outputList});
+
+
+
+  double getQuantityByDate(Exercise exercise) {
+    double sum = 0;
+    if ( this.diagramType == DiagramType.sumMass ) {
+      if ( exercise.unitQuantity != null ) {
+        sum = exercise.quantity * exercise.unitQuantity;
+      } else {
+        sum = exercise.quantity;
+      }
+    } else if ( this.diagramType == DiagramType.oneRepMax || this.diagramType == DiagramType.percent ) {
+      if ( exercise.unitQuantity != null ) {
+        sum = calculate1RM(exercise.quantity, exercise.unitQuantity);
+      } else {
+        sum = exercise.quantity;
+      }
+    }
+    return sum;
+  }
+
+  @override
+  void addTempData(Exercise exercise) {
+    double newQuantity = getQuantityByDate(exercise);
+    _sumQuantity += newQuantity;
+    if (_maxQuantity < newQuantity) {
+      _maxQuantity = newQuantity;
+    }
+    _countExercises++;
+    _origDatePart = getDatePart(exercise.dateAdd, dateRate);
+    _origExerciseTypeId = exercise.exerciseTypeId;
+    _origExercise = exercise;
+  }
+
+  @override
+  bool checkNewType(Exercise exercise) {
+    String exerciseDatePart = getDatePart(exercise.dateAdd, dateRate);
+    return _origDatePart != exerciseDatePart || _origExerciseTypeId != exercise.exerciseTypeId;
+  }
+
+  @override
+  void iteration() {
+    this.resetTemp();
+    Exercise tempExercise;
+    inputList.forEach((element) {
+      tempExercise = element;
+      if ( this.checkNewType(element)) {
+        if ( _origDatePart == null ) {
+          this.addTempData(element);
+        } else {
+          this.temp2Output(_origExercise);
+          this.resetTemp();
+          this.addTempData(element);
+        }
+      } else {
+        this.addTempData(element);
+      }
+    });
+    if ( tempExercise != null) {
+      this.temp2Output(tempExercise);
+    }
+  }
+
+  @override
+  void temp2Output(Exercise exercise) {
+    Exercise newExercise = exercise.copy();
+    newExercise.datePart = _origDatePart;
+    if (this.diagramType == DiagramType.oneRepMax || this.diagramType == DiagramType.percent) {
+      newExercise.calculated = _maxQuantity;
+    } else {
+      newExercise.calculated = _sumQuantity / _countExercises;
+    }
+    outputList.add(newExercise);
+  }
+
+  @override
+  void resetTemp() {
+    _countExercises = 0;
+    _sumQuantity = 0;
+    _maxQuantity = 0;
+  }
+}
+
+/*
+ =========== CHART DATA CLASS
+ */
+class GroupChart extends GroupData with Calculate {
+
+  final List<dynamic> inputList;
+  LinkedHashMap<int, ChartDataExtended> outputList = LinkedHashMap();
+
+  int _origExerciseTypeId;
+  double _minData = 999999999999;
+  double _maxData = 0;
+  List<BarChartGroupData> _chartData;
+  double _basePercent;
+
+  String diagramType = DiagramType.sumMass;
+
+  GroupChart({this.inputList, this.outputList});
+
+  double getBasePercent(Exercise exercise) {
+    if ( exercise.unitQuantity != null ) {
+      this._basePercent = calculate1RM(exercise.quantity, exercise.unitQuantity);
+    } else {
+      this._basePercent = exercise.quantity;
+    }
+    return this._basePercent;
+  }
+
+  double getDiagramValue(Exercise exercise) {
+    double value = 0;
+
+    if ( diagramType == DiagramType.percent) {
+      if ( exercise.unitQuantity != null ) {
+        double oneRepMax = calculate1RM(exercise.quantity, exercise.unitQuantity);
+        value = (oneRepMax / this._basePercent) * 100;
+      } else {
+        value = (exercise.quantity / this._basePercent ) * 100;
+      }
+    } else if ( diagramType == DiagramType.oneRepMax || diagramType == DiagramType.sumMass) {
+      value = exercise.calculated;
+    }
+    return value;
+  }
+
+  @override
+  void addTempData(Exercise exercise) {
+
+    double diagramValue = this.getDiagramValue(exercise);
+
+    if (_maxData < diagramValue) {
+      _maxData = diagramValue;
+    }
+    if (_minData > diagramValue) {
+      _minData = diagramValue;
+    }
+
+    BarChartGroupData data = BarChartGroupData(
+      x: exercise.dateAdd.millisecondsSinceEpoch,
+      barRods: [
+        BarChartRodData(y: diagramValue, width: 12, color: Colors.lightBlue)
+      ]
+    );
+    _chartData.add(data);
+    _origExerciseTypeId = exercise.exerciseTypeId;
+
+  }
+
+  @override
+  bool checkNewType(Exercise exercise) {
+    return  _origExerciseTypeId != exercise.exerciseTypeId;
+  }
+
+  @override
+  void iteration() {
+
+    this.resetTemp();
+    Exercise tempExercise;
+    inputList.forEach((element) {
+      tempExercise = element;
+
+      if ( this.checkNewType(element)) {
+        if ( _origExerciseTypeId == null ) {
+          _basePercent = getBasePercent(element);
+          this.addTempData(element);
+        } else {
+          this.temp2Output(element);
+          this.resetTemp();
+          _basePercent = getBasePercent(element);
+          this.addTempData(element);
+        }
+      } else {
+        this.addTempData(element);
+      }
+    });
+    if ( tempExercise != null) {
+      this.temp2Output(tempExercise);
+    }
+  }
+
+  @override
+  void temp2Output(Exercise exercise) {
+    double dInterval = ((_maxData + _minData) / 8).roundToDouble();
+    int gridInterval = (dInterval / 3).floor();
+
+    ChartDataExtended extended;
+    if ( outputList[_origExerciseTypeId] == null ) {
+      extended = ChartDataExtended(
+        data: _chartData, interval: dInterval, gridInterval: gridInterval);
+      outputList[_origExerciseTypeId] = extended;
+    } else {
+      extended = outputList[_origExerciseTypeId];
+      _chartData.forEach((element) {
+        extended.data.add(element);
+      });
+    }
+  }
+
+  @override
+  void resetTemp() {
+    _minData = 999999999999;
+    _maxData = 0;
+    _chartData = List();
+  }
+
+}
+
 class ChartDataExtended {
  final List<BarChartGroupData> data;
  final double interval;
@@ -40,16 +262,29 @@ class ChartDataExtended {

  const ChartDataExtended({this.data, this.interval, this.gridInterval});

-  Map<String, dynamic> toJson() =>
-     {
-      "data": data.toString(),
-      "interval" : interval.toString(),
-      "gridInterval" : gridInterval,
+  Map<String, dynamic> toJson() {
+    List listBarChartData = List();
+    data.forEach((element) {
+      element.barRods.forEach((rods) {
+        var barChartData = {
+          'x': element.x,
+          'y': rods.y,
+        };
+        listBarChartData.add(barChartData);
+      });
+
+    });
+    var chartData = {
+      "data": listBarChartData.toString(),
+      "interval": interval.toString(),
+      "gridInterval": gridInterval,
    };
+    return chartData;
+  }

 }

-class DevelopmentByMuscleBloc extends Bloc<DevelopmentByMuscleEvent, DevelopmentByMuscleState> with Calculate, Common {
+class DevelopmentByMuscleBloc extends Bloc<DevelopmentByMuscleEvent, DevelopmentByMuscleState> with Calculate {
  final WorkoutTreeRepository workoutTreeRepository;
  final ExerciseRepository exerciseRepository = ExerciseRepository();
  LinkedHashMap<int, ChartDataExtended> listChartData = LinkedHashMap();
@@ -81,57 +316,21 @@ class DevelopmentByMuscleBloc extends Bloc<DevelopmentByMuscleEvent, Development

  void getChartData() {
    List<Exercise> exercises = exerciseRepository.getExerciseList();
-    exercises.sort( (a, b) => a.exerciseTypeId.compareTo(b.exerciseTypeId));
+
+    //print("-- Start calculate --- ");
    exercises = this.groupByDate(exercises);

-    int origExerciseTypeId = 0;
-    int x = 0;
-    chartData = List();
-    double maxData = 0;
-    double minData = 9999999999999;
-    exercises.forEach((exercise) {
-      if ( exercise.unitQuantity != null ) {
-        if (origExerciseTypeId != exercise.exerciseTypeId && diagramType == DiagramType.percent) {
-          this.basePercent = getBasePercent(exercise);
-        }
-        double diagramValue = this.getDiagramValue(exercise);
+    exercises = sort(exercises, true);
+/*    exercises.forEach((exercise) {
+      print ("Chart exercise " + exercise.toJsonDatePart().toString());
+    });*/
+
+    listChartData = LinkedHashMap();
+    GroupChart groupChart = GroupChart(inputList: exercises, outputList: listChartData);
+    groupChart.diagramType = this.diagramType;
+    groupChart.iteration();
+    listChartData = groupChart.outputList;

-        if (maxData < diagramValue) {
-          maxData = diagramValue;
-        }
-        if (minData > diagramValue) {
-          minData = diagramValue;
-        }
-        //print("exercise " + exercise.exerciseTypeId.toString() + " d " + getDateFormat(exercise.dateAdd) + " mass " + sumMass.toString());
-        //print("date " + exercise.dateAdd.toIso8601String() + " epoch " + exercise.dateAdd.millisecondsSinceEpoch.toString() );
-        BarChartGroupData data = BarChartGroupData(
-          x: exercise.dateAdd.millisecondsSinceEpoch,
-          barRods: [
-            BarChartRodData(y: diagramValue, width: 12, color: Colors.lightBlue)
-          ]
-        );
-        if (origExerciseTypeId != exercise.exerciseTypeId) {
-          if (origExerciseTypeId == 0) {
-            origExerciseTypeId = exercise.exerciseTypeId;
-            chartData.add(data);
-          } else {
-            double dInterval = ((maxData + minData) / 8).roundToDouble();
-            int gridInterval = (dInterval / 3).floor();
-            ChartDataExtended extended = ChartDataExtended(
-              data: chartData, interval: dInterval, gridInterval: gridInterval);
-            listChartData[origExerciseTypeId] = extended;
-            maxData = 0;
-            minData = 9999999999999;
-            chartData = List();
-            chartData.add(data);
-            origExerciseTypeId = exercise.exerciseTypeId;
-          }
-        } else {
-          origExerciseTypeId = exercise.exerciseTypeId;
-          chartData.add(data);
-        }
-      }
-    });

    listChartData.forEach((key, value) {
      print ("typeid " + key.toString() + " chardata " + value.toJson().toString());
@@ -139,126 +338,38 @@ class DevelopmentByMuscleBloc extends Bloc<DevelopmentByMuscleEvent, Development
    return;
  }

-  String getDatePart(DateTime date) {
-    String datePart = DateFormat('MM.dd', AppLanguage().appLocal.toString()).format(date);;
-    if ( this.dateRate == DateRate.weekly ) {
-      datePart = weekNumber(date).toString();
-    } else if ( this.dateRate == DateRate.monthly ) {
-      datePart =  DateFormat('MMM', AppLanguage().appLocal.toString()).format(date);
-    }  else if ( this.dateRate == DateRate.yearly ) {
-      datePart =  DateFormat('y', AppLanguage().appLocal.toString()).format(date);
-    } else if ( this.dateRate == DateRate.daily ) {
-      datePart =  DateFormat('MM.dd', AppLanguage().appLocal.toString()).format(date);
-    }
-    return datePart;
-  }
+

  List<Exercise> groupByDate(List<Exercise> exercises) {
    List<Exercise> groupedExercises = List();

-    String origDatePart;
-
-    int countExercises = 0;
-    double sumQuantity = 0;
-    double maxQuantity = 0;
-    Exercise origExercise;
+    exercises = sort(exercises, false);
    exercises.forEach((exercise) {
-      String exerciseDatePart = getDatePart(exercise.dateAdd);
-      if ( origExercise != null ) {
-        if ( origExercise.exerciseTypeId != exercise.exerciseTypeId || origDatePart != exerciseDatePart ) {
-          Exercise newExercise = origExercise.copy();
-          newExercise.datePart = origDatePart;
-          if (this.diagramType == DiagramType.oneRepMax || this.diagramType == DiagramType.percent) {
-            newExercise.quantity = maxQuantity;
-          } else {
-            newExercise.quantity = sumQuantity / countExercises;
-          }
-          groupedExercises.add(newExercise);
-          countExercises = 0;
-          sumQuantity = 0;
-          maxQuantity = 0;
-        }
-      }
-      origExercise = exercise;
-      origDatePart = exerciseDatePart;
-
-      double newQuantity = getQuantityByDate(exercise);
-      sumQuantity += newQuantity;
-      if (maxQuantity < newQuantity) {
-        maxQuantity = newQuantity;
-      }
-      countExercises++;
-
+      print ("Date exercise  " + exercise.toJsonDatePart().toString());
    });

-    groupedExercises.forEach((element) {
-      print("grouped " + element.toJson().toString());
-    });
+    GroupDate groupDate = GroupDate(inputList: exercises, outputList: groupedExercises);
+    groupDate.dateRate = this.dateRate;
+    groupDate.diagramType = this.diagramType;
+    groupDate.iteration();
+    groupedExercises = groupDate.outputList;
+
+/*    groupedExercises.forEach((element) {
+      print("Grouped " + element.toJsonDatePart().toString());
+    });*/


    return groupedExercises;
  }

-  double getQuantityByDate(Exercise exercise) {
-    double sum = 0;
-    if ( this.diagramType == DiagramType.sumMass ) {
-      if ( exercise.unitQuantity != null ) {
-        sum = exercise.quantity * exercise.unitQuantity;
-      } else {
-        sum = exercise.quantity;
-      }
-    } else if ( this.diagramType == DiagramType.oneRepMax || this.diagramType == DiagramType.percent ) {
-      if ( exercise.unitQuantity != null ) {
-        sum = calculate1RM(exercise.quantity, exercise.unitQuantity);
-      } else {
-        sum = exercise.quantity;
-      }
-    }
-    return sum;
-  }
+  List<Exercise> sort(List<Exercise> exercises, bool asc) {
+    exercises.sort( (a, b) {
+      var aDateId = a.exerciseTypeId.toString() + "_" + a.datePart.toString();
+      var bDateId = b.exerciseTypeId.toString() + "_" + b.datePart.toString();

-  double getBasePercent(Exercise exercise) {
-    if ( exercise.unitQuantity != null ) {
-      this.basePercent = calculate1RM(exercise.quantity, exercise.unitQuantity);
-    } else {
-      this.basePercent = exercise.quantity;
-    }
-    //print("Base percent of " + exercise.exerciseTypeId.toString() + ": "  + basePercent.toString());
-    return this.basePercent;
-  }
-
-  double getDiagramValue(Exercise exercise) {
-    double value = 0;
-    /*if ( diagramType == DiagramType.sumMass) {
-      value = exercise.quantity;
-      if ( exercise.unitQuantity != null ) {
-        value *= exercise.unitQuantity;
-      }
-    } else if ( diagramType == DiagramType.oneRepMax) {
-      if ( exercise.unitQuantity != null ) {
-        value = calculate1RM(exercise.quantity, exercise.unitQuantity);
-      }
-    } else if ( diagramType == DiagramType.percent) {
-      if ( exercise.unitQuantity != null ) {
-        double oneRepMax = calculate1RM(exercise.quantity, exercise.unitQuantity);
-        value = (oneRepMax / this.basePercent) * 100;
-        //print("Percent of " + exercise.exerciseTypeId.toString() + ": "  + value.toString() + " date " + exercise.dateAdd.toIso8601String() + " 1RM " + oneRepMax.toString());
-      } else {
-        value = (exercise.quantity / this.basePercent ) * 100;
-      }*/
-
-    if ( diagramType == DiagramType.percent) {
-      if ( exercise.unitQuantity != null ) {
-        double oneRepMax = calculate1RM(exercise.quantity, exercise.unitQuantity);
-        value = (oneRepMax / this.basePercent) * 100;
-        //print("Percent of " + exercise.exerciseTypeId.toString() + ": "  + value.toString() + " date " + exercise.dateAdd.toIso8601String() + " 1RM " + oneRepMax.toString());
-      } else {
-        value = (exercise.quantity / this.basePercent ) * 100;
-      }
-    } else {
-      return exercise.quantity;
-    }
-    return value;
+      return asc ? aDateId.compareTo(bDateId) : bDateId.compareTo(aDateId);
+    });
+    return exercises;
  }

  String getDateFormat(DateTime datetime) {