197 lines
9.0 KiB
Plaintext
197 lines
9.0 KiB
Plaintext
package com.healthcare.ohctech.service.impl;
|
|
|
|
import com.healthcare.ohctech.dto.PatientDailyBodyMeasurementDto;
|
|
import com.healthcare.ohctech.dto.PatientDailyExerciseDto;
|
|
import com.healthcare.ohctech.entity.ExerciseMaster;
|
|
import com.healthcare.ohctech.entity.Patient;
|
|
import com.healthcare.ohctech.entity.PatientDailyBodyMeasurement;
|
|
import com.healthcare.ohctech.entity.PatientDailyExercise;
|
|
import com.healthcare.ohctech.repository.ExerciseMasterRepo;
|
|
import com.healthcare.ohctech.repository.PatientDailyExerciseRepo;
|
|
import com.healthcare.ohctech.repository.PatientRepo;
|
|
import com.healthcare.ohctech.service.PatientDailyExerciseService;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.data.domain.Page;
|
|
import org.springframework.data.domain.Pageable;
|
|
import org.springframework.stereotype.Service;
|
|
|
|
import java.time.LocalDate;
|
|
import java.util.ArrayList;
|
|
import java.util.Comparator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.stream.Collectors;
|
|
|
|
@Service
|
|
public class PatientDailyExerciseServiceImpl implements PatientDailyExerciseService {
|
|
|
|
@Autowired
|
|
private PatientDailyExerciseRepo patientDailyExerciseRepo;
|
|
@Autowired
|
|
private ExerciseMasterRepo exerciseMasterRepo;
|
|
@Autowired
|
|
private PatientRepo patientRepo;
|
|
|
|
@Override
|
|
public List<PatientDailyExerciseDto> getPatientExercisesByEmpId(Long empId) {
|
|
List<PatientDailyExercise> exercises = patientDailyExerciseRepo.findAllByPatientId(empId);
|
|
|
|
Map<LocalDate, List<PatientDailyExercise>> exercisesByDate = exercises.stream()
|
|
.collect(Collectors.groupingBy(PatientDailyExercise::getDate));
|
|
|
|
return exercisesByDate.entrySet().stream()
|
|
.sorted(Map.Entry.<LocalDate, List<PatientDailyExercise>>comparingByKey().reversed())
|
|
.map(entry -> {
|
|
LocalDate date = entry.getKey();
|
|
List<PatientDailyExercise> dailyExercises = entry.getValue();
|
|
|
|
Map<Long, PatientDailyExerciseDto.ExerciseValue> exerciseValues = dailyExercises.stream()
|
|
.collect(Collectors.toMap(
|
|
e -> e.getExerciseMaster().getId(),
|
|
e -> new PatientDailyExerciseDto.ExerciseValue(
|
|
e.getValue(),
|
|
e.getRemark(),
|
|
e.getExerciseMaster().getUnitMaster().getId()
|
|
)
|
|
));
|
|
|
|
return new PatientDailyExerciseDto(
|
|
dailyExercises.get(0).getId(),
|
|
dailyExercises.get(0).getPatient().getId(),
|
|
date,
|
|
dailyExercises.get(0).getModifiedBy(),
|
|
dailyExercises.get(0).getLastModified(),
|
|
exerciseValues
|
|
);
|
|
})
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
@Override
|
|
public PatientDailyExerciseDto getPatientExerciseByEmpIdAndDate(Long empId, LocalDate date) {
|
|
List<PatientDailyExercise> exercises = patientDailyExerciseRepo.findAllByPatientIdAndDate(empId, date);
|
|
|
|
if (exercises.isEmpty()) {
|
|
return null;
|
|
}
|
|
|
|
Map<Long, PatientDailyExerciseDto.ExerciseValue> exerciseValues = exercises.stream()
|
|
.collect(Collectors.toMap(
|
|
e -> e.getExerciseMaster().getId(),
|
|
e -> new PatientDailyExerciseDto.ExerciseValue(
|
|
e.getValue(),
|
|
e.getRemark(),
|
|
e.getExerciseMaster().getUnitMaster().getId()
|
|
)
|
|
));
|
|
|
|
PatientDailyExercise firstExercise = exercises.get(0);
|
|
|
|
return new PatientDailyExerciseDto(
|
|
firstExercise.getId(),
|
|
empId,
|
|
firstExercise.getDate(),
|
|
firstExercise.getModifiedBy(),
|
|
firstExercise.getLastModified(),
|
|
exerciseValues
|
|
);
|
|
}
|
|
|
|
@Override
|
|
public List<PatientDailyExerciseDto> getAllPatientExercises() {
|
|
List<PatientDailyExercise> exercises = patientDailyExerciseRepo.findAll();
|
|
|
|
Map<Long, PatientDailyExerciseDto> dtoMap = exercises.stream()
|
|
.collect(Collectors.groupingBy(
|
|
exercise -> exercise.getPatient().getId(),
|
|
Collectors.collectingAndThen(
|
|
Collectors.toList(),
|
|
exerciseList -> {
|
|
Map<Long, PatientDailyExerciseDto.ExerciseValue> exerciseValues = exerciseList.stream()
|
|
.collect(Collectors.toMap(
|
|
exercise -> exercise.getExerciseMaster().getId(),
|
|
exercise -> new PatientDailyExerciseDto.ExerciseValue(exercise.getValue(), exercise.getRemark(), exercise.getExerciseMaster().getUnitMaster().getId())
|
|
));
|
|
return new PatientDailyExerciseDto(
|
|
exerciseList.get(0).getId(),
|
|
exerciseList.get(0).getPatient().getId(),
|
|
exerciseList.get(0).getDate(),
|
|
exerciseList.get(0).getModifiedBy(),
|
|
exerciseList.get(0).getLastModified(),
|
|
exerciseValues
|
|
);
|
|
}
|
|
)
|
|
));
|
|
return new ArrayList<>(dtoMap.values());
|
|
}
|
|
|
|
@Override
|
|
public void addPatientExercise(PatientDailyExerciseDto exerciseDto, Long userId) {
|
|
List<PatientDailyExercise> exercises = convertToEntity(exerciseDto, userId);
|
|
patientDailyExerciseRepo.saveAll(exercises);
|
|
}
|
|
|
|
@Override
|
|
public void updatePatientExercise(Long empId, PatientDailyExerciseDto exerciseDto, Long userId) {
|
|
List<PatientDailyExercise> existingExercises = patientDailyExerciseRepo.findAllByPatientIdAndDate(empId, exerciseDto.date());
|
|
|
|
for (Map.Entry<Long, PatientDailyExerciseDto.ExerciseValue> entry : exerciseDto.exerciseValues().entrySet()) {
|
|
Long exerciseId = entry.getKey();
|
|
PatientDailyExerciseDto.ExerciseValue exerciseValue = entry.getValue();
|
|
|
|
PatientDailyExercise exercise = existingExercises.stream()
|
|
.filter(e -> e.getExerciseMaster().getId().equals(exerciseId))
|
|
.findFirst()
|
|
.orElse(new PatientDailyExercise());
|
|
|
|
ExerciseMaster exerciseMaster = exerciseMasterRepo.findById(exerciseId)
|
|
.orElseThrow(() -> new RuntimeException("Exercise not found for ID: " + exerciseId));
|
|
|
|
exercise.setPatient(patientRepo.findById(empId)
|
|
.orElseThrow(() -> new RuntimeException("Patient not found for ID: " + empId)));
|
|
exercise.setExerciseMaster(exerciseMaster);
|
|
exercise.setValue(exerciseValue.value());
|
|
exercise.setRemark(exerciseValue.remark());
|
|
exercise.setDate(exerciseDto.date());
|
|
exercise.setModifiedBy(userId);
|
|
|
|
patientDailyExerciseRepo.save(exercise);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void deletePatientExercise(Long empId, LocalDate date) {
|
|
List<PatientDailyExercise> exercises = patientDailyExerciseRepo.findAllByPatientIdAndDate(empId, date);
|
|
|
|
if (exercises.isEmpty()) {
|
|
throw new RuntimeException("No Patient Exercises found for EmpId: " + empId + " and Date: " + date);
|
|
}
|
|
patientDailyExerciseRepo.deleteAll(exercises);
|
|
}
|
|
|
|
|
|
private List<PatientDailyExercise> convertToEntity(PatientDailyExerciseDto exerciseDto, Long userId) {
|
|
Patient patient = patientRepo.findById(exerciseDto.empId())
|
|
.orElseThrow(() -> new RuntimeException("Patient not found for ID: " + exerciseDto.empId()));
|
|
|
|
return exerciseDto.exerciseValues().entrySet().stream().map(entry -> {
|
|
Long exerciseId = entry.getKey();
|
|
PatientDailyExerciseDto.ExerciseValue exerciseValue = entry.getValue();
|
|
|
|
ExerciseMaster exerciseMaster = exerciseMasterRepo.findById(exerciseId)
|
|
.orElseThrow(() -> new RuntimeException("Exercise not found for ID: " + exerciseId));
|
|
|
|
PatientDailyExercise exercise = new PatientDailyExercise();
|
|
exercise.setPatient(patient);
|
|
exercise.setExerciseMaster(exerciseMaster);
|
|
exercise.setValue(exerciseValue.value());
|
|
exercise.setRemark(exerciseValue.remark());
|
|
exercise.setDate(exerciseDto.date());
|
|
exercise.setModifiedBy(userId);
|
|
|
|
return exercise;
|
|
}).collect(Collectors.toList());
|
|
}
|
|
}
|