Finish Feature-CheckStyle

checkstyle.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <!DOCTYPE module PUBLIC
-    "-//Puppy Crawl//DTD Check Configuration 1.2//EN"
-    "http://www.puppycrawl.com/dtds/configuration_1_2.dtd">
+    "-//Puppy Crawl//DTD Check Configuration 1.3//EN"
+    "http://www.puppycrawl.com/dtds/configuration_1_3.dtd">
 
 <module name="Checker">
   <!--module name="NewlineAtEndOfFile"/-->

src/main/java/de/avalax/fitbuddy/application/dialog/WeightDecimalPlaces.java

@@ -4,31 +4,31 @@
 import java.util.TreeMap;
 
 public class WeightDecimalPlaces {
-    private static final Map<String, Double> decimalPlaces;
+    private static final Map<String, Double> DECIMAL_PLACES;
 
     static {
-        decimalPlaces = new TreeMap<>();
-        decimalPlaces.put("0", 0.0);
-        decimalPlaces.put("125", 0.125);
-        decimalPlaces.put("250", 0.25);
-        decimalPlaces.put("375", 0.375);
-        decimalPlaces.put("500", 0.5);
-        decimalPlaces.put("625", 0.625);
-        decimalPlaces.put("750", 0.75);
-        decimalPlaces.put("875", 0.875);
+        DECIMAL_PLACES = new TreeMap<>();
+        DECIMAL_PLACES.put("0", 0.0);
+        DECIMAL_PLACES.put("125", 0.125);
+        DECIMAL_PLACES.put("250", 0.25);
+        DECIMAL_PLACES.put("375", 0.375);
+        DECIMAL_PLACES.put("500", 0.5);
+        DECIMAL_PLACES.put("625", 0.625);
+        DECIMAL_PLACES.put("750", 0.75);
+        DECIMAL_PLACES.put("875", 0.875);
     }
 
     public String[] getLabels() {
-        return decimalPlaces.keySet().toArray(new String[decimalPlaces.size()]);
+        return DECIMAL_PLACES.keySet().toArray(new String[DECIMAL_PLACES.size()]);
     }
 
     public Double getWeight(int position) {
-        Double[] doubleValues = decimalPlaces.values().toArray(new Double[decimalPlaces.size()]);
+        Double[] doubleValues = DECIMAL_PLACES.values().toArray(new Double[DECIMAL_PLACES.size()]);
         return doubleValues[position];
     }
 
     public int getPosition(double weight) {
-        Double[] doubleValues = decimalPlaces.values().toArray(new Double[decimalPlaces.size()]);
+        Double[] doubleValues = DECIMAL_PLACES.values().toArray(new Double[DECIMAL_PLACES.size()]);
         for (int i = 0; i < doubleValues.length; i++) {
             if (doubleValues[i] == weight) {
                 return i;

src/main/java/de/avalax/fitbuddy/application/edit/workout/EditWorkoutApplicationService.java

@@ -1,22 +1,27 @@
 package de.avalax.fitbuddy.application.edit.workout;
 
-import android.view.View;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
 import de.avalax.fitbuddy.application.workout.WorkoutSession;
-import de.avalax.fitbuddy.domain.model.ResourceNotFoundException;
+import de.avalax.fitbuddy.domain.model.ResourceException;
 import de.avalax.fitbuddy.domain.model.exercise.Exercise;
-import de.avalax.fitbuddy.domain.model.exercise.ExerciseNotFoundException;
+import de.avalax.fitbuddy.domain.model.exercise.ExerciseException;
 import de.avalax.fitbuddy.domain.model.exercise.ExerciseRepository;
 import de.avalax.fitbuddy.domain.model.finishedWorkout.FinishedWorkoutRepository;
 import de.avalax.fitbuddy.domain.model.set.Set;
-import de.avalax.fitbuddy.domain.model.set.SetNotFoundException;
+import de.avalax.fitbuddy.domain.model.set.SetException;
 import de.avalax.fitbuddy.domain.model.set.SetRepository;
-import de.avalax.fitbuddy.domain.model.workout.*;
-
-import java.io.IOException;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.TreeMap;
+import de.avalax.fitbuddy.domain.model.workout.BasicWorkout;
+import de.avalax.fitbuddy.domain.model.workout.Workout;
+import de.avalax.fitbuddy.domain.model.workout.WorkoutException;
+import de.avalax.fitbuddy.domain.model.workout.WorkoutId;
+import de.avalax.fitbuddy.domain.model.workout.WorkoutListEntry;
+import de.avalax.fitbuddy.domain.model.workout.WorkoutParseException;
+import de.avalax.fitbuddy.domain.model.workout.WorkoutRepository;
+import de.avalax.fitbuddy.domain.model.workout.WorkoutService;
 
 public class EditWorkoutApplicationService {
 
@@ -40,7 +45,13 @@ public class EditWorkoutApplicationService {
 
     private Map<Integer, Exercise> deletedExercises;
 
-    public EditWorkoutApplicationService(WorkoutSession workoutSession, FinishedWorkoutRepository finishedWorkoutRepository, WorkoutRepository workoutRepository, ExerciseRepository exerciseRepository, SetRepository setRepository, WorkoutService workoutService) {
+    public EditWorkoutApplicationService(
+            WorkoutSession workoutSession,
+            FinishedWorkoutRepository finishedWorkoutRepository,
+            WorkoutRepository workoutRepository,
+            ExerciseRepository exerciseRepository,
+            SetRepository setRepository,
+            WorkoutService workoutService) {
         this.workoutSession = workoutSession;
         this.finishedWorkoutRepository = finishedWorkoutRepository;
         this.workoutRepository = workoutRepository;
@@ -54,23 +65,23 @@ private void setUnsavedChanges(boolean unsavedChanges) {
         this.unsavedChanges = unsavedChanges;
     }
 
-    public int unsavedChangesVisibility() {
-        return unsavedChanges ? View.VISIBLE : View.GONE;
+    public boolean hasUnsavedChanges() {
+        return unsavedChanges;
     }
 
     public Workout getWorkout() {
         return workout;
     }
 
-    public void setWorkout(WorkoutId id) throws WorkoutNotFoundException {
+    public void setWorkout(WorkoutId id) throws WorkoutException {
         this.workout = workoutRepository.load(id);
     }
 
-    public void switchWorkout() throws IOException {
+    public void switchWorkout() throws WorkoutException {
         try {
             Workout workoutToSave = workoutSession.getWorkout();
             finishedWorkoutRepository.saveWorkout(workoutToSave);
-        } catch (ResourceNotFoundException ignored) {
+        } catch (ResourceException ignored) {
         }
         workoutSession.switchWorkout(workout);
         setUnsavedChanges(false);
@@ -132,7 +143,7 @@ public void undoDeleteWorkout() {
         setUnsavedChanges(false);
     }
 
-    public void deleteExercise(Collection<Integer> positions) throws ExerciseNotFoundException {
+    public void deleteExercise(Collection<Integer> positions) throws ExerciseException {
         for (Integer position : positions) {
             Exercise exercise = workout.exerciseAtPosition(position);
             exerciseRepository.delete(exercise.getExerciseId());
@@ -154,12 +165,6 @@ public void createExercise() {
         setUnsavedChanges(false);
     }
 
-    public void createExerciseAfterPosition(int position) {
-        workout.createExercise(position + 1);
-        workoutRepository.save(workout);
-        setUnsavedChanges(false);
-    }
-
     public boolean hasDeletedWorkout() {
         return deletedWorkout != null;
     }
@@ -174,13 +179,13 @@ public void changeName(String name) {
         setUnsavedChanges(false);
     }
 
-    public void changeSetAmount(Exercise exercise, int newSetAmount) throws ResourceNotFoundException {
+    public void changeSetAmount(Exercise exercise, int amount) throws ResourceException {
         int countOfSets = exercise.countOfSets();
-        if (newSetAmount == countOfSets) {
+        if (amount == countOfSets) {
             return;
         }
-        if (newSetAmount < countOfSets) {
-            for (int i = 0; i < countOfSets - newSetAmount; i++) {
+        if (amount < countOfSets) {
+            for (int i = 0; i < countOfSets - amount; i++) {
                 Set set = exercise.setAtPosition(i);
                 exercise.removeSet(set);
                 setRepository.delete(set.getSetId());
@@ -193,11 +198,11 @@ public void changeSetAmount(Exercise exercise, int newSetAmount) throws Resource
                 Set set = exercise.setAtPosition(indexOfCurrentSet);
                 weight = set.getWeight();
                 maxReps = set.getMaxReps();
-            } catch (SetNotFoundException e) {
+            } catch (SetException e) {
                 weight = 0;
                 maxReps = 0;
             }
-            for (int i = 0; i < newSetAmount - countOfSets; i++) {
+            for (int i = 0; i < amount - countOfSets; i++) {
                 Set set = exercise.createSet();
                 set.setMaxReps(maxReps);
                 set.setWeight(weight);
@@ -208,14 +213,14 @@ public void changeSetAmount(Exercise exercise, int newSetAmount) throws Resource
     }
 
 
-    public void moveExerciseAtPositionUp(int position) throws ResourceNotFoundException {
+    public void moveExerciseAtPositionUp(int position) throws ResourceException {
         if (workout.moveExerciseAtPositionUp(position)) {
             workoutRepository.save(workout);
         }
         setUnsavedChanges(false);
     }
 
-    public void moveExerciseAtPositionDown(int position) throws ResourceNotFoundException {
+    public void moveExerciseAtPositionDown(int position) throws ResourceException {
         if (workout.moveExerciseAtPositionDown(position)) {
             workoutRepository.save(workout);
         }

src/main/java/de/avalax/fitbuddy/application/workout/WorkoutApplicationService.java

@@ -1,41 +1,44 @@
 package de.avalax.fitbuddy.application.workout;
 
-import de.avalax.fitbuddy.domain.model.ResourceNotFoundException;
+import de.avalax.fitbuddy.domain.model.ResourceException;
 import de.avalax.fitbuddy.domain.model.exercise.Exercise;
-import de.avalax.fitbuddy.domain.model.exercise.ExerciseNotFoundException;
 import de.avalax.fitbuddy.domain.model.finishedWorkout.FinishedWorkoutRepository;
 import de.avalax.fitbuddy.domain.model.set.Set;
-import de.avalax.fitbuddy.domain.model.workout.*;
-
-import java.io.IOException;
+import de.avalax.fitbuddy.domain.model.workout.Workout;
+import de.avalax.fitbuddy.domain.model.workout.WorkoutException;
+import de.avalax.fitbuddy.domain.model.workout.WorkoutId;
+import de.avalax.fitbuddy.domain.model.workout.WorkoutRepository;
 
 public class WorkoutApplicationService {
     private WorkoutSession workoutSession;
     private WorkoutRepository workoutRepository;
     private FinishedWorkoutRepository finishedWorkoutRepository;
 
-    public WorkoutApplicationService(WorkoutSession workoutSession, WorkoutRepository workoutRepository, FinishedWorkoutRepository finishedWorkoutRepository) {
+    public WorkoutApplicationService(
+            WorkoutSession workoutSession,
+            WorkoutRepository workoutRepository,
+            FinishedWorkoutRepository finishedWorkoutRepository) {
         this.workoutSession = workoutSession;
         this.workoutRepository = workoutRepository;
         this.finishedWorkoutRepository = finishedWorkoutRepository;
     }
 
-    public int countOfExercises() throws ResourceNotFoundException {
+    public int countOfExercises() throws ResourceException {
         return getWorkout().countOfExercises();
     }
 
-    public Exercise requestExercise(int position) throws WorkoutNotFoundException, ExerciseNotFoundException {
+    public Exercise requestExercise(int position) throws ResourceException {
         return getWorkout().exerciseAtPosition(position);
     }
 
-    public void switchToSet(int position, int moved) throws ResourceNotFoundException, IOException {
+    public void switchToSet(int position, int moved) throws ResourceException {
         Exercise exercise = getWorkout().exerciseAtPosition(position);
         exercise.setCurrentSet(exercise.indexOfCurrentSet() + moved);
         //TODO only saveWorkout by android lifecycle
         workoutSession.saveCurrentWorkout();
     }
 
-    public void addRepsToSet(int position, int moved) throws ResourceNotFoundException, IOException {
+    public void addRepsToSet(int position, int moved) throws ResourceException {
         Exercise exercise = getWorkout().exerciseAtPosition(position);
         int currentSetIndex = exercise.indexOfCurrentSet();
         Set set = exercise.setAtPosition(currentSetIndex);
@@ -45,51 +48,51 @@ public void addRepsToSet(int position, int moved) throws ResourceNotFoundExcepti
         workoutSession.saveCurrentWorkout();
     }
 
-    public void setCurrentExercise(int index) throws ResourceNotFoundException, IOException {
+    public void setCurrentExercise(int index) throws ResourceException {
         getWorkout().setCurrentExercise(index);
         //TODO only saveWorkout by android lifecycle
         workoutSession.saveCurrentWorkout();
     }
 
-    public void updateWeightOfCurrentSet(int index, double weight) throws ResourceNotFoundException, IOException {
+    public void updateWeightOfCurrentSet(int index, double weight) throws ResourceException {
         Exercise exercise = requestExercise(index);
         int indexOfCurrentSet = exercise.indexOfCurrentSet();
         exercise.setAtPosition(indexOfCurrentSet).setWeight(weight);
         //TODO only saveWorkout by android lifecycle
         workoutSession.saveCurrentWorkout();
     }
 
-    public double weightOfCurrentSet(int index) throws ResourceNotFoundException {
+    public double weightOfCurrentSet(int index) throws ResourceException {
         Exercise exercise = requestExercise(index);
         int indexOfCurrentSet = exercise.indexOfCurrentSet();
         Set set = exercise.setAtPosition(indexOfCurrentSet);
         return set.getWeight();
     }
 
-    public int indexOfCurrentExercise() throws ResourceNotFoundException {
+    public int indexOfCurrentExercise() throws ResourceException {
         return getWorkout().indexOfCurrentExercise();
     }
 
-    public WorkoutId currentWorkoutId() throws ResourceNotFoundException {
+    public WorkoutId currentWorkoutId() throws ResourceException {
         return workoutSession.getWorkout().getWorkoutId();
     }
 
-    public void finishCurrentWorkout() throws ResourceNotFoundException, IOException {
+    public void finishCurrentWorkout() throws ResourceException {
         Workout workout = workoutSession.getWorkout();
         finishedWorkoutRepository.saveWorkout(workout);
         Workout newWorkout = workoutRepository.load(workout.getWorkoutId());
         workoutSession.switchWorkout(newWorkout);
     }
 
-    public int workoutProgress(int exerciseIndex) throws ResourceNotFoundException {
+    public int workoutProgress(int exerciseIndex) throws ResourceException {
         return progressInPercent(getWorkout().getProgress(exerciseIndex));
     }
 
     private int progressInPercent(double progess) {
         return (int) Math.round(progess * 100);
     }
 
-    private Workout getWorkout() throws WorkoutNotFoundException {
+    private Workout getWorkout() throws WorkoutException {
         return workoutSession.getWorkout();
     }
 }

src/main/java/de/avalax/fitbuddy/application/workout/WorkoutSession.java

@@ -1,10 +1,16 @@
 package de.avalax.fitbuddy.application.workout;
 
 import android.content.Context;
-import de.avalax.fitbuddy.domain.model.workout.Workout;
-import de.avalax.fitbuddy.domain.model.workout.WorkoutNotFoundException;
 
-import java.io.*;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+import de.avalax.fitbuddy.domain.model.workout.Workout;
+import de.avalax.fitbuddy.domain.model.workout.WorkoutException;
 
 public class WorkoutSession {
     private Workout workout;
@@ -15,18 +21,18 @@ public WorkoutSession(Context context) {
         this.workout = readCurrentWorkoutFromFile();
     }
 
-    public void switchWorkout(Workout workout) throws IOException {
+    public void switchWorkout(Workout workout) throws WorkoutException {
         this.workout = workout;
         writeCurrentWorkoutToFile();
     }
 
-    public void saveCurrentWorkout() throws IOException {
+    public void saveCurrentWorkout() throws WorkoutException {
         writeCurrentWorkoutToFile();
     }
 
-    public Workout getWorkout() throws WorkoutNotFoundException {
+    public Workout getWorkout() throws WorkoutException {
         if (workout == null) {
-            throw new WorkoutNotFoundException();
+            throw new WorkoutException();
         }
         return workout;
     }
@@ -46,12 +52,16 @@ private Workout readCurrentWorkoutFromFile() {
         return workout;
     }
 
-    private void writeCurrentWorkoutToFile() throws IOException {
+    private void writeCurrentWorkoutToFile() throws WorkoutException {
         File file = new File(context.getDir("data", Context.MODE_PRIVATE), "currentWorkout");
-        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(file));
-        outputStream.writeObject(workout);
-        outputStream.flush();
-        outputStream.close();
+        try {
+            ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(file));
+            outputStream.writeObject(workout);
+            outputStream.flush();
+            outputStream.close();
+        } catch (IOException ioe) {
+            throw new WorkoutException(ioe);
+        }
 
     }
 }