com.osomapps.pt.admin.exercise.AdminExerciseService.update(Long,ExerciseRequestDTO) - 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

update(Long,ExerciseRequestDTO) D

↳ Parent: com.osomapps.pt.admin.exercise.AdminExerciseService

Complexity

Conditions

Size

Total Lines	100
Code Lines	93

Duplication

Lines	25
Ratio	25 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
eloc	93
dl	25
loc	100
rs	4.429
c	2
b	0
f	0
cc	10

How to fix Long Method Complexity

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

If many parameters/temporary variables are present:
- Replace temporary variables with Query
- Introduce parameter object; often combined with preserve whole object
- If the above two are insufficient: Replace method with method object
If you have long conditionals: Decompose Conditional
Otherwise: Extract method

Complexity

Complex classes like com.osomapps.pt.admin.exercise.AdminExerciseService.update(Long,ExerciseRequestDTO) often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

package com.osomapps.pt.admin.exercise;

import com.osomapps.pt.ResourceNotFoundException;
import com.osomapps.pt.UnauthorizedException;
import com.osomapps.pt.dictionary.DictionaryName;
import com.osomapps.pt.dictionary.DictionaryService;
import com.osomapps.pt.exercises.Exercise;
import com.osomapps.pt.exercises.ExerciseBodypart;
import com.osomapps.pt.exercises.ExerciseEquipmentType;
import com.osomapps.pt.exercises.ExerciseFile;
import com.osomapps.pt.exercises.ExerciseFilePreview;
import com.osomapps.pt.exercises.ExerciseFilePreviewRepository;
import com.osomapps.pt.exercises.ExerciseFileRepository;
import com.osomapps.pt.exercises.ExerciseRepository;
import com.osomapps.pt.tokenemail.DataurlValidator;
import java.util.HashMap;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import org.springframework.validation.MapBindingResult;

@Service
class AdminExerciseService {
    private final ExerciseRepository exerciseRepository;
    private final ExerciseBodypartRepository exerciseBodypartRepository;
    private final ExerciseEquipmentTypeRepository exerciseEquipmentTypeRepository;
    private final ExerciseTypeRepository exerciseTypeRepository;
    private final DictionaryService dictionaryService;
    private final ExerciseInputRepository exerciseInputRepository;
    private final ExerciseOutputRepository exerciseOutputRepository;
    private final ExerciseFileRepository exerciseFileRepository;
    private final ExerciseFilePreviewRepository exerciseFilePreviewRepository;
    private final DataurlValidator dataurlValidator;

    AdminExerciseService(

            ExerciseRepository exerciseRepository,
            ExerciseBodypartRepository exerciseBodypartRepository,
            ExerciseEquipmentTypeRepository exerciseEquipmentTypeRepository,
            ExerciseTypeRepository exerciseTypeRepository,
            DictionaryService dictionaryService,
            ExerciseInputRepository exerciseInputRepository,
            ExerciseOutputRepository exerciseOutputRepository,
            ExerciseFileRepository exerciseFileRepository,
            ExerciseFilePreviewRepository exerciseFilePreviewRepository,
            DataurlValidator dataurlValidator) {
        this.exerciseRepository = exerciseRepository;
        this.exerciseBodypartRepository = exerciseBodypartRepository;
        this.exerciseEquipmentTypeRepository = exerciseEquipmentTypeRepository;
        this.exerciseTypeRepository = exerciseTypeRepository;
        this.dictionaryService = dictionaryService;
        this.exerciseInputRepository = exerciseInputRepository;
        this.exerciseOutputRepository = exerciseOutputRepository;
        this.exerciseFileRepository = exerciseFileRepository;
        this.exerciseFilePreviewRepository = exerciseFilePreviewRepository;
        this.dataurlValidator = dataurlValidator;
    }

    List<ExerciseResponseDTO> findAll() {
        return exerciseRepository.findAll(sortByIdAsc()).stream()
                .map(exercise -> exerciseToDto(exercise))
                .collect(Collectors.toList());
    }

    private Sort sortByIdAsc() {
        return Sort.by(Sort.Direction.ASC, "exerciseId");
    }

    private ExerciseResponseDTO exerciseToDto(Exercise exercise) {
        return ExerciseResponseDTO.builder()
                .id(exercise.getId())
                .exerciseId(exercise.getExerciseId())
                .nameEn(
                        dictionaryService.getEnValue(
                                DictionaryName.exercise_name, exercise.getDExerciseName(), ""))
                .nameNo(
                        dictionaryService.getNoValue(
                                DictionaryName.exercise_name, exercise.getDExerciseName(), ""))
                .descriptionEn(
                        dictionaryService.getEnValue(
                                DictionaryName.exercise_description,
                                exercise.getDExerciseDescription(),
                                ""))
                .descriptionNo(
                        dictionaryService.getNoValue(
                                DictionaryName.exercise_description,
                                exercise.getDExerciseDescription(),
                                ""))
                .bodypart(
                        exercise.getExerciseBodypart() == null
                                ? null
                                : ExerciseBodypartResponseDTO.builder()
                                        .id(exercise.getExerciseBodypart().getId())
                                        .nameEn(
                                                dictionaryService.getEnValue(
                                                        DictionaryName.exercise_bodypart_name,
                                                        exercise.getExerciseBodypart()
                                                                .getDExerciseBodypartName(),
                                                        ""))
                                        .nameNo(
                                                dictionaryService.getNoValue(
                                                        DictionaryName.exercise_bodypart_name,
                                                        exercise.getExerciseBodypart()
                                                                .getDExerciseBodypartName(),
                                                        ""))
                                        .build())
                .equipmentType(
                        exercise.getExerciseEquipmentType() == null
                                ? null
                                : ExerciseEquipmentTypeResponseDTO.builder()
                                        .id(exercise.getExerciseEquipmentType().getId())
                                        .nameEn(
                                                dictionaryService.getEnValue(
                                                        DictionaryName.exercise_equipment_type_name,
                                                        exercise.getExerciseEquipmentType()
                                                                .getDExerciseEquipmentTypeName(),
                                                        ""))
                                        .nameNo(
                                                dictionaryService.getNoValue(
                                                        DictionaryName.exercise_equipment_type_name,
                                                        exercise.getExerciseEquipmentType()
                                                                .getDExerciseEquipmentTypeName(),
                                                        ""))
                                        .build())
                .types(
                        exercise.getExerciseTypes().stream()
                                .map(
                                        type ->
                                                ExerciseTypeResponseDTO.builder()
                                                        .id(type.getId())
                                                        .name(type.getName())
                                                        .build())
                                .collect(Collectors.toList()))
                .inputs(
                        exercise.getExerciseInputs().stream()
                                .map(
                                        input ->
                                                ExerciseInputResponseDTO.builder()
                                                        .id(input.getId())
                                                        .name(input.getName())
                                                        .build())
                                .collect(Collectors.toList()))
                .outputs(
                        exercise.getExerciseOutputs().stream()
                                .map(
                                        output ->
                                                ExerciseOutputResponseDTO.builder()
                                                        .id(output.getId())
                                                        .name(output.getName())
                                                        .build())
                                .collect(Collectors.toList()))
                .files(
                        exercise.getExerciseFiles().stream()
                                .map(
                                        file ->
                                                ExerciseFileResponseDTO.builder()
                                                        .id(file.getId())
                                                        .file_name(file.getFile_name())
                                                        .file_size(file.getFile_size())
                                                        .file_type(file.getFile_type())
                                                        .build())
                                .collect(Collectors.toList()))
                .cardioPercent(exercise.getCardio_percent())
                .build();
    }

    ExerciseResponseDTO findOne(Long id) {
        final Exercise exercise = exerciseRepository.findById(id).orElse(null);
        if (exercise == null) {
            throw new ResourceNotFoundException("Exercise with id " + id + " not found.");
        }
        return exerciseToDto(exercise);
    }

    ExerciseResponseDTO create(ExerciseRequestDTO exerciseRequestDTO) {
        final ExerciseBodypart exerciseBodypartDb =
                exerciseRequestDTO.getBodypart() == null
                                || exerciseRequestDTO.getBodypart().getId() == null
                        ? null
                        : exerciseBodypartRepository
                                .findById(exerciseRequestDTO.getBodypart().getId())
                                .orElse(null);
        final ExerciseEquipmentType exerciseEquipmentTypeDb =
                exerciseRequestDTO.getEquipmentType() == null
                                || exerciseRequestDTO.getEquipmentType().getId() == null
                        ? null
                        : exerciseEquipmentTypeRepository
                                .findById(exerciseRequestDTO.getEquipmentType().getId())
                                .orElse(null);
        final String dataKey =
                dictionaryService.getNewDictionaryDataKey(DictionaryName.exercise_name);
        dictionaryService.createDictionaryDataKey(
                DictionaryName.exercise_name,
                dataKey,
                exerciseRequestDTO.getNameEn(),
                exerciseRequestDTO.getNameNo());
        final String dataDescriptionKey =
                dictionaryService.getNewDictionaryDataKey(DictionaryName.exercise_description);
        dictionaryService.createDictionaryDataKey(
                DictionaryName.exercise_description,
                dataDescriptionKey,
                exerciseRequestDTO.getDescriptionEn(),
                exerciseRequestDTO.getDescriptionNo());
        final Exercise exercise = new Exercise();
        exercise.setDExerciseName(dataKey);
        exercise.setDExerciseDescription(dataDescriptionKey);
        exercise.setExerciseId(exerciseRequestDTO.getExerciseId());
        exercise.setExerciseBodypart(exerciseBodypartDb);
        exercise.setExerciseEquipmentType(exerciseEquipmentTypeDb);
        exercise.setExerciseTypes(
                exerciseTypeRepository.findAllById(
                        exerciseRequestDTO.getTypes().stream()
                                .map(type -> type.getId())
                                .collect(Collectors.toList())));
        if (exerciseRequestDTO.getInputs() != null) {
            exercise.setExerciseInputs(
                    exerciseInputRepository.findAllById(
                            exerciseRequestDTO.getInputs().stream()
                                    .map(input -> input.getId())
                                    .collect(Collectors.toList())));
        }
        if (exerciseRequestDTO.getOutputs() != null) {
            exercise.setExerciseOutputs(
                    exerciseOutputRepository.findAllById(
                            exerciseRequestDTO.getOutputs().stream()
                                    .map(output -> output.getId())
                                    .collect(Collectors.toList())));
        }
        if (exerciseRequestDTO.getFiles() != null) {

            List<ExerciseFile> exerciseFiles =
                    exerciseRequestDTO.getFiles().stream()
                            .map(
                                    file -> {
                                        final MapBindingResult errors =
                                                new MapBindingResult(
                                                        new HashMap<>(), String.class.getName());
                                        if (file.getData_url() == null) {
                                            throw new UnauthorizedException("Invalid data_url");
                                        }
                                        dataurlValidator.validate(file.getData_url(), errors);
                                        if (errors.hasErrors()) {
                                            throw new UnauthorizedException(
                                                    errors.getAllErrors()
                                                            .get(0)
                                                            .getDefaultMessage());
                                        }
                                        return new ExerciseFile()
                                                .setFile_name(file.getFile_name())
                                                .setFile_size(file.getFile_size())
                                                .setFile_type(file.getFile_type())
                                                .setData_url(file.getData_url());
                                    })
                            .collect(Collectors.toList());
            List<ExerciseFile> savedExerciseFiles = exerciseFileRepository.saveAll(exerciseFiles);
            exercise.setExerciseFiles(
                    savedExerciseFiles.stream()
                            .map(
                                    file ->
                                            new ExerciseFilePreview()
                                                    .setId(file.getId())
                                                    .setCreated(file.getCreated())
                                                    .setFile_name(file.getFile_name())
                                                    .setFile_size(file.getFile_size())
                                                    .setFile_type(file.getFile_type())
                                                    .setExercises(file.getExercises()))
                            .collect(Collectors.toList()));
        }
        exercise.setCardio_percent(exerciseRequestDTO.getCardioPercent());
        return exerciseToDto(exerciseRepository.save(exercise));
    }

    ExerciseResponseDTO update(Long id, ExerciseRequestDTO exerciseRequestDTO) {
        final Exercise existedExercise = exerciseRepository.findById(id).orElse(null);
        if (existedExercise == null) {
            throw new ResourceNotFoundException("Exercise with id not found: " + id);
        }
        final String dataKey = existedExercise.getDExerciseName();
        dictionaryService.createDictionaryDataKey(
                DictionaryName.exercise_name,
                dataKey,
                exerciseRequestDTO.getNameEn(),
                exerciseRequestDTO.getNameNo());
        final String dataDescriptionKey =
                existedExercise.getDExerciseDescription() == null
                        ? dictionaryService.getNewDictionaryDataKey(
                                DictionaryName.exercise_description)
                        : existedExercise.getDExerciseDescription();
        dictionaryService.createDictionaryDataKey(
                DictionaryName.exercise_description,
                dataDescriptionKey,
                exerciseRequestDTO.getDescriptionEn(),
                exerciseRequestDTO.getDescriptionNo());
        final ExerciseBodypart exerciseBodypartDb =
                exerciseRequestDTO.getBodypart() == null
                        ? null
                        : exerciseBodypartRepository
                                .findById(exerciseRequestDTO.getBodypart().getId())
                                .orElse(null);
        final ExerciseEquipmentType exerciseEquipmentTypeDb =
                exerciseRequestDTO.getEquipmentType() == null
                        ? null
                        : exerciseEquipmentTypeRepository
                                .findById(exerciseRequestDTO.getEquipmentType().getId())
                                .orElse(null);
        existedExercise.setExerciseBodypart(exerciseBodypartDb);
        existedExercise.setExerciseEquipmentType(exerciseEquipmentTypeDb);
        existedExercise.setDExerciseName(dataKey);
        existedExercise.setDExerciseDescription(dataDescriptionKey);
        existedExercise.setExerciseId(exerciseRequestDTO.getExerciseId());
        existedExercise.setCardio_percent(exerciseRequestDTO.getCardioPercent());
        existedExercise.setExerciseTypes(
                exerciseTypeRepository.findAllById(
                        exerciseRequestDTO.getTypes().stream()
                                .map(type -> type.getId())
                                .collect(Collectors.toList())));
        if (exerciseRequestDTO.getInputs() != null) {
            existedExercise.setExerciseInputs(
                    exerciseInputRepository.findAllById(
                            exerciseRequestDTO.getInputs().stream()
                                    .map(input -> input.getId())
                                    .collect(Collectors.toList())));
        }
        if (exerciseRequestDTO.getOutputs() != null) {
            existedExercise.setExerciseOutputs(
                    exerciseOutputRepository.findAllById(
                            exerciseRequestDTO.getOutputs().stream()
                                    .map(output -> output.getId())
                                    .collect(Collectors.toList())));
        }
        if (exerciseRequestDTO.getFiles() != null) {

            exerciseFilePreviewRepository.deleteAll(existedExercise.getExerciseFiles());
            List<ExerciseFile> exerciseFiles =
                    exerciseRequestDTO.getFiles().stream()
                            .map(
                                    file -> {
                                        final MapBindingResult errors =
                                                new MapBindingResult(
                                                        new HashMap<>(), String.class.getName());
                                        if (file.getData_url() == null) {
                                            throw new UnauthorizedException("Invalid data_url");
                                        }
                                        dataurlValidator.validate(file.getData_url(), errors);
                                        if (errors.hasErrors()) {
                                            throw new UnauthorizedException(
                                                    errors.getAllErrors()
                                                            .get(0)
                                                            .getDefaultMessage());
                                        }
                                        return new ExerciseFile()
                                                .setFile_name(file.getFile_name())
                                                .setFile_size(file.getFile_size())
                                                .setFile_type(file.getFile_type())
                                                .setData_url(file.getData_url());
                                    })
                            .collect(Collectors.toList());
            List<ExerciseFile> savedExerciseFiles = exerciseFileRepository.saveAll(exerciseFiles);
            existedExercise.setExerciseFiles(
                    savedExerciseFiles.stream()
                            .map(
                                    file ->
                                            new ExerciseFilePreview()
                                                    .setId(file.getId())
                                                    .setCreated(file.getCreated())
                                                    .setFile_name(file.getFile_name())
                                                    .setFile_size(file.getFile_size())
                                                    .setFile_type(file.getFile_type())
                                                    .setExercises(file.getExercises()))
                            .collect(Collectors.toList()));
        }
        final Exercise savedExercise = exerciseRepository.save(existedExercise);
        return exerciseToDto(savedExercise);
    }

    ExerciseResponseDTO delete(Long id) {
        final Exercise exercise = exerciseRepository.findById(id).orElse(null);
        if (exercise == null) {
            throw new ResourceNotFoundException("Exercise with id " + id + " not found.");
        }
        dictionaryService.deleteDatas(DictionaryName.exercise_name, exercise.getDExerciseName());
        dictionaryService.deleteDatas(
                DictionaryName.exercise_description, exercise.getDExerciseDescription());
        final ExerciseResponseDTO exerciseResponseDTO = exerciseToDto(exercise);
        exerciseRepository.deleteById(id);
        return exerciseResponseDTO;
    }
}


1		package com.osomapps.pt.admin.exercise;
2
3		import com.osomapps.pt.ResourceNotFoundException;
4		import com.osomapps.pt.UnauthorizedException;
5		import com.osomapps.pt.dictionary.DictionaryName;
6		import com.osomapps.pt.dictionary.DictionaryService;
7		import com.osomapps.pt.exercises.Exercise;
8		import com.osomapps.pt.exercises.ExerciseBodypart;
9		import com.osomapps.pt.exercises.ExerciseEquipmentType;
10		import com.osomapps.pt.exercises.ExerciseFile;
11		import com.osomapps.pt.exercises.ExerciseFilePreview;
12		import com.osomapps.pt.exercises.ExerciseFilePreviewRepository;
13		import com.osomapps.pt.exercises.ExerciseFileRepository;
14		import com.osomapps.pt.exercises.ExerciseRepository;
15		import com.osomapps.pt.tokenemail.DataurlValidator;
16		import java.util.HashMap;
17		import java.util.List;
18		import java.util.stream.Collectors;
19		import org.springframework.data.domain.Sort;
20		import org.springframework.stereotype.Service;
21		import org.springframework.validation.MapBindingResult;
22
23		@Service
24		class AdminExerciseService {
25		private final ExerciseRepository exerciseRepository;
26		private final ExerciseBodypartRepository exerciseBodypartRepository;
27		private final ExerciseEquipmentTypeRepository exerciseEquipmentTypeRepository;
28		private final ExerciseTypeRepository exerciseTypeRepository;
29		private final DictionaryService dictionaryService;
30		private final ExerciseInputRepository exerciseInputRepository;
31		private final ExerciseOutputRepository exerciseOutputRepository;
32		private final ExerciseFileRepository exerciseFileRepository;
33		private final ExerciseFilePreviewRepository exerciseFilePreviewRepository;
34		private final DataurlValidator dataurlValidator;
35
36		AdminExerciseService(
		0 ignored issues – show Comprehensibility introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report Constructor has 10 parameters, which is greater than 7 authorized. Loading history...
37		ExerciseRepository exerciseRepository,
38		ExerciseBodypartRepository exerciseBodypartRepository,
39		ExerciseEquipmentTypeRepository exerciseEquipmentTypeRepository,
40		ExerciseTypeRepository exerciseTypeRepository,
41		DictionaryService dictionaryService,
42		ExerciseInputRepository exerciseInputRepository,
43		ExerciseOutputRepository exerciseOutputRepository,
44		ExerciseFileRepository exerciseFileRepository,
45		ExerciseFilePreviewRepository exerciseFilePreviewRepository,
46		DataurlValidator dataurlValidator) {
47		this.exerciseRepository = exerciseRepository;
48		this.exerciseBodypartRepository = exerciseBodypartRepository;
49		this.exerciseEquipmentTypeRepository = exerciseEquipmentTypeRepository;
50		this.exerciseTypeRepository = exerciseTypeRepository;
51		this.dictionaryService = dictionaryService;
52		this.exerciseInputRepository = exerciseInputRepository;
53		this.exerciseOutputRepository = exerciseOutputRepository;
54		this.exerciseFileRepository = exerciseFileRepository;
55		this.exerciseFilePreviewRepository = exerciseFilePreviewRepository;
56		this.dataurlValidator = dataurlValidator;
57		}
58
59		List<ExerciseResponseDTO> findAll() {
60		return exerciseRepository.findAll(sortByIdAsc()).stream()
61		.map(exercise -> exerciseToDto(exercise))
62		.collect(Collectors.toList());
63		}
64
65		private Sort sortByIdAsc() {
66		return Sort.by(Sort.Direction.ASC, "exerciseId");
67		}
68
69		private ExerciseResponseDTO exerciseToDto(Exercise exercise) {
70		return ExerciseResponseDTO.builder()
71		.id(exercise.getId())
72		.exerciseId(exercise.getExerciseId())
73		.nameEn(
74		dictionaryService.getEnValue(
75		DictionaryName.exercise_name, exercise.getDExerciseName(), ""))
76		.nameNo(
77		dictionaryService.getNoValue(
78		DictionaryName.exercise_name, exercise.getDExerciseName(), ""))
79		.descriptionEn(
80		dictionaryService.getEnValue(
81		DictionaryName.exercise_description,
82		exercise.getDExerciseDescription(),
83		""))
84		.descriptionNo(
85		dictionaryService.getNoValue(
86		DictionaryName.exercise_description,
87		exercise.getDExerciseDescription(),
88		""))
89		.bodypart(
90		exercise.getExerciseBodypart() == null
91		? null
92		: ExerciseBodypartResponseDTO.builder()
93		.id(exercise.getExerciseBodypart().getId())
94		.nameEn(
95		dictionaryService.getEnValue(
96		DictionaryName.exercise_bodypart_name,
97		exercise.getExerciseBodypart()
98		.getDExerciseBodypartName(),
99		""))
100		.nameNo(
101		dictionaryService.getNoValue(
102		DictionaryName.exercise_bodypart_name,
103		exercise.getExerciseBodypart()
104		.getDExerciseBodypartName(),
105		""))
106		.build())
107		.equipmentType(
108		exercise.getExerciseEquipmentType() == null
109		? null
110		: ExerciseEquipmentTypeResponseDTO.builder()
111		.id(exercise.getExerciseEquipmentType().getId())
112		.nameEn(
113		dictionaryService.getEnValue(
114		DictionaryName.exercise_equipment_type_name,
115		exercise.getExerciseEquipmentType()
116		.getDExerciseEquipmentTypeName(),
117		""))
118		.nameNo(
119		dictionaryService.getNoValue(
120		DictionaryName.exercise_equipment_type_name,
121		exercise.getExerciseEquipmentType()
122		.getDExerciseEquipmentTypeName(),
123		""))
124		.build())
125		.types(
126		exercise.getExerciseTypes().stream()
127		.map(
128		type ->
129		ExerciseTypeResponseDTO.builder()
130		.id(type.getId())
131		.name(type.getName())
132		.build())
133		.collect(Collectors.toList()))
134		.inputs(
135		exercise.getExerciseInputs().stream()
136		.map(
137		input ->
138		ExerciseInputResponseDTO.builder()
139		.id(input.getId())
140		.name(input.getName())
141		.build())
142		.collect(Collectors.toList()))
143		.outputs(
144		exercise.getExerciseOutputs().stream()
145		.map(
146		output ->
147		ExerciseOutputResponseDTO.builder()
148		.id(output.getId())
149		.name(output.getName())
150		.build())
151		.collect(Collectors.toList()))
152		.files(
153		exercise.getExerciseFiles().stream()
154		.map(
155		file ->
156		ExerciseFileResponseDTO.builder()
157		.id(file.getId())
158		.file_name(file.getFile_name())
159		.file_size(file.getFile_size())
160		.file_type(file.getFile_type())
161		.build())
162		.collect(Collectors.toList()))
163		.cardioPercent(exercise.getCardio_percent())
164		.build();
165		}
166
167		ExerciseResponseDTO findOne(Long id) {
168		final Exercise exercise = exerciseRepository.findById(id).orElse(null);
169		if (exercise == null) {
170		throw new ResourceNotFoundException("Exercise with id " + id + " not found.");
171		}
172		return exerciseToDto(exercise);
173		}
174
175		ExerciseResponseDTO create(ExerciseRequestDTO exerciseRequestDTO) {
176		final ExerciseBodypart exerciseBodypartDb =
177		exerciseRequestDTO.getBodypart() == null
178		\|\| exerciseRequestDTO.getBodypart().getId() == null
179		? null
180		: exerciseBodypartRepository
181		.findById(exerciseRequestDTO.getBodypart().getId())
182		.orElse(null);
183		final ExerciseEquipmentType exerciseEquipmentTypeDb =
184		exerciseRequestDTO.getEquipmentType() == null
185		\|\| exerciseRequestDTO.getEquipmentType().getId() == null
186		? null
187		: exerciseEquipmentTypeRepository
188		.findById(exerciseRequestDTO.getEquipmentType().getId())
189		.orElse(null);
190		final String dataKey =
191		dictionaryService.getNewDictionaryDataKey(DictionaryName.exercise_name);
192		dictionaryService.createDictionaryDataKey(
193		DictionaryName.exercise_name,
194		dataKey,
195		exerciseRequestDTO.getNameEn(),
196		exerciseRequestDTO.getNameNo());
197		final String dataDescriptionKey =
198		dictionaryService.getNewDictionaryDataKey(DictionaryName.exercise_description);
199		dictionaryService.createDictionaryDataKey(
200		DictionaryName.exercise_description,
201		dataDescriptionKey,
202		exerciseRequestDTO.getDescriptionEn(),
203		exerciseRequestDTO.getDescriptionNo());
204		final Exercise exercise = new Exercise();
205		exercise.setDExerciseName(dataKey);
206		exercise.setDExerciseDescription(dataDescriptionKey);
207		exercise.setExerciseId(exerciseRequestDTO.getExerciseId());
208		exercise.setExerciseBodypart(exerciseBodypartDb);
209		exercise.setExerciseEquipmentType(exerciseEquipmentTypeDb);
210		exercise.setExerciseTypes(
211		exerciseTypeRepository.findAllById(
212		exerciseRequestDTO.getTypes().stream()
213		.map(type -> type.getId())
214		.collect(Collectors.toList())));
215		if (exerciseRequestDTO.getInputs() != null) {
216		exercise.setExerciseInputs(
217		exerciseInputRepository.findAllById(
218		exerciseRequestDTO.getInputs().stream()
219		.map(input -> input.getId())
220		.collect(Collectors.toList())));
221		}
222		if (exerciseRequestDTO.getOutputs() != null) {
223		exercise.setExerciseOutputs(
224		exerciseOutputRepository.findAllById(
225		exerciseRequestDTO.getOutputs().stream()
226		.map(output -> output.getId())
227		.collect(Collectors.toList())));
228		}
229	View Code Duplication	if (exerciseRequestDTO.getFiles() != null) {
		0 ignored issues – show Duplication introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
230		List<ExerciseFile> exerciseFiles =
231		exerciseRequestDTO.getFiles().stream()
232		.map(
233		file -> {
234		final MapBindingResult errors =
235		new MapBindingResult(
236		new HashMap<>(), String.class.getName());
237		if (file.getData_url() == null) {
238		throw new UnauthorizedException("Invalid data_url");
239		}
240		dataurlValidator.validate(file.getData_url(), errors);
241		if (errors.hasErrors()) {
242		throw new UnauthorizedException(
243		errors.getAllErrors()
244		.get(0)
245		.getDefaultMessage());
246		}
247		return new ExerciseFile()
248		.setFile_name(file.getFile_name())
249		.setFile_size(file.getFile_size())
250		.setFile_type(file.getFile_type())
251		.setData_url(file.getData_url());
252		})
253		.collect(Collectors.toList());
254		List<ExerciseFile> savedExerciseFiles = exerciseFileRepository.saveAll(exerciseFiles);
255		exercise.setExerciseFiles(
256		savedExerciseFiles.stream()
257		.map(
258		file ->
259		new ExerciseFilePreview()
260		.setId(file.getId())
261		.setCreated(file.getCreated())
262		.setFile_name(file.getFile_name())
263		.setFile_size(file.getFile_size())
264		.setFile_type(file.getFile_type())
265		.setExercises(file.getExercises()))
266		.collect(Collectors.toList()));
267		}
268		exercise.setCardio_percent(exerciseRequestDTO.getCardioPercent());
269		return exerciseToDto(exerciseRepository.save(exercise));
270		}
271
272		ExerciseResponseDTO update(Long id, ExerciseRequestDTO exerciseRequestDTO) {
273		final Exercise existedExercise = exerciseRepository.findById(id).orElse(null);
274		if (existedExercise == null) {
275		throw new ResourceNotFoundException("Exercise with id not found: " + id);
276		}
277		final String dataKey = existedExercise.getDExerciseName();
278		dictionaryService.createDictionaryDataKey(
279		DictionaryName.exercise_name,
280		dataKey,
281		exerciseRequestDTO.getNameEn(),
282		exerciseRequestDTO.getNameNo());
283		final String dataDescriptionKey =
284		existedExercise.getDExerciseDescription() == null
285		? dictionaryService.getNewDictionaryDataKey(
286		DictionaryName.exercise_description)
287		: existedExercise.getDExerciseDescription();
288		dictionaryService.createDictionaryDataKey(
289		DictionaryName.exercise_description,
290		dataDescriptionKey,
291		exerciseRequestDTO.getDescriptionEn(),
292		exerciseRequestDTO.getDescriptionNo());
293		final ExerciseBodypart exerciseBodypartDb =
294		exerciseRequestDTO.getBodypart() == null
295		? null
296		: exerciseBodypartRepository
297		.findById(exerciseRequestDTO.getBodypart().getId())
298		.orElse(null);
299		final ExerciseEquipmentType exerciseEquipmentTypeDb =
300		exerciseRequestDTO.getEquipmentType() == null
301		? null
302		: exerciseEquipmentTypeRepository
303		.findById(exerciseRequestDTO.getEquipmentType().getId())
304		.orElse(null);
305		existedExercise.setExerciseBodypart(exerciseBodypartDb);
306		existedExercise.setExerciseEquipmentType(exerciseEquipmentTypeDb);
307		existedExercise.setDExerciseName(dataKey);
308		existedExercise.setDExerciseDescription(dataDescriptionKey);
309		existedExercise.setExerciseId(exerciseRequestDTO.getExerciseId());
310		existedExercise.setCardio_percent(exerciseRequestDTO.getCardioPercent());
311		existedExercise.setExerciseTypes(
312		exerciseTypeRepository.findAllById(
313		exerciseRequestDTO.getTypes().stream()
314		.map(type -> type.getId())
315		.collect(Collectors.toList())));
316		if (exerciseRequestDTO.getInputs() != null) {
317		existedExercise.setExerciseInputs(
318		exerciseInputRepository.findAllById(
319		exerciseRequestDTO.getInputs().stream()
320		.map(input -> input.getId())
321		.collect(Collectors.toList())));
322		}
323		if (exerciseRequestDTO.getOutputs() != null) {
324		existedExercise.setExerciseOutputs(
325		exerciseOutputRepository.findAllById(
326		exerciseRequestDTO.getOutputs().stream()
327		.map(output -> output.getId())
328		.collect(Collectors.toList())));
329		}
330	View Code Duplication	if (exerciseRequestDTO.getFiles() != null) {
		0 ignored issues – show Duplication introduced 2018-10-12 21:20 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
331		exerciseFilePreviewRepository.deleteAll(existedExercise.getExerciseFiles());
332		List<ExerciseFile> exerciseFiles =
333		exerciseRequestDTO.getFiles().stream()
334		.map(
335		file -> {
336		final MapBindingResult errors =
337		new MapBindingResult(
338		new HashMap<>(), String.class.getName());
339		if (file.getData_url() == null) {
340		throw new UnauthorizedException("Invalid data_url");
341		}
342		dataurlValidator.validate(file.getData_url(), errors);
343		if (errors.hasErrors()) {
344		throw new UnauthorizedException(
345		errors.getAllErrors()
346		.get(0)
347		.getDefaultMessage());
348		}
349		return new ExerciseFile()
350		.setFile_name(file.getFile_name())
351		.setFile_size(file.getFile_size())
352		.setFile_type(file.getFile_type())
353		.setData_url(file.getData_url());
354		})
355		.collect(Collectors.toList());
356		List<ExerciseFile> savedExerciseFiles = exerciseFileRepository.saveAll(exerciseFiles);
357		existedExercise.setExerciseFiles(
358		savedExerciseFiles.stream()
359		.map(
360		file ->
361		new ExerciseFilePreview()
362		.setId(file.getId())
363		.setCreated(file.getCreated())
364		.setFile_name(file.getFile_name())
365		.setFile_size(file.getFile_size())
366		.setFile_type(file.getFile_type())
367		.setExercises(file.getExercises()))
368		.collect(Collectors.toList()));
369		}
370		final Exercise savedExercise = exerciseRepository.save(existedExercise);
371		return exerciseToDto(savedExercise);
372		}
373
374		ExerciseResponseDTO delete(Long id) {
375		final Exercise exercise = exerciseRepository.findById(id).orElse(null);
376		if (exercise == null) {
377		throw new ResourceNotFoundException("Exercise with id " + id + " not found.");
378		}
379		dictionaryService.deleteDatas(DictionaryName.exercise_name, exercise.getDExerciseName());
380		dictionaryService.deleteDatas(
381		DictionaryName.exercise_description, exercise.getDExerciseDescription());
382		final ExerciseResponseDTO exerciseResponseDTO = exerciseToDto(exercise);
383		exerciseRepository.deleteById(id);
384		return exerciseResponseDTO;
385		}
386		}
387

javadev / pt-backend

Push — master ( 634ec8...dcf6e8 )

update(Long,ExerciseRequestDTO) D

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like