ohctechv3/.svn/pristine/88/88746f94e14dd138fdc69925f22e27463b73e6c4.svn-base

197 lines
9.0 KiB
Plaintext
Raw Permalink Normal View History

2024-10-28 15:03:36 +05:30
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());
}
}