com.osomapps.pt.admin.program.AdminProgramAssignService.multiplyLists(List,Integer) - Code Metrics - Inspection of "Fix NPE while creating user." - javadev/pt-backend - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( c56ed7...f22d86 )

by Valentyn

created 2018-12-10 14:59 UTC

multiplyLists(List,Integer) A

↳ Parent: com.osomapps.pt.admin.program.AdminProgramAssignService

Complexity

Conditions

Size

Total Lines	11
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	8
dl	0
loc	11
c	1
b	0
f	0
rs	10
cc	3

package com.osomapps.pt.admin.program;

import com.osomapps.pt.dictionary.DictionaryName;
import com.osomapps.pt.dictionary.DictionaryService;
import com.osomapps.pt.exercises.Exercise;
import com.osomapps.pt.exercises.ExerciseRepository;
import com.osomapps.pt.programs.InProgram;
import com.osomapps.pt.programs.InProgramRepository;
import com.osomapps.pt.programs.InWarmupWorkoutItem;
import com.osomapps.pt.programs.InWarmupWorkoutItemRepository;
import com.osomapps.pt.programs.InWorkout;
import com.osomapps.pt.programs.InWorkoutItem;
import com.osomapps.pt.programs.InWorkoutItemSet;
import com.osomapps.pt.programs.InWorkoutRepository;
import com.osomapps.pt.programs.ParseExercise;
import com.osomapps.pt.programs.ParseWorkout;
import com.osomapps.pt.reportworkout.InWorkoutItemRepository;
import com.osomapps.pt.token.InUser;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import org.springframework.stereotype.Service;
import com.osomapps.pt.programs.ParseProgram;
import com.osomapps.pt.programs.ParseProgramRepository;
import com.osomapps.pt.programs.ParseRound;
import com.osomapps.pt.programs.ParseWorkoutItem;
import com.osomapps.pt.programs.ParseWorkoutItemSet;
import com.osomapps.pt.reportworkout.InWorkoutItemSetRepository;
import com.osomapps.pt.token.InUserGoal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Sort;

@Slf4j
@Service
public class AdminProgramAssignService {

    private final InProgramRepository inProgramRepository;
    private final InWorkoutRepository inWorkoutRepository;
    private final InWorkoutItemRepository inWorkoutItemRepository;
    private final InWorkoutItemSetRepository inWorkoutItemSetRepository;
    private final ParseProgramRepository parseProgramRepository;
    private final InWarmupWorkoutItemRepository inWarmupWorkoutItemRepository;
    private final DictionaryService dictionaryService;
    private final ExerciseRepository exerciseRepository;

    AdminProgramAssignService(InProgramRepository inProgramRepository,

            InWorkoutRepository inWorkoutRepository,
            InWorkoutItemRepository inWorkoutItemRepository,
            InWorkoutItemSetRepository inWorkoutItemSetRepository,
            ParseProgramRepository parseProgramRepository,
            InWarmupWorkoutItemRepository inWarmupWorkoutItemRepository,
            DictionaryService dictionaryService,
            ExerciseRepository exerciseRepository) {
        this.inProgramRepository = inProgramRepository;
        this.inWorkoutRepository = inWorkoutRepository;
        this.inWorkoutItemRepository = inWorkoutItemRepository;
        this.inWorkoutItemSetRepository = inWorkoutItemSetRepository;
        this.parseProgramRepository = parseProgramRepository;
        this.inWarmupWorkoutItemRepository = inWarmupWorkoutItemRepository;
        this.dictionaryService = dictionaryService;
        this.exerciseRepository = exerciseRepository;
    }

    public InUser assign(InUser inUser) {

        List<ParseProgram> parsePrograms = parseProgramRepository.findAll(new Sort(Sort.Direction.DESC, "id"));
        if (parsePrograms.isEmpty()) {
            log.warn("There are no programs found.");
            return inUser;
        }
        Optional<Integer> userGroup = getUserGroup(inUser);
        if (!userGroup.isPresent()) {
            log.warn("User group not recognized, level - {}, gender - {}", inUser.getD_level(), inUser.getD_sex());
            return inUser;
        }
        if (inUser.getInUserGoals().isEmpty()) {
            log.warn("Cannot create program for user without goals.");
            return inUser;
        }
        List<ParseRound> parseRounds = getRoundsGorGoalAndUserGroup(parsePrograms,
                inUser.getInUserGoals().get(0), userGroup.get());
        final List<ParseWorkout> parseWorkouts;
        final List<String> goalNames = new ArrayList<>();
        if (!parseRounds.isEmpty()) {
            goalNames.add(parseRounds.get(0).getParseUserGroup().getParseGoal().getName());
        }
        if (inUser.getInUserGoals().size() > 1) {
            List<ParseRound> parseRounds2 = getRoundsGorGoalAndUserGroup(parsePrograms,
                    inUser.getInUserGoals().get(1), userGroup.get());
            parseWorkouts = mergeLists(getParseWorkouts(parseRounds), getParseWorkouts(parseRounds2));
            if (!parseRounds2.isEmpty()) {
                goalNames.add(parseRounds2.get(0).getParseUserGroup().getParseGoal().getName());
            }
        } else {
            parseWorkouts = getParseWorkouts(parseRounds);
        }
        final AtomicInteger index = new AtomicInteger(-1);
        final InProgram inProgram = new InProgram()
                .setName("Test program for user " + inUser.getId())
                .setCurrent_workout_index(getCurrentWorkoutIndex(inUser, parseWorkouts))
                .setInWorkouts(parseWorkouts.stream().map(parseWorkout
                        -> new InWorkout()
                        .setD_workout_name(parseWorkout.getName())
                        .setWorkout_index(index.incrementAndGet())
                        .setPart_name(parseWorkout.getParsePart().getName())
                        .setGoal_index(goalNames.indexOf(parseWorkout.getParsePart().getParseRound().getParseUserGroup().getParseGoal().getName()))
                        .setInWarmupWorkoutItems(parseWorkout.getParseWarmupWorkoutItems().stream().map(parseWarmupWorkoutItem
                                -> new InWarmupWorkoutItem()
                                .setD_exercise_name(parseWarmupWorkoutItem.getName())
                                .setExercise_id(parseWarmupWorkoutItem.getExercise_id())
                                .setTime_in_sec(minToSec(parseWarmupWorkoutItem.getTime_in_min()))
                                .setSpeed(parseWarmupWorkoutItem.getSpeed())
                                .setIncline(parseWarmupWorkoutItem.getIncline())
                        ).collect(Collectors.toList()))
                        .setInWorkoutItems(parseWorkout.getParseWorkoutItems().stream().map(parseWorkoutItem
                                -> new InWorkoutItem()
                                .setD_exercise_name(parseWorkoutItem.getName())
                                .setExercise_id(parseWorkoutItem.getExercise_id())
                                .setD_exercise_type(getExerciseType(parseWorkoutItem))
                                .setInWorkoutItemSets(parseWorkoutItem.getParseWorkoutItemSets().stream().map(parseWorkoutItemSet
                                        -> generateInWorkoutItemSet(parseWorkoutItemSet,
                                                parsePrograms.get(0).getParseExercises(), inUser.getWeight())
                                ).collect(Collectors.toList()))
                                .setInWorkoutItemReports(Collections.emptyList())
                        ).collect(Collectors.toList()))).collect(Collectors.toList()));
        inProgram.setInUser(inUser);
        inProgram.getInWorkouts().forEach(inWorkout -> {
            inWorkout.setInProgram(inProgram);
            inWorkout.getInWarmupWorkoutItems().forEach(inWarmupWorkoutItem -> {

                inWarmupWorkoutItem.setInWorkout(inWorkout);
            });
            inWorkout.getInWorkoutItems().forEach(inWorkoutItem -> {
                inWorkoutItem.setInWorkout(inWorkout);
                inWorkoutItem.getInWorkoutItemSets().forEach(inWorkoutItemSet -> {

                    inWorkoutItemSet.setInWorkoutItem(inWorkoutItem);
                });
            });
        });
        inProgramRepository.save(inProgram);
        inWorkoutRepository.save(inProgram.getInWorkouts());
        inProgram.getInWorkouts().forEach(inWorkout -> {
            inWarmupWorkoutItemRepository.save(inWorkout.getInWarmupWorkoutItems());
            inWorkoutItemRepository.save(inWorkout.getInWorkoutItems());
            inWorkout.getInWorkoutItems().forEach(inWorkoutItem -> {

                inWorkoutItemSetRepository.save(inWorkoutItem.getInWorkoutItemSets());
            });
        });
        return inUser;
    }

    int getCurrentWorkoutIndex(InUser inUser, List<ParseWorkout> parseWorkouts) {
        if (inUser.getInPrograms() == null || inUser.getInPrograms().isEmpty()) {
            return 0;
        }
        final InProgram inProgram = inUser.getInPrograms().get(inUser.getInPrograms().size() - 1);
        if (parseWorkouts.isEmpty() || parseWorkouts.size() != inProgram.getInWorkouts().size()) {
            return 0;
        }
        final InWorkout inWorkout = inProgram.getInWorkouts().get(inProgram.getCurrent_workout_index());
        if (parseWorkouts.get(inProgram.getCurrent_workout_index()).getName().equals(inWorkout.getD_workout_name())) {
            return inProgram.getCurrent_workout_index();
        }
        return 0;
    }

    private InWorkoutItemSet generateInWorkoutItemSet(ParseWorkoutItemSet parseWorkoutItemSet,
            List<ParseExercise> parseExercises, Float userWeight) {
        Optional<ParseExercise> parseExercise = parseExercises.stream().filter(
                exercise -> Objects.equals(exercise.getExercise_id(),
                parseWorkoutItemSet.getParseWorkoutItem().getExercise_id())).findFirst();
        Integer userGroup = Integer.parseInt(parseWorkoutItemSet.getParseWorkoutItem()
                .getParseWorkout().getParsePart().getParseRound().getParseUserGroup().getName());
        final Integer exercise_percent;
        if (parseExercise.isPresent()) {
            switch (userGroup) {
                case 1:
                    exercise_percent = parseExercise.get().getUser_group_1_percent();
                    break;
                case 2:
                    exercise_percent = parseExercise.get().getUser_group_2_percent();
                    break;
                case 3:
                    exercise_percent = parseExercise.get().getUser_group_3_percent();
                    break;
                case 4:
                    exercise_percent = parseExercise.get().getUser_group_4_percent();
                    break;
                default:
                    exercise_percent = 100;
            }
        } else {
            exercise_percent = 100;
        }
        final String exerciseBasis = parseExercise.isPresent()
                ? parseExercise.get().getBasis_for_calculations() : "";
        final Integer exerciseWeightPercent = Arrays.asList("Weight", "Time").contains(exerciseBasis)
                ? exercise_percent : null;
        final Integer exerciseRepetitionsPercent = "Reps".equals(exerciseBasis) ? exercise_percent : null;
        final Integer exerciseTimePercent = "Time".equals(exerciseBasis) ? exercise_percent : null;
        final Integer exerciseSpeedPercent = "Speed".equals(exerciseBasis) ? exercise_percent : null;
        return new InWorkoutItemSet()
                .setExercise_repetitions_percent(exerciseRepetitionsPercent)
                .setGoal_repetitions(parseWorkoutItemSet.getRepetitions())
                .setRepetitions(parseWorkoutItemSet.getRepetitions())
                .setRepetitions_to_failure(parseWorkoutItemSet.getRepetitions_to_failure())
                .setExercise_weight_percent(exerciseWeightPercent)
                .setGoal_weight_coef(parseWorkoutItemSet.getWeight())
                .setWeight(generateWeight(parseWorkoutItemSet.getWeight(),
                        exerciseWeightPercent, getWeightForUserGroup(userWeight, userGroup)))
                .setBodyweight(parseWorkoutItemSet.getBodyweight())
                .setExercise_time_percent(exerciseTimePercent)
                .setGoal_time_in_sec(minToSec(parseWorkoutItemSet.getTime_in_min()))
                .setTime_in_sec(minToSec(parseWorkoutItemSet.getTime_in_min()))
                .setExercise_speed_percent(exerciseSpeedPercent)
                .setGoal_speed(parseWorkoutItemSet.getSpeed())
                .setSpeed(parseWorkoutItemSet.getSpeed())
                .setIncline(parseWorkoutItemSet.getIncline())
                .setResistance(parseWorkoutItemSet.getResistance())
                .setExercise_basis(exerciseBasis);
    }

    Float getWeightForUserGroup(Float userWeight, Integer userGroup) {
        if (userWeight == null) {
            return null;
        }
        switch (userGroup) {
            case 1:
            case 2:
                return Math.min(100F, userWeight);
            case 3:
            case 4:
                return Math.min(75F, userWeight);
            default:
                return userWeight;
        }
    }

    private Float generateWeight(Float goalWeightCoef, Integer exerciseWeightPercent, Float userWeight) {
        if (goalWeightCoef != null && exerciseWeightPercent != null && userWeight != null) {
            return roundToEven(userWeight * goalWeightCoef * exerciseWeightPercent / 100);
        }
        return goalWeightCoef;
    }

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

    }

    private Integer minToSec(Float value) {
        return value == null ? null : Float.valueOf(value * 60).intValue();

    }

    private List<ParseRound> getRoundsGorGoalAndUserGroup(List<ParseProgram> parsePrograms,
            InUserGoal inUserGoal, Integer userGroup) {
        final List<ParseRound> parseRounds = new ArrayList<>();
        parsePrograms.get(0).getParseGoals().forEach(parseGoal -> {
            boolean nameFound = getOnlySymbols(parseGoal.getName()).equalsIgnoreCase(
                    getOnlySymbols(getGoalName(inUserGoal)));
            if (nameFound) {
                final List<ParseRound> localParseRounds = new ArrayList<>();
                parseGoal.getParseUserGroups().forEach(parseUserGroup -> {
                    if (parseUserGroup.getName().equals("" + userGroup)) {
                        localParseRounds.addAll(parseUserGroup.getParseRounds());
                    }
                });
                parseRounds.addAll(multiplyLists(localParseRounds, parseGoal.getLoops()));
            }
        });
        return parseRounds;
    }

    List<ParseRound> multiplyLists(List<ParseRound> parseRounds, Integer loops) {
        if (loops == null) {
            return parseRounds;
        }
        final List<ParseRound> result = new ArrayList<>(parseRounds.size() * loops);
        parseRounds.forEach(parseRound -> {
            for (int index = 0; index < loops; index += 1) {
                result.add(parseRound);
            }
        });
        return result;
    }

    private String getOnlySymbols(String value) {
        return value.replace("on a specific distance", "").replace("ednurance", "endurance")
                .replaceAll("[\\s\\.\\,]+", "");
    }

    private String getGoalName(InUserGoal inUserGoal) {
        return Arrays.asList(dictionaryService.getEnValue(DictionaryName.goal_title,
                inUserGoal.getD_goal_title(), null),
                dictionaryService.getEnValue(DictionaryName.goal_title_2,
                        inUserGoal.getD_goal_title_2(), null)).stream().filter(Objects::nonNull).collect(Collectors.joining(", "));
    }

    private List<ParseWorkout> getParseWorkouts(List<ParseRound> parseRounds) {
        final List<ParseWorkout> parseWorkouts = new ArrayList<>();
        parseRounds.forEach(parseRound -> {

            parseRound.getParseParts().forEach(parsePart -> {

                parsePart.getParseWorkouts().forEach(parseWorkout -> {

                    parseWorkouts.add(parseWorkout);
                });
            });
        });
        return parseWorkouts;
    }

    List<ParseWorkout> mergeLists(List<ParseWorkout> parseWorkouts1, List<ParseWorkout> parseWorkouts2) {
        final List<ParseWorkout> parseWorkouts = new ArrayList<>();
        for (int index = 0; index < Math.max(parseWorkouts1.size(), parseWorkouts2.size()); index += 1) {
            if (!parseWorkouts1.isEmpty()) {
                parseWorkouts.add(parseWorkouts1.get(index % parseWorkouts1.size()));
            }
            if (!parseWorkouts2.isEmpty()) {
                parseWorkouts.add(parseWorkouts2.get(index % parseWorkouts2.size()));
            }
        }
        return parseWorkouts;
    }

    String getExerciseType(ParseWorkoutItem parseWorkoutItem) {
        List<Exercise> exercises = exerciseRepository.findByExerciseId(parseWorkoutItem.getExercise_id());
        if (exercises.isEmpty()) {
            return "OnRepetitions";
        }
        if (exercises.get(0).getExerciseTypes().size() == 1) {
            return exercises.get(0).getExerciseTypes().get(0).getName();
        }
        if (parseWorkoutItem.getParseWorkoutItemSets().stream()
                .filter(set -> set.getTime_in_min() != null).findFirst().isPresent()) {

            return "OnTime";
        }
        return "OnRepetitions";
    }

    enum Gender {
        male, female, unknown
    }

    enum Level {
        unexperienced, experienced, unknown
    }

    private Optional<Integer> getUserGroup(InUser inUser) {
        final Gender gender;
        if ("male".equalsIgnoreCase(inUser.getD_sex())) {
            gender = Gender.male;
        } else if ("female".equalsIgnoreCase(inUser.getD_sex())) {
            gender = Gender.female;
        } else {
            gender = Gender.unknown;
        }
        final Level level;
        if ("1".equalsIgnoreCase(inUser.getD_level())) {
            level = Level.unexperienced;
        } else if ("2".equalsIgnoreCase(inUser.getD_level())) {
            level = Level.experienced;
        } else {
            level = Level.unknown;
        }
        final Integer userGroup;
        if (gender == Gender.male && level == Level.experienced) {
            userGroup = 1;
        } else if (gender == Gender.male && level == Level.unexperienced) {
            userGroup = 2;
        } else if (gender == Gender.female && level == Level.experienced) {
            userGroup = 3;
        } else if (gender == Gender.female && level == Level.unexperienced) {
            userGroup = 4;
        } else {
            userGroup = null;
        }
        return Optional.ofNullable(userGroup);
    }
}


1			package com.osomapps.pt.admin.program;
2
3			import com.osomapps.pt.dictionary.DictionaryName;
4			import com.osomapps.pt.dictionary.DictionaryService;
5			import com.osomapps.pt.exercises.Exercise;
6			import com.osomapps.pt.exercises.ExerciseRepository;
7			import com.osomapps.pt.programs.InProgram;
8			import com.osomapps.pt.programs.InProgramRepository;
9			import com.osomapps.pt.programs.InWarmupWorkoutItem;
10			import com.osomapps.pt.programs.InWarmupWorkoutItemRepository;
11			import com.osomapps.pt.programs.InWorkout;
12			import com.osomapps.pt.programs.InWorkoutItem;
13			import com.osomapps.pt.programs.InWorkoutItemSet;
14			import com.osomapps.pt.programs.InWorkoutRepository;
15			import com.osomapps.pt.programs.ParseExercise;
16			import com.osomapps.pt.programs.ParseWorkout;
17			import com.osomapps.pt.reportworkout.InWorkoutItemRepository;
18			import com.osomapps.pt.token.InUser;
19			import java.util.Arrays;
20			import java.util.List;
21			import java.util.Optional;
22			import java.util.stream.Collectors;
23			import org.springframework.stereotype.Service;
24			import com.osomapps.pt.programs.ParseProgram;
25			import com.osomapps.pt.programs.ParseProgramRepository;
26			import com.osomapps.pt.programs.ParseRound;
27			import com.osomapps.pt.programs.ParseWorkoutItem;
28			import com.osomapps.pt.programs.ParseWorkoutItemSet;
29			import com.osomapps.pt.reportworkout.InWorkoutItemSetRepository;
30			import com.osomapps.pt.token.InUserGoal;
31			import java.util.ArrayList;
32			import java.util.Collections;
33			import java.util.Objects;
34			import java.util.concurrent.atomic.AtomicInteger;
35			import lombok.extern.slf4j.Slf4j;
36			import org.springframework.data.domain.Sort;
37
38			@Slf4j
39			@Service
40			public class AdminProgramAssignService {
41
42			private final InProgramRepository inProgramRepository;
43			private final InWorkoutRepository inWorkoutRepository;
44			private final InWorkoutItemRepository inWorkoutItemRepository;
45			private final InWorkoutItemSetRepository inWorkoutItemSetRepository;
46			private final ParseProgramRepository parseProgramRepository;
47			private final InWarmupWorkoutItemRepository inWarmupWorkoutItemRepository;
48			private final DictionaryService dictionaryService;
49			private final ExerciseRepository exerciseRepository;
50
51			AdminProgramAssignService(InProgramRepository inProgramRepository,
			0 ignored issues – show Comprehensibility introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report Constructor has 8 parameters, which is greater than 7 authorized. Loading history...
52			InWorkoutRepository inWorkoutRepository,
53			InWorkoutItemRepository inWorkoutItemRepository,
54			InWorkoutItemSetRepository inWorkoutItemSetRepository,
55			ParseProgramRepository parseProgramRepository,
56			InWarmupWorkoutItemRepository inWarmupWorkoutItemRepository,
57			DictionaryService dictionaryService,
58			ExerciseRepository exerciseRepository) {
59			this.inProgramRepository = inProgramRepository;
60			this.inWorkoutRepository = inWorkoutRepository;
61			this.inWorkoutItemRepository = inWorkoutItemRepository;
62			this.inWorkoutItemSetRepository = inWorkoutItemSetRepository;
63			this.parseProgramRepository = parseProgramRepository;
64			this.inWarmupWorkoutItemRepository = inWarmupWorkoutItemRepository;
65			this.dictionaryService = dictionaryService;
66			this.exerciseRepository = exerciseRepository;
67			}
68
69			public InUser assign(InUser inUser) {
70
71			List<ParseProgram> parsePrograms = parseProgramRepository.findAll(new Sort(Sort.Direction.DESC, "id"));
72			if (parsePrograms.isEmpty()) {
73			log.warn("There are no programs found.");
74			return inUser;
75			}
76			Optional<Integer> userGroup = getUserGroup(inUser);
77			if (!userGroup.isPresent()) {
78			log.warn("User group not recognized, level - {}, gender - {}", inUser.getD_level(), inUser.getD_sex());
79			return inUser;
80			}
81			if (inUser.getInUserGoals().isEmpty()) {
82			log.warn("Cannot create program for user without goals.");
83			return inUser;
84			}
85			List<ParseRound> parseRounds = getRoundsGorGoalAndUserGroup(parsePrograms,
86			inUser.getInUserGoals().get(0), userGroup.get());
87			final List<ParseWorkout> parseWorkouts;
88			final List<String> goalNames = new ArrayList<>();
89			if (!parseRounds.isEmpty()) {
90			goalNames.add(parseRounds.get(0).getParseUserGroup().getParseGoal().getName());
91			}
92			if (inUser.getInUserGoals().size() > 1) {
93			List<ParseRound> parseRounds2 = getRoundsGorGoalAndUserGroup(parsePrograms,
94			inUser.getInUserGoals().get(1), userGroup.get());
95			parseWorkouts = mergeLists(getParseWorkouts(parseRounds), getParseWorkouts(parseRounds2));
96			if (!parseRounds2.isEmpty()) {
97			goalNames.add(parseRounds2.get(0).getParseUserGroup().getParseGoal().getName());
98			}
99			} else {
100			parseWorkouts = getParseWorkouts(parseRounds);
101			}
102			final AtomicInteger index = new AtomicInteger(-1);
103			final InProgram inProgram = new InProgram()
104			.setName("Test program for user " + inUser.getId())
105			.setCurrent_workout_index(getCurrentWorkoutIndex(inUser, parseWorkouts))
106			.setInWorkouts(parseWorkouts.stream().map(parseWorkout
107			-> new InWorkout()
108			.setD_workout_name(parseWorkout.getName())
109			.setWorkout_index(index.incrementAndGet())
110			.setPart_name(parseWorkout.getParsePart().getName())
111			.setGoal_index(goalNames.indexOf(parseWorkout.getParsePart().getParseRound().getParseUserGroup().getParseGoal().getName()))
112			.setInWarmupWorkoutItems(parseWorkout.getParseWarmupWorkoutItems().stream().map(parseWarmupWorkoutItem
113			-> new InWarmupWorkoutItem()
114			.setD_exercise_name(parseWarmupWorkoutItem.getName())
115			.setExercise_id(parseWarmupWorkoutItem.getExercise_id())
116			.setTime_in_sec(minToSec(parseWarmupWorkoutItem.getTime_in_min()))
117			.setSpeed(parseWarmupWorkoutItem.getSpeed())
118			.setIncline(parseWarmupWorkoutItem.getIncline())
119			).collect(Collectors.toList()))
120			.setInWorkoutItems(parseWorkout.getParseWorkoutItems().stream().map(parseWorkoutItem
121			-> new InWorkoutItem()
122			.setD_exercise_name(parseWorkoutItem.getName())
123			.setExercise_id(parseWorkoutItem.getExercise_id())
124			.setD_exercise_type(getExerciseType(parseWorkoutItem))
125			.setInWorkoutItemSets(parseWorkoutItem.getParseWorkoutItemSets().stream().map(parseWorkoutItemSet
126			-> generateInWorkoutItemSet(parseWorkoutItemSet,
127			parsePrograms.get(0).getParseExercises(), inUser.getWeight())
128			).collect(Collectors.toList()))
129			.setInWorkoutItemReports(Collections.emptyList())
130			).collect(Collectors.toList()))).collect(Collectors.toList()));
131			inProgram.setInUser(inUser);
132			inProgram.getInWorkouts().forEach(inWorkout -> {
133			inWorkout.setInProgram(inProgram);
134			inWorkout.getInWarmupWorkoutItems().forEach(inWarmupWorkoutItem -> {
			0 ignored issues – show Java 8 introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report Remove useless curly braces around statement Loading history...
135			inWarmupWorkoutItem.setInWorkout(inWorkout);
136			});
137			inWorkout.getInWorkoutItems().forEach(inWorkoutItem -> {
138			inWorkoutItem.setInWorkout(inWorkout);
139			inWorkoutItem.getInWorkoutItemSets().forEach(inWorkoutItemSet -> {
			0 ignored issues – show Java 8 introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report Remove useless curly braces around statement Loading history...
140			inWorkoutItemSet.setInWorkoutItem(inWorkoutItem);
141			});
142			});
143			});
144			inProgramRepository.save(inProgram);
145			inWorkoutRepository.save(inProgram.getInWorkouts());
146			inProgram.getInWorkouts().forEach(inWorkout -> {
147			inWarmupWorkoutItemRepository.save(inWorkout.getInWarmupWorkoutItems());
148			inWorkoutItemRepository.save(inWorkout.getInWorkoutItems());
149			inWorkout.getInWorkoutItems().forEach(inWorkoutItem -> {
			0 ignored issues – show Java 8 introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report Remove useless curly braces around statement Loading history...
150			inWorkoutItemSetRepository.save(inWorkoutItem.getInWorkoutItemSets());
151			});
152			});
153			return inUser;
154			}
155
156			int getCurrentWorkoutIndex(InUser inUser, List<ParseWorkout> parseWorkouts) {
157			if (inUser.getInPrograms() == null \|\| inUser.getInPrograms().isEmpty()) {
158			return 0;
159			}
160			final InProgram inProgram = inUser.getInPrograms().get(inUser.getInPrograms().size() - 1);
161			if (parseWorkouts.isEmpty() \|\| parseWorkouts.size() != inProgram.getInWorkouts().size()) {
162			return 0;
163			}
164			final InWorkout inWorkout = inProgram.getInWorkouts().get(inProgram.getCurrent_workout_index());
165			if (parseWorkouts.get(inProgram.getCurrent_workout_index()).getName().equals(inWorkout.getD_workout_name())) {
166			return inProgram.getCurrent_workout_index();
167			}
168			return 0;
169			}
170
171			private InWorkoutItemSet generateInWorkoutItemSet(ParseWorkoutItemSet parseWorkoutItemSet,
172			List<ParseExercise> parseExercises, Float userWeight) {
173			Optional<ParseExercise> parseExercise = parseExercises.stream().filter(
174			exercise -> Objects.equals(exercise.getExercise_id(),
175			parseWorkoutItemSet.getParseWorkoutItem().getExercise_id())).findFirst();
176			Integer userGroup = Integer.parseInt(parseWorkoutItemSet.getParseWorkoutItem()
177			.getParseWorkout().getParsePart().getParseRound().getParseUserGroup().getName());
178			final Integer exercise_percent;
179			if (parseExercise.isPresent()) {
180			switch (userGroup) {
181			case 1:
182			exercise_percent = parseExercise.get().getUser_group_1_percent();
183			break;
184			case 2:
185			exercise_percent = parseExercise.get().getUser_group_2_percent();
186			break;
187			case 3:
188			exercise_percent = parseExercise.get().getUser_group_3_percent();
189			break;
190			case 4:
191			exercise_percent = parseExercise.get().getUser_group_4_percent();
192			break;
193			default:
194			exercise_percent = 100;
195			}
196			} else {
197			exercise_percent = 100;
198			}
199			final String exerciseBasis = parseExercise.isPresent()
200			? parseExercise.get().getBasis_for_calculations() : "";
201			final Integer exerciseWeightPercent = Arrays.asList("Weight", "Time").contains(exerciseBasis)
202			? exercise_percent : null;
203			final Integer exerciseRepetitionsPercent = "Reps".equals(exerciseBasis) ? exercise_percent : null;
204			final Integer exerciseTimePercent = "Time".equals(exerciseBasis) ? exercise_percent : null;
205			final Integer exerciseSpeedPercent = "Speed".equals(exerciseBasis) ? exercise_percent : null;
206			return new InWorkoutItemSet()
207			.setExercise_repetitions_percent(exerciseRepetitionsPercent)
208			.setGoal_repetitions(parseWorkoutItemSet.getRepetitions())
209			.setRepetitions(parseWorkoutItemSet.getRepetitions())
210			.setRepetitions_to_failure(parseWorkoutItemSet.getRepetitions_to_failure())
211			.setExercise_weight_percent(exerciseWeightPercent)
212			.setGoal_weight_coef(parseWorkoutItemSet.getWeight())
213			.setWeight(generateWeight(parseWorkoutItemSet.getWeight(),
214			exerciseWeightPercent, getWeightForUserGroup(userWeight, userGroup)))
215			.setBodyweight(parseWorkoutItemSet.getBodyweight())
216			.setExercise_time_percent(exerciseTimePercent)
217			.setGoal_time_in_sec(minToSec(parseWorkoutItemSet.getTime_in_min()))
218			.setTime_in_sec(minToSec(parseWorkoutItemSet.getTime_in_min()))
219			.setExercise_speed_percent(exerciseSpeedPercent)
220			.setGoal_speed(parseWorkoutItemSet.getSpeed())
221			.setSpeed(parseWorkoutItemSet.getSpeed())
222			.setIncline(parseWorkoutItemSet.getIncline())
223			.setResistance(parseWorkoutItemSet.getResistance())
224			.setExercise_basis(exerciseBasis);
225			}
226
227			Float getWeightForUserGroup(Float userWeight, Integer userGroup) {
228			if (userWeight == null) {
229			return null;
230			}
231			switch (userGroup) {
232			case 1:
233			case 2:
234			return Math.min(100F, userWeight);
235			case 3:
236			case 4:
237			return Math.min(75F, userWeight);
238			default:
239			return userWeight;
240			}
241			}
242
243			private Float generateWeight(Float goalWeightCoef, Integer exerciseWeightPercent, Float userWeight) {
244			if (goalWeightCoef != null && exerciseWeightPercent != null && userWeight != null) {
245			return roundToEven(userWeight * goalWeightCoef * exerciseWeightPercent / 100);
246			}
247			return goalWeightCoef;
248			}
249
250			float roundToEven(Float floatValue) {
251			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...
252			}
253
254			private Integer minToSec(Float value) {
255			return value == null ? null : Float.valueOf(value * 60).intValue();
			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...
256			}
257
258			private List<ParseRound> getRoundsGorGoalAndUserGroup(List<ParseProgram> parsePrograms,
259			InUserGoal inUserGoal, Integer userGroup) {
260			final List<ParseRound> parseRounds = new ArrayList<>();
261			parsePrograms.get(0).getParseGoals().forEach(parseGoal -> {
262			boolean nameFound = getOnlySymbols(parseGoal.getName()).equalsIgnoreCase(
263			getOnlySymbols(getGoalName(inUserGoal)));
264			if (nameFound) {
265			final List<ParseRound> localParseRounds = new ArrayList<>();
266			parseGoal.getParseUserGroups().forEach(parseUserGroup -> {
267			if (parseUserGroup.getName().equals("" + userGroup)) {
268			localParseRounds.addAll(parseUserGroup.getParseRounds());
269			}
270			});
271			parseRounds.addAll(multiplyLists(localParseRounds, parseGoal.getLoops()));
272			}
273			});
274			return parseRounds;
275			}
276
277			List<ParseRound> multiplyLists(List<ParseRound> parseRounds, Integer loops) {
278			if (loops == null) {
279			return parseRounds;
280			}
281			final List<ParseRound> result = new ArrayList<>(parseRounds.size() * loops);
282			parseRounds.forEach(parseRound -> {
283			for (int index = 0; index < loops; index += 1) {
284			result.add(parseRound);
285			}
286			});
287			return result;
288			}
289
290			private String getOnlySymbols(String value) {
291			return value.replace("on a specific distance", "").replace("ednurance", "endurance")
292			.replaceAll("[\\s\\.\\,]+", "");
293			}
294
295			private String getGoalName(InUserGoal inUserGoal) {
296			return Arrays.asList(dictionaryService.getEnValue(DictionaryName.goal_title,
297			inUserGoal.getD_goal_title(), null),
298			dictionaryService.getEnValue(DictionaryName.goal_title_2,
299			inUserGoal.getD_goal_title_2(), null)).stream().filter(Objects::nonNull).collect(Collectors.joining(", "));
300			}
301
302			private List<ParseWorkout> getParseWorkouts(List<ParseRound> parseRounds) {
303			final List<ParseWorkout> parseWorkouts = new ArrayList<>();
304			parseRounds.forEach(parseRound -> {
			0 ignored issues – show Java 8 introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report Remove useless curly braces around statement Loading history...
305			parseRound.getParseParts().forEach(parsePart -> {
			0 ignored issues – show Java 8 introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report Remove useless curly braces around statement Loading history...
306			parsePart.getParseWorkouts().forEach(parseWorkout -> {
			0 ignored issues – show Java 8 introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report Remove useless curly braces around statement Loading history...
307			parseWorkouts.add(parseWorkout);
308			});
309			});
310			});
311			return parseWorkouts;
312			}
313
314			List<ParseWorkout> mergeLists(List<ParseWorkout> parseWorkouts1, List<ParseWorkout> parseWorkouts2) {
315			final List<ParseWorkout> parseWorkouts = new ArrayList<>();
316			for (int index = 0; index < Math.max(parseWorkouts1.size(), parseWorkouts2.size()); index += 1) {
317			if (!parseWorkouts1.isEmpty()) {
318			parseWorkouts.add(parseWorkouts1.get(index % parseWorkouts1.size()));
319			}
320			if (!parseWorkouts2.isEmpty()) {
321			parseWorkouts.add(parseWorkouts2.get(index % parseWorkouts2.size()));
322			}
323			}
324			return parseWorkouts;
325			}
326
327			String getExerciseType(ParseWorkoutItem parseWorkoutItem) {
328			List<Exercise> exercises = exerciseRepository.findByExerciseId(parseWorkoutItem.getExercise_id());
329			if (exercises.isEmpty()) {
330			return "OnRepetitions";
331			}
332			if (exercises.get(0).getExerciseTypes().size() == 1) {
333			return exercises.get(0).getExerciseTypes().get(0).getName();
334			}
335			if (parseWorkoutItem.getParseWorkoutItemSets().stream()
336			.filter(set -> set.getTime_in_min() != null).findFirst().isPresent()) {
			0 ignored issues – show introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report Replace this "filter().findFirst().isPresent()" chain with "anyMatch()" Loading history...
337			return "OnTime";
338			}
339			return "OnRepetitions";
340			}
341
342			enum Gender {
343			male, female, unknown
344			}
345
346			enum Level {
347			unexperienced, experienced, unknown
348			}
349
350			private Optional<Integer> getUserGroup(InUser inUser) {
351			final Gender gender;
352			if ("male".equalsIgnoreCase(inUser.getD_sex())) {
353			gender = Gender.male;
354			} else if ("female".equalsIgnoreCase(inUser.getD_sex())) {
355			gender = Gender.female;
356			} else {
357			gender = Gender.unknown;
358			}
359			final Level level;
360			if ("1".equalsIgnoreCase(inUser.getD_level())) {
361			level = Level.unexperienced;
362			} else if ("2".equalsIgnoreCase(inUser.getD_level())) {
363			level = Level.experienced;
364			} else {
365			level = Level.unknown;
366			}
367			final Integer userGroup;
368			if (gender == Gender.male && level == Level.experienced) {
369			userGroup = 1;
370			} else if (gender == Gender.male && level == Level.unexperienced) {
371			userGroup = 2;
372			} else if (gender == Gender.female && level == Level.experienced) {
373			userGroup = 3;
374			} else if (gender == Gender.female && level == Level.unexperienced) {
375			userGroup = 4;
376			} else {
377			userGroup = null;
378			}
379			return Optional.ofNullable(userGroup);
380			}
381			}
382

javadev / pt-backend

Push — master ( c56ed7...f22d86 )

multiplyLists(List,Integer) A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like