com.osomapps.pt.programs.ProgramService.getPredefinedPrograms(String) - Code Metrics - Inspection of "Update package.json" - javadev/pt-backend - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 634ec8...dcf6e8 )

by Valentyn

created 2021-06-17 07:18 UTC

getPredefinedPrograms(String) B

↳ Parent: com.osomapps.pt.programs.ProgramService

Complexity

Conditions

Size

Total Lines	133
Code Lines	126

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
eloc	126
dl	0
loc	133
rs	7
c	4
b	0
f	0
cc	2

How to fix Long Method

package com.osomapps.pt.programs;

import com.osomapps.pt.estimation.CurveEstimation;
import com.osomapps.pt.token.InUserLogin;
import com.osomapps.pt.user.UserService;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.BooleanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Slf4j
@Service
class ProgramService {
    private final UserService userService;

    @Autowired
    ProgramService(UserService userService) {
        this.userService = userService;
    }

    List<ProgramResponseDTO> getPredefinedPrograms(String token) {
        if (token.isEmpty()) {
            return Collections.emptyList();
        }
        userService.checkUserToken(token);
        InProgram inProgram1 = new InProgram();
        inProgram1.setId(1L);
        inProgram1.setName("Test program 1");
        inProgram1.setD_program_type("test");
        InWorkout inWorkout11 = new InWorkout();
        inWorkout11.setId(1L);
        inWorkout11.setD_workout_name("Test workout 1");
        InWorkout inWorkout12 = new InWorkout();
        inWorkout12.setId(2L);
        inWorkout12.setD_workout_name("Test workout 2");
        inProgram1.setInWorkouts(Arrays.asList(inWorkout11, inWorkout12));
        InWarmupWorkoutItem inWarmupWorkoutItem111 = new InWarmupWorkoutItem();
        inWarmupWorkoutItem111.setId(0L);
        inWarmupWorkoutItem111.setExercise_id(800);
        inWarmupWorkoutItem111.setD_exercise_name("Treadmill");
        inWarmupWorkoutItem111.setSpeed(10);
        inWarmupWorkoutItem111.setIncline(2);
        inWarmupWorkoutItem111.setTime_in_sec(600);
        inWorkout11.setInWarmupWorkoutItems(Arrays.asList(inWarmupWorkoutItem111));
        InWorkoutItem inWorkoutItem111 = new InWorkoutItem();
        inWorkoutItem111.setId(1L);
        inWorkoutItem111.setExercise_id(210);
        inWorkoutItem111.setD_exercise_name("Deadlift");
        InWorkoutItemSet inWorkoutItemSet111 = new InWorkoutItemSet();
        inWorkoutItemSet111.setRepetitions(10);
        inWorkoutItemSet111.setWeight(75F);
        inWorkoutItem111.setInWorkoutItemSets(Arrays.asList(inWorkoutItemSet111));
        InWorkoutItem inWorkoutItem112 =
                new InWorkoutItem()
                        .setId(2L)
                        .setExercise_id(260)
                        .setD_exercise_name("Bench Press")
                        .setInWorkoutItemSets(
                                Arrays.asList(
                                        new InWorkoutItemSet().setRepetitions(10).setWeight(65F),
                                        new InWorkoutItemSet().setRepetitions(10).setWeight(65F),
                                        new InWorkoutItemSet().setRepetitions(10).setWeight(65F)));

        InWorkoutItem inWorkoutItem113 =
                new InWorkoutItem()
                        .setId(3L)
                        .setExercise_id(150)
                        .setD_exercise_name("Pull Up")
                        .setInWorkoutItemSets(
                                Arrays.asList(
                                        new InWorkoutItemSet()
                                                .setRepetitions(10)
                                                .setBodyweight(true)
                                                .setWeight(65F),
                                        new InWorkoutItemSet()
                                                .setRepetitions(10)
                                                .setBodyweight(true)
                                                .setWeight(65F),
                                        new InWorkoutItemSet()
                                                .setRepetitions(10)
                                                .setBodyweight(true)
                                                .setWeight(65F),
                                        new InWorkoutItemSet()
                                                .setRepetitions(10)
                                                .setBodyweight(true)
                                                .setWeight(65F)));

        InWorkoutItem inWorkoutItem114 =
                new InWorkoutItem()
                        .setId(4L)
                        .setExercise_id(530)
                        .setD_exercise_name("Dips")
                        .setInWorkoutItemSets(
                                Arrays.asList(
                                        new InWorkoutItemSet()
                                                .setRepetitions(10)
                                                .setBodyweight(true)
                                                .setWeight(65F),
                                        new InWorkoutItemSet()
                                                .setRepetitions(10)
                                                .setBodyweight(true)
                                                .setWeight(65F),
                                        new InWorkoutItemSet()
                                                .setRepetitions(10)
                                                .setBodyweight(true)
                                                .setWeight(65F)));

        InWorkoutItem inWorkoutItem115 =
                new InWorkoutItem()
                        .setId(5L)
                        .setExercise_id(440)
                        .setD_exercise_name("Plank")
                        .setD_exercise_type("OnTime")
                        .setInWorkoutItemSets(
                                Arrays.asList(
                                        new InWorkoutItemSet()
                                                .setTime_in_sec(120)
                                                .setBodyweight(true)
                                                .setWeight(65F)));

        InWorkoutItemSet inWorkoutItemSet1 =
                new InWorkoutItemSet().setIncline(2).setSpeed(8).setTime_in_sec(4);
        InWorkoutItemSet inWorkoutItemSet2 =
                new InWorkoutItemSet().setIncline(3).setSpeed(9).setTime_in_sec(4);
        InWorkoutItemSet inWorkoutItemSet3 =
                new InWorkoutItemSet().setIncline(4).setSpeed(10).setTime_in_sec(4);
        InWorkoutItemSet inWorkoutItemSet4 =
                new InWorkoutItemSet().setIncline(3).setSpeed(9).setTime_in_sec(4);
        InWorkoutItem inWorkoutItem116 =
                new InWorkoutItem()
                        .setId(6L)
                        .setExercise_id(820)
                        .setD_exercise_name("Treadmill 4x4")
                        .setD_exercise_type("OnIntervals")
                        .setInWorkoutItemSets(
                                Arrays.asList(
                                        inWorkoutItemSet1,
                                        inWorkoutItemSet2,
                                        inWorkoutItemSet3,
                                        inWorkoutItemSet4));

        inWorkout11.setInWorkoutItems(
                Arrays.asList(
                        inWorkoutItem111,
                        inWorkoutItem112,
                        inWorkoutItem113,
                        inWorkoutItem114,
                        inWorkoutItem115,
                        inWorkoutItem116));
        inProgram1.setInWorkouts(Arrays.asList(inWorkout11));

        ProgramResponseDTO program1 = createProgramResponseDTO(inProgram1);
        return Arrays.asList(program1);
    }

    List<ProgramResponseDTO> getExamples(String token) {
        if (token.isEmpty()) {
            return Collections.emptyList();
        }
        InUserLogin inUserLogin = userService.checkUserToken(token);
        List<InProgram> inPrograms = inUserLogin.getInUser().getInPrograms();
        if (inPrograms.isEmpty()) {
            return Collections.emptyList();
        }
        return inPrograms.stream()
                .sorted((p1, p2) -> Long.compare(p2.getId(), p1.getId()))
                .findFirst()
                .map(inProgram -> Arrays.asList(createProgramResponseDTO(inProgram)))
                .orElse(Collections.emptyList());
    }

    private ProgramResponseDTO createProgramResponseDTO(InProgram inProgram) {
        ProgramResponseDTO program = new ProgramResponseDTO();
        program.setId(inProgram.getId());
        program.setName(inProgram.getName());
        program.setType(
                inProgram.getD_program_type() == null ? "personal" : inProgram.getD_program_type());
        program.setWorkouts(new ArrayList<>());
        for (InWorkout inWorkout : inProgram.getInWorkouts()) {
            if (!Objects.equals(
                    inProgram.getCurrent_workout_index(), inWorkout.getWorkout_index())) {
                continue;
            }
            WorkoutResponseDTO workout = new WorkoutResponseDTO();
            workout.setId(inWorkout.getId());
            workout.setName(inWorkout.getD_workout_name());
            workout.setItems(new ArrayList<>());
            program.getWorkouts().add(workout);
            if (inWorkout.getInWarmupWorkoutItems() != null
                    && !inWorkout.getInWarmupWorkoutItems().isEmpty()) {
                InWarmupWorkoutItem inWarmupWorkoutItem =
                        inWorkout.getInWarmupWorkoutItems().get(0);
                WarmupWorkoutItemResponseDTO warmupWorkoutItem = new WarmupWorkoutItemResponseDTO();
                warmupWorkoutItem.setId(inWarmupWorkoutItem.getId());
                warmupWorkoutItem.setExercise_id(inWarmupWorkoutItem.getExercise_id());
                warmupWorkoutItem.setExercise_name(inWarmupWorkoutItem.getD_exercise_name());
                warmupWorkoutItem.setExercise_type("OnTime");
                warmupWorkoutItem.setSets(
                        Arrays.asList(
                                new WarmupWorkoutItemSetResponseDTO()
                                        .setSpeed(inWarmupWorkoutItem.getSpeed())
                                        .setIncline(inWarmupWorkoutItem.getIncline())
                                        .setTime_in_sec(inWarmupWorkoutItem.getTime_in_sec())));
                workout.setWarmup(warmupWorkoutItem);
            }
            for (InWorkoutItem inWorkoutItem : inWorkout.getInWorkoutItems()) {
                WorkoutItemResponseDTO workoutItem = new WorkoutItemResponseDTO();
                workoutItem.setId(inWorkoutItem.getId());
                workoutItem.setExercise_id(inWorkoutItem.getExercise_id());
                workoutItem.setExercise_name(inWorkoutItem.getD_exercise_name());
                workoutItem.setExercise_type(
                        inWorkoutItem.getD_exercise_type() == null
                                ? "OnRepetitions"
                                : inWorkoutItem.getD_exercise_type());
                workoutItem.setSets(
                        inWorkoutItem.getInWorkoutItemSets().stream()
                                .map(set -> generateWorkoutItemSetResponse(set))
                                .collect(Collectors.toList()));
                workout.getItems().add(workoutItem);
            }
        }
        return program;
    }

    private WorkoutItemSetResponseDTO generateWorkoutItemSetResponse(InWorkoutItemSet set) {
        if ("Weight".equalsIgnoreCase(set.getExercise_basis())) {
            final List<InWorkoutItemSetReport> previousSetReports =
                    getPreviousInWorkoutItemSets(set);
            Optional<Integer> diffPercent = calculateDiffInPercent(previousSetReports, set);
            if (diffPercent.isPresent()) {
                float newPercent = CurveEstimation.of(1, 0, 2.5F, 2, 50).calc(diffPercent.get());
                float newWeight = roundToEven(set.getWeight() * (1 + newPercent / 100f));
                log.info(
                        "New weigh was calculated, base weight - {}, new weight - {}, diff - {}",
                        set.getWeight(),
                        newWeight,
                        newWeight - set.getWeight());
                return new WorkoutItemSetResponseDTO()
                        .setRepetitions(set.getRepetitions())
                        .setWeight(newWeight)
                        .setBodyweight(BooleanUtils.isTrue(set.getBodyweight()))
                        .setTime_in_sec(set.getTime_in_sec())
                        .setSpeed(set.getSpeed())
                        .setIncline(set.getIncline())
                        .setResistance(set.getResistance());
            }
        }
        return new WorkoutItemSetResponseDTO()
                .setRepetitions(set.getRepetitions())
                .setWeight(set.getWeight())
                .setBodyweight(BooleanUtils.isTrue(set.getBodyweight()))
                .setTime_in_sec(set.getTime_in_sec())
                .setSpeed(set.getSpeed())
                .setIncline(set.getIncline())
                .setResistance(set.getResistance());
    }

    float roundToEven(Float floatValue) {
        return floatValue.intValue() - floatValue.intValue() % 2;

    }

    private List<InWorkoutItemSetReport> getPreviousInWorkoutItemSets(InWorkoutItemSet set) {
        if (set.getInWorkoutItem().getInWorkoutItemReports().isEmpty()) {
            return Collections.emptyList();
        }
        return set.getInWorkoutItem()
                .getInWorkoutItemReports()
                .get(set.getInWorkoutItem().getInWorkoutItemReports().size() - 1)
                .getInWorkoutItemSetReports();
    }

    Optional<Integer> calculateDiffInPercent(
            List<InWorkoutItemSetReport> previousSetReport, InWorkoutItemSet set) {
        if (previousSetReport.isEmpty()) {
            return Optional.empty();
        }
        long prevRepetitions =
                previousSetReport.stream()
                        .collect(Collectors.summarizingInt(InWorkoutItemSetReport::getRepetitions))
                        .getSum();
        long curRepetitions =
                set.getInWorkoutItem().getInWorkoutItemSets().stream()
                        .collect(Collectors.summarizingInt(InWorkoutItemSet::getRepetitions))
                        .getSum();
        Integer result =
                Float.valueOf((prevRepetitions - curRepetitions) / (float) curRepetitions * 100)

                        .intValue();
        log.info(
                "New reps diff was calculated, previous reps - {}, current reps - {}, diff - {}",
                prevRepetitions,
                curRepetitions,
                result);
        return Optional.of(result);
    }
}


1			package com.osomapps.pt.programs;
2
3			import com.osomapps.pt.estimation.CurveEstimation;
4			import com.osomapps.pt.token.InUserLogin;
5			import com.osomapps.pt.user.UserService;
6			import java.util.ArrayList;
7			import java.util.Arrays;
8			import java.util.Collections;
9			import java.util.List;
10			import java.util.Objects;
11			import java.util.Optional;
12			import java.util.stream.Collectors;
13			import lombok.extern.slf4j.Slf4j;
14			import org.apache.commons.lang3.BooleanUtils;
15			import org.springframework.beans.factory.annotation.Autowired;
16			import org.springframework.stereotype.Service;
17
18			@Slf4j
19			@Service
20			class ProgramService {
21			private final UserService userService;
22
23			@Autowired
24			ProgramService(UserService userService) {
25			this.userService = userService;
26			}
27
28			List<ProgramResponseDTO> getPredefinedPrograms(String token) {
29			if (token.isEmpty()) {
30			return Collections.emptyList();
31			}
32			userService.checkUserToken(token);
33			InProgram inProgram1 = new InProgram();
34			inProgram1.setId(1L);
35			inProgram1.setName("Test program 1");
36			inProgram1.setD_program_type("test");
37			InWorkout inWorkout11 = new InWorkout();
38			inWorkout11.setId(1L);
39			inWorkout11.setD_workout_name("Test workout 1");
40			InWorkout inWorkout12 = new InWorkout();
41			inWorkout12.setId(2L);
42			inWorkout12.setD_workout_name("Test workout 2");
43			inProgram1.setInWorkouts(Arrays.asList(inWorkout11, inWorkout12));
44			InWarmupWorkoutItem inWarmupWorkoutItem111 = new InWarmupWorkoutItem();
45			inWarmupWorkoutItem111.setId(0L);
46			inWarmupWorkoutItem111.setExercise_id(800);
47			inWarmupWorkoutItem111.setD_exercise_name("Treadmill");
48			inWarmupWorkoutItem111.setSpeed(10);
49			inWarmupWorkoutItem111.setIncline(2);
50			inWarmupWorkoutItem111.setTime_in_sec(600);
51			inWorkout11.setInWarmupWorkoutItems(Arrays.asList(inWarmupWorkoutItem111));
52			InWorkoutItem inWorkoutItem111 = new InWorkoutItem();
53			inWorkoutItem111.setId(1L);
54			inWorkoutItem111.setExercise_id(210);
55			inWorkoutItem111.setD_exercise_name("Deadlift");
56			InWorkoutItemSet inWorkoutItemSet111 = new InWorkoutItemSet();
57			inWorkoutItemSet111.setRepetitions(10);
58			inWorkoutItemSet111.setWeight(75F);
59			inWorkoutItem111.setInWorkoutItemSets(Arrays.asList(inWorkoutItemSet111));
60			InWorkoutItem inWorkoutItem112 =
61			new InWorkoutItem()
62			.setId(2L)
63			.setExercise_id(260)
64			.setD_exercise_name("Bench Press")
65			.setInWorkoutItemSets(
66			Arrays.asList(
67			new InWorkoutItemSet().setRepetitions(10).setWeight(65F),
68			new InWorkoutItemSet().setRepetitions(10).setWeight(65F),
69			new InWorkoutItemSet().setRepetitions(10).setWeight(65F)));
70
71			InWorkoutItem inWorkoutItem113 =
72			new InWorkoutItem()
73			.setId(3L)
74			.setExercise_id(150)
75			.setD_exercise_name("Pull Up")
76			.setInWorkoutItemSets(
77			Arrays.asList(
78			new InWorkoutItemSet()
79			.setRepetitions(10)
80			.setBodyweight(true)
81			.setWeight(65F),
82			new InWorkoutItemSet()
83			.setRepetitions(10)
84			.setBodyweight(true)
85			.setWeight(65F),
86			new InWorkoutItemSet()
87			.setRepetitions(10)
88			.setBodyweight(true)
89			.setWeight(65F),
90			new InWorkoutItemSet()
91			.setRepetitions(10)
92			.setBodyweight(true)
93			.setWeight(65F)));
94
95			InWorkoutItem inWorkoutItem114 =
96			new InWorkoutItem()
97			.setId(4L)
98			.setExercise_id(530)
99			.setD_exercise_name("Dips")
100			.setInWorkoutItemSets(
101			Arrays.asList(
102			new InWorkoutItemSet()
103			.setRepetitions(10)
104			.setBodyweight(true)
105			.setWeight(65F),
106			new InWorkoutItemSet()
107			.setRepetitions(10)
108			.setBodyweight(true)
109			.setWeight(65F),
110			new InWorkoutItemSet()
111			.setRepetitions(10)
112			.setBodyweight(true)
113			.setWeight(65F)));
114
115			InWorkoutItem inWorkoutItem115 =
116			new InWorkoutItem()
117			.setId(5L)
118			.setExercise_id(440)
119			.setD_exercise_name("Plank")
120			.setD_exercise_type("OnTime")
121			.setInWorkoutItemSets(
122			Arrays.asList(
123			new InWorkoutItemSet()
124			.setTime_in_sec(120)
125			.setBodyweight(true)
126			.setWeight(65F)));
127
128			InWorkoutItemSet inWorkoutItemSet1 =
129			new InWorkoutItemSet().setIncline(2).setSpeed(8).setTime_in_sec(4);
130			InWorkoutItemSet inWorkoutItemSet2 =
131			new InWorkoutItemSet().setIncline(3).setSpeed(9).setTime_in_sec(4);
132			InWorkoutItemSet inWorkoutItemSet3 =
133			new InWorkoutItemSet().setIncline(4).setSpeed(10).setTime_in_sec(4);
134			InWorkoutItemSet inWorkoutItemSet4 =
135			new InWorkoutItemSet().setIncline(3).setSpeed(9).setTime_in_sec(4);
136			InWorkoutItem inWorkoutItem116 =
137			new InWorkoutItem()
138			.setId(6L)
139			.setExercise_id(820)
140			.setD_exercise_name("Treadmill 4x4")
141			.setD_exercise_type("OnIntervals")
142			.setInWorkoutItemSets(
143			Arrays.asList(
144			inWorkoutItemSet1,
145			inWorkoutItemSet2,
146			inWorkoutItemSet3,
147			inWorkoutItemSet4));
148
149			inWorkout11.setInWorkoutItems(
150			Arrays.asList(
151			inWorkoutItem111,
152			inWorkoutItem112,
153			inWorkoutItem113,
154			inWorkoutItem114,
155			inWorkoutItem115,
156			inWorkoutItem116));
157			inProgram1.setInWorkouts(Arrays.asList(inWorkout11));
158
159			ProgramResponseDTO program1 = createProgramResponseDTO(inProgram1);
160			return Arrays.asList(program1);
161			}
162
163			List<ProgramResponseDTO> getExamples(String token) {
164			if (token.isEmpty()) {
165			return Collections.emptyList();
166			}
167			InUserLogin inUserLogin = userService.checkUserToken(token);
168			List<InProgram> inPrograms = inUserLogin.getInUser().getInPrograms();
169			if (inPrograms.isEmpty()) {
170			return Collections.emptyList();
171			}
172			return inPrograms.stream()
173			.sorted((p1, p2) -> Long.compare(p2.getId(), p1.getId()))
174			.findFirst()
175			.map(inProgram -> Arrays.asList(createProgramResponseDTO(inProgram)))
176			.orElse(Collections.emptyList());
177			}
178
179			private ProgramResponseDTO createProgramResponseDTO(InProgram inProgram) {
180			ProgramResponseDTO program = new ProgramResponseDTO();
181			program.setId(inProgram.getId());
182			program.setName(inProgram.getName());
183			program.setType(
184			inProgram.getD_program_type() == null ? "personal" : inProgram.getD_program_type());
185			program.setWorkouts(new ArrayList<>());
186			for (InWorkout inWorkout : inProgram.getInWorkouts()) {
187			if (!Objects.equals(
188			inProgram.getCurrent_workout_index(), inWorkout.getWorkout_index())) {
189			continue;
190			}
191			WorkoutResponseDTO workout = new WorkoutResponseDTO();
192			workout.setId(inWorkout.getId());
193			workout.setName(inWorkout.getD_workout_name());
194			workout.setItems(new ArrayList<>());
195			program.getWorkouts().add(workout);
196			if (inWorkout.getInWarmupWorkoutItems() != null
197			&& !inWorkout.getInWarmupWorkoutItems().isEmpty()) {
198			InWarmupWorkoutItem inWarmupWorkoutItem =
199			inWorkout.getInWarmupWorkoutItems().get(0);
200			WarmupWorkoutItemResponseDTO warmupWorkoutItem = new WarmupWorkoutItemResponseDTO();
201			warmupWorkoutItem.setId(inWarmupWorkoutItem.getId());
202			warmupWorkoutItem.setExercise_id(inWarmupWorkoutItem.getExercise_id());
203			warmupWorkoutItem.setExercise_name(inWarmupWorkoutItem.getD_exercise_name());
204			warmupWorkoutItem.setExercise_type("OnTime");
205			warmupWorkoutItem.setSets(
206			Arrays.asList(
207			new WarmupWorkoutItemSetResponseDTO()
208			.setSpeed(inWarmupWorkoutItem.getSpeed())
209			.setIncline(inWarmupWorkoutItem.getIncline())
210			.setTime_in_sec(inWarmupWorkoutItem.getTime_in_sec())));
211			workout.setWarmup(warmupWorkoutItem);
212			}
213			for (InWorkoutItem inWorkoutItem : inWorkout.getInWorkoutItems()) {
214			WorkoutItemResponseDTO workoutItem = new WorkoutItemResponseDTO();
215			workoutItem.setId(inWorkoutItem.getId());
216			workoutItem.setExercise_id(inWorkoutItem.getExercise_id());
217			workoutItem.setExercise_name(inWorkoutItem.getD_exercise_name());
218			workoutItem.setExercise_type(
219			inWorkoutItem.getD_exercise_type() == null
220			? "OnRepetitions"
221			: inWorkoutItem.getD_exercise_type());
222			workoutItem.setSets(
223			inWorkoutItem.getInWorkoutItemSets().stream()
224			.map(set -> generateWorkoutItemSetResponse(set))
225			.collect(Collectors.toList()));
226			workout.getItems().add(workoutItem);
227			}
228			}
229			return program;
230			}
231
232			private WorkoutItemSetResponseDTO generateWorkoutItemSetResponse(InWorkoutItemSet set) {
233			if ("Weight".equalsIgnoreCase(set.getExercise_basis())) {
234			final List<InWorkoutItemSetReport> previousSetReports =
235			getPreviousInWorkoutItemSets(set);
236			Optional<Integer> diffPercent = calculateDiffInPercent(previousSetReports, set);
237			if (diffPercent.isPresent()) {
238			float newPercent = CurveEstimation.of(1, 0, 2.5F, 2, 50).calc(diffPercent.get());
239			float newWeight = roundToEven(set.getWeight() * (1 + newPercent / 100f));
240			log.info(
241			"New weigh was calculated, base weight - {}, new weight - {}, diff - {}",
242			set.getWeight(),
243			newWeight,
244			newWeight - set.getWeight());
245			return new WorkoutItemSetResponseDTO()
246			.setRepetitions(set.getRepetitions())
247			.setWeight(newWeight)
248			.setBodyweight(BooleanUtils.isTrue(set.getBodyweight()))
249			.setTime_in_sec(set.getTime_in_sec())
250			.setSpeed(set.getSpeed())
251			.setIncline(set.getIncline())
252			.setResistance(set.getResistance());
253			}
254			}
255			return new WorkoutItemSetResponseDTO()
256			.setRepetitions(set.getRepetitions())
257			.setWeight(set.getWeight())
258			.setBodyweight(BooleanUtils.isTrue(set.getBodyweight()))
259			.setTime_in_sec(set.getTime_in_sec())
260			.setSpeed(set.getSpeed())
261			.setIncline(set.getIncline())
262			.setResistance(set.getResistance());
263			}
264
265			float roundToEven(Float floatValue) {
266			return floatValue.intValue() - floatValue.intValue() % 2;
			0 ignored issues – show Bug introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report Math operands should be cast to prevent unwanted loss of precision when mixing types. Consider casting one of the operands of this subtraction to float. Loading history...
267			}
268
269			private List<InWorkoutItemSetReport> getPreviousInWorkoutItemSets(InWorkoutItemSet set) {
270			if (set.getInWorkoutItem().getInWorkoutItemReports().isEmpty()) {
271			return Collections.emptyList();
272			}
273			return set.getInWorkoutItem()
274			.getInWorkoutItemReports()
275			.get(set.getInWorkoutItem().getInWorkoutItemReports().size() - 1)
276			.getInWorkoutItemSetReports();
277			}
278
279			Optional<Integer> calculateDiffInPercent(
280			List<InWorkoutItemSetReport> previousSetReport, InWorkoutItemSet set) {
281			if (previousSetReport.isEmpty()) {
282			return Optional.empty();
283			}
284			long prevRepetitions =
285			previousSetReport.stream()
286			.collect(Collectors.summarizingInt(InWorkoutItemSetReport::getRepetitions))
287			.getSum();
288			long curRepetitions =
289			set.getInWorkoutItem().getInWorkoutItemSets().stream()
290			.collect(Collectors.summarizingInt(InWorkoutItemSet::getRepetitions))
291			.getSum();
292			Integer result =
293			Float.valueOf((prevRepetitions - curRepetitions) / (float) curRepetitions * 100)
			0 ignored issues – show Best Practice introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report Immediately boxing and unboxing a primitive has no effect. Consider removing the boxing to `Float` For an explanation of boxing and autoboxing, please refer to the Java tutorial. Loading history...
294			.intValue();
295			log.info(
296			"New reps diff was calculated, previous reps - {}, current reps - {}, diff - {}",
297			prevRepetitions,
298			curRepetitions,
299			result);
300			return Optional.of(result);
301			}
302			}
303

javadev / pt-backend

Push — master ( 634ec8...dcf6e8 )

getPredefinedPrograms(String) B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like