697 lines
37 KiB
Plaintext
697 lines
37 KiB
Plaintext
package com.healthcare.ohctech.controller;
|
|
|
|
import com.healthcare.ohctech.dto.EmployeeAppointmentDto;
|
|
import com.healthcare.ohctech.entity.*;
|
|
import com.healthcare.ohctech.repository.*;
|
|
import com.healthcare.ohctech.service.impl.AuthServiceImpl;
|
|
import com.healthcare.ohctech.service.impl.EmployeeAppointmentServiceImpl;
|
|
import com.healthcare.ohctech.util.PaginationUtil;
|
|
import jakarta.validation.Valid;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.data.domain.Page;
|
|
import org.springframework.data.domain.Pageable;
|
|
import org.springframework.http.HttpStatus;
|
|
import org.springframework.http.ResponseEntity;
|
|
import org.springframework.web.bind.annotation.*;
|
|
|
|
import java.util.*;
|
|
import java.util.stream.Collectors;
|
|
|
|
@RestController
|
|
@RequestMapping("/employee-appointments")
|
|
public class EmployeeAppointmentController {
|
|
|
|
@Autowired
|
|
private EmployeeAppointmentServiceImpl employeeAppointmentServiceImpl;
|
|
@Autowired
|
|
private AuthServiceImpl authServiceImpl;
|
|
@Autowired
|
|
private ComplaintRepo complaintRepo;
|
|
@Autowired
|
|
private ExaminationFindingsRepo examinationFindingsRepo;
|
|
@Autowired
|
|
private AilmentRepo ailmentRepo;
|
|
@Autowired
|
|
private SaltMasterRepo saltMasterRepo;
|
|
@Autowired
|
|
private InjuryTypeRepo injuryTypeRepo;
|
|
@Autowired
|
|
private InjuryPartRepo injuryPartRepo;
|
|
@Autowired
|
|
private InjuryClassRepo injuryClassRepo;
|
|
@Autowired
|
|
private InjuryMechanismRepo injuryMechanismRepo;
|
|
@Autowired
|
|
private HealthAdviceRepo healthAdviceRepo;
|
|
@Autowired
|
|
private CheckupFormSectionRepo checkupFormSectionRepo;
|
|
@Autowired
|
|
private CheckupParameterRepo checkupParameterRepo;
|
|
@Autowired
|
|
private ReferralPointRepo referralPointRepo;
|
|
@Autowired
|
|
private ReferredByRepo referredByRepo;
|
|
@Autowired
|
|
private PrescriptionMasterRepo prescriptionMasterRepo;
|
|
@Autowired
|
|
private PatientRepo patientRepo;
|
|
@Autowired
|
|
private OhcTypeRepo ohcTypeRepo;
|
|
@GetMapping("/opd/{empId}")
|
|
public ResponseEntity<?> getEmployeeAppointmentsByEmpId(@PathVariable Long empId) {
|
|
// Fetch all appointments for the given employee ID
|
|
List<EmployeeAppointment> appointments = employeeAppointmentServiceImpl.getAppointmentsByPatientId(empId);
|
|
|
|
// Filter appointments where appointment_type is 'o'
|
|
List<EmployeeAppointment> filteredAppointments = appointments.stream()
|
|
.filter(appointment -> "o".equals(appointment.getAppointmentType()))
|
|
.collect(Collectors.toList());
|
|
|
|
List<Map<String, Object>> responseList = new ArrayList<>();
|
|
for (EmployeeAppointment appointment : filteredAppointments) {
|
|
List<Map<String, Object>> complaintsDetails = appointment.getComplaintIds() != null ?
|
|
Arrays.stream(appointment.getComplaintIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> complaintRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(complaint -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", complaint.getId());
|
|
map.put("label", complaint.getComplaint());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> recommendedTestsDetails = appointment.getCheckupFormSectionIds() != null ?
|
|
Arrays.stream(appointment.getCheckupFormSectionIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> checkupFormSectionRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(recommendedTest -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", recommendedTest.getId());
|
|
map.put("label", recommendedTest.getSectionName());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
Map<String, Object> response = new LinkedHashMap<>();
|
|
response.put("id", appointment.getId());
|
|
response.put("ticketNo", appointment.getTicketNo());
|
|
response.put("complaints", complaintsDetails);
|
|
response.put("appointmentDate", appointment.getAppointmentDate());
|
|
response.put("recommendedTests", recommendedTestsDetails);
|
|
responseList.add(response);
|
|
}
|
|
|
|
return new ResponseEntity<>(responseList, HttpStatus.OK);
|
|
}
|
|
@GetMapping("/injury/{empId}")
|
|
public ResponseEntity<?> getEmployeeInquiryAppointmentsByEmpId(@PathVariable Long empId) {
|
|
// Fetch all appointments for the given employee ID
|
|
List<EmployeeAppointment> appointments = employeeAppointmentServiceImpl.getAppointmentsByPatientId(empId);
|
|
|
|
// Filter appointments where appointment_type is 'i'
|
|
List<EmployeeAppointment> filteredAppointments = appointments.stream()
|
|
.filter(appointment -> "i".equals(appointment.getAppointmentType()))
|
|
.collect(Collectors.toList());
|
|
|
|
List<Map<String, Object>> responseList = new ArrayList<>();
|
|
for (EmployeeAppointment appointment : filteredAppointments) {
|
|
List<Map<String, Object>> complaintsDetails = appointment.getComplaintIds() != null ?
|
|
Arrays.stream(appointment.getComplaintIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> complaintRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(complaint -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", complaint.getId());
|
|
map.put("label", complaint.getComplaint());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> recommendedTestsDetails = appointment.getCheckupFormSectionIds() != null ?
|
|
Arrays.stream(appointment.getCheckupFormSectionIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> checkupFormSectionRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(recommendedTest -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", recommendedTest.getId());
|
|
map.put("label", recommendedTest.getSectionName());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
Map<String, Object> response = new LinkedHashMap<>();
|
|
response.put("id", appointment.getId());
|
|
response.put("ticketNo", appointment.getTicketNo());
|
|
response.put("complaints", complaintsDetails);
|
|
response.put("appointmentDate", appointment.getAppointmentDate());
|
|
response.put("recommendedTests", recommendedTestsDetails);
|
|
responseList.add(response);
|
|
}
|
|
|
|
return new ResponseEntity<>(responseList, HttpStatus.OK);
|
|
}
|
|
|
|
|
|
@GetMapping("/{appointmentId}")
|
|
public ResponseEntity<?> getEmployeeAppointmentById(@PathVariable Long appointmentId) {
|
|
EmployeeAppointment appointment = employeeAppointmentServiceImpl.getEmployeeAppointmentById(appointmentId);
|
|
|
|
List<Map<String, Object>> complaintsDetails = appointment.getComplaintIds() != null ?
|
|
Arrays.stream(appointment.getComplaintIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> complaintRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(complaint -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", complaint.getId());
|
|
map.put("label", complaint.getComplaint());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> examinationRemarksDetails = appointment.getExaminationRemarkIds() != null ?
|
|
Arrays.stream(appointment.getExaminationRemarkIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> examinationFindingsRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(examinationRemark -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", examinationRemark.getId());
|
|
map.put("label", examinationRemark.getExaminationFinding());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> ailmentsNewDetails = appointment.getAilmentIds() != null ?
|
|
Arrays.stream(appointment.getAilmentIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> ailmentRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(ailmentNew -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", ailmentNew.getId());
|
|
map.put("label", ailmentNew.getAilmentName());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> drugAllergyDetails = appointment.getSaltIds() != null ?
|
|
Arrays.stream(appointment.getSaltIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> saltMasterRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(drugAllergy -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", drugAllergy.getId());
|
|
map.put("label", drugAllergy.getSaltName());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> injuryTypesDetails = appointment.getInjuryTypeIds() != null ?
|
|
Arrays.stream(appointment.getInjuryTypeIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> injuryTypeRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(injuryType -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", injuryType.getId());
|
|
map.put("label", injuryType.getInjuryTypeName());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> injuryPartsDetails = appointment.getInjuryPartIds() != null ?
|
|
Arrays.stream(appointment.getInjuryPartIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> injuryPartRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(injuryPart -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", injuryPart.getId());
|
|
map.put("label", injuryPart.getName());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> injuryClassesDetails = appointment.getInjuryClassIds() != null ?
|
|
Arrays.stream(appointment.getInjuryClassIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> injuryClassRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(injuryClass -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", injuryClass.getId());
|
|
map.put("label", injuryClass.getInjClassName());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> injuryMechsDetails = appointment.getInjuryMechIds() != null ?
|
|
Arrays.stream(appointment.getInjuryMechIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> injuryMechanismRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(injuryMech -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", injuryMech.getId());
|
|
map.put("label", injuryMech.getInjuryMechName());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> healthAdvicesDetails = appointment.getHealthAdviceIds() != null ?
|
|
Arrays.stream(appointment.getHealthAdviceIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> healthAdviceRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(healthAdvice -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", healthAdvice.getId());
|
|
map.put("label", healthAdvice.getHealthAdviceName());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> recommendedTestsDetails = appointment.getCheckupFormSectionIds() != null ?
|
|
Arrays.stream(appointment.getCheckupFormSectionIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> checkupFormSectionRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(recommendedTest -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", recommendedTest.getId());
|
|
map.put("label", recommendedTest.getSectionName());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> recommendedTestParamsDetails = appointment.getCheckupParameterIds() != null ?
|
|
Arrays.stream(appointment.getCheckupParameterIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> checkupParameterRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(recommendedTestParam -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", recommendedTestParam.getId());
|
|
map.put("label", recommendedTestParam.getParameterName());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
List<Map<String, Object>> abnormalityDetails = appointment.getPrescriptionMasterIds() != null ?
|
|
Arrays.stream(appointment.getPrescriptionMasterIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> prescriptionMasterRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(abnormality -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", abnormality.getId());
|
|
map.put("label", abnormality.getChronicIllness());
|
|
return map;
|
|
})
|
|
.collect(Collectors.toList()) : new ArrayList<>();
|
|
|
|
Map<String, Object> referredByDetails = appointment.getReferredBy() != null ?
|
|
referredByRepo.findById(appointment.getReferredBy().getId())
|
|
.map(doctor -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", doctor.getId());
|
|
map.put("label", doctor.getReferredBy());
|
|
return map;
|
|
})
|
|
.orElseGet(() -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", " ");
|
|
map.put("label", " ");
|
|
return map;
|
|
}) : new LinkedHashMap<>();
|
|
|
|
Map<String, Object> referralDetails = appointment.getReferralPoint() != null ?
|
|
referralPointRepo.findById(appointment.getReferralPoint().getId())
|
|
.map(doctor -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", doctor.getId());
|
|
map.put("label", doctor.getReferralPointName());
|
|
return map;
|
|
})
|
|
.orElseGet(() -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", " ");
|
|
map.put("label", " ");
|
|
return map;
|
|
}) : new LinkedHashMap<>();
|
|
|
|
Map<String, Object> ohcTypeDetails = appointment.getOhcType() != null ?
|
|
ohcTypeRepo.findById(appointment.getOhcType().getId())
|
|
.map(ohcType -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", ohcType.getId());
|
|
map.put("label", ohcType.getOhcName());
|
|
return map;
|
|
})
|
|
.orElseGet(() -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", " ");
|
|
map.put("label", " ");
|
|
return map;
|
|
}) : new LinkedHashMap<>();
|
|
|
|
Map<String, Object> empDetails = appointment.getOhcType() != null ?
|
|
patientRepo.findById(appointment.getPatient().getId())
|
|
.map(ohcType -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", ohcType.getId());
|
|
map.put("label", ohcType.getPatientName());
|
|
return map;
|
|
})
|
|
.orElseGet(() -> {
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", " ");
|
|
map.put("label", " ");
|
|
return map;
|
|
}) : new LinkedHashMap<>();
|
|
|
|
Map<String, Object> response = new LinkedHashMap<>();
|
|
response.put("id", appointment.getId());
|
|
response.put("weight", appointment.getWeight());
|
|
response.put("height", appointment.getHeight());
|
|
response.put("bmi", appointment.getBmi());
|
|
response.put("bpSbp", appointment.getBpSbp());
|
|
response.put("bpDbp", appointment.getBpDbp());
|
|
response.put("temperature", appointment.getTemperature());
|
|
response.put("respiratoryRate", appointment.getRespiratoryRate());
|
|
response.put("pulseOutput", appointment.getPulseOutput());
|
|
response.put("spo2Percent", appointment.getSpo2Percent());
|
|
response.put("glasgowComaScale", appointment.getGlasgowComaScale());
|
|
response.put("ticketNo", appointment.getTicketNo());
|
|
response.put("appointmentDate", appointment.getAppointmentDate());
|
|
response.put("appointmentType",appointment.getAppointmentType());
|
|
response.put("clearanceTime", appointment.getClearanceTime());
|
|
response.put("caseType", appointment.getCaseType());
|
|
response.put("followupToOpd", appointment.getFollowupToOpd());
|
|
response.put("referredBy", referredByDetails);
|
|
response.put("complaints", complaintsDetails);
|
|
response.put("examinationRemarks", examinationRemarksDetails);
|
|
response.put("ailmentsNew", ailmentsNewDetails);
|
|
response.put("injuryTime", appointment.getInjuryTime());
|
|
response.put("injuryAreaCat", appointment.getInjuryAreaCat());
|
|
response.put("injuryAreaType", appointment.getInjuryAreaType());
|
|
response.put("incidentLocation", appointment.getIncidentLocation());
|
|
response.put("diseaseType", appointment.getDiseaseType());
|
|
response.put("drugAllergies", drugAllergyDetails);
|
|
response.put("docComment", appointment.getDocComment());
|
|
response.put("injuryTypes", injuryTypesDetails);
|
|
response.put("injuryParts", injuryPartsDetails);
|
|
response.put("injuryClasses", injuryClassesDetails);
|
|
response.put("injuryMechs", injuryMechsDetails);
|
|
response.put("injuryProcedure", appointment.getInjuryProcedure());
|
|
response.put("anyMedication", appointment.getAnyMedication());
|
|
response.put("abnormalitys", abnormalityDetails);
|
|
response.put("doctorDiscussed", appointment.getDoctorDiscussed());
|
|
response.put("healthAdvices", healthAdvicesDetails);
|
|
response.put("recommendedTests", recommendedTestsDetails);
|
|
response.put("recommendedTestParams", recommendedTestParamsDetails);
|
|
response.put("status", appointment.getStatus());
|
|
response.put("remarksRece", appointment.getRemarksRece());
|
|
response.put("followup", appointment.getFollowup());
|
|
response.put("followupRemarks", appointment.getFollowupRemarks());
|
|
response.put("restFromTime", appointment.getRestFromTime());
|
|
response.put("restToTime", appointment.getRestToTime());
|
|
response.put("injuryRemarks", appointment.getInjuryRemarks());
|
|
response.put("referralId", referralDetails);
|
|
response.put("referralDoc", appointment.getReferralDoc());
|
|
response.put("ambulanceUsed", appointment.getAmbulanceUsed());
|
|
response.put("dischargeTime", appointment.getDischargeTime());
|
|
response.put("empId", empDetails);
|
|
response.put("ohcTypeId", ohcTypeDetails);
|
|
response.put("modifiedBy", appointment.getModifiedBy());
|
|
response.put("lastModified", appointment.getLastModified());
|
|
|
|
return new ResponseEntity<>(response, HttpStatus.OK);
|
|
}
|
|
|
|
@GetMapping
|
|
public ResponseEntity<?> getAllEmployeeAppointments(@RequestParam(required = false) Integer page,
|
|
@RequestParam(required = false) Integer size,
|
|
@RequestParam(required = false) String sortBy,
|
|
@RequestParam(required = false) String sortOrder) {
|
|
Pageable pageable = PaginationUtil.getPageableWithDefaults(page, size, sortBy, sortOrder);
|
|
Page<EmployeeAppointment> appointmentPage = employeeAppointmentServiceImpl.getAllEmployeeAppointments(pageable);
|
|
|
|
Page<Map<String, Object>> dtoPage = appointmentPage.map(appointment -> {
|
|
|
|
List<String> complaintsNames = appointment.getComplaintIds() != null
|
|
? Arrays.stream(appointment.getComplaintIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> complaintRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(Complaint::getComplaint)
|
|
.collect(Collectors.toList())
|
|
: Collections.emptyList();
|
|
|
|
List<String> examinationRemarksNames = appointment.getExaminationRemarkIds() != null
|
|
? Arrays.stream(appointment.getExaminationRemarkIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> examinationFindingsRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(ExaminationFindings::getExaminationFinding)
|
|
.collect(Collectors.toList())
|
|
: Collections.emptyList();
|
|
|
|
List<String> ailmentsNames = appointment.getAilmentIds() != null
|
|
? Arrays.stream(appointment.getAilmentIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> ailmentRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(Ailment::getAilmentName)
|
|
.collect(Collectors.toList())
|
|
: Collections.emptyList();
|
|
|
|
List<String> drugAllergiesNames = appointment.getSaltIds() != null
|
|
? Arrays.stream(appointment.getSaltIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> saltMasterRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(SaltMaster::getSaltName)
|
|
.collect(Collectors.toList())
|
|
: Collections.emptyList();
|
|
|
|
List<String> injuryTypesNames = appointment.getInjuryTypeIds() != null
|
|
? Arrays.stream(appointment.getInjuryTypeIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> injuryTypeRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(InjuryType::getInjuryTypeName)
|
|
.collect(Collectors.toList())
|
|
: Collections.emptyList();
|
|
|
|
List<String> injuryPartsNames = appointment.getInjuryPartIds() != null
|
|
? Arrays.stream(appointment.getInjuryPartIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> injuryPartRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(InjuryPart::getName)
|
|
.collect(Collectors.toList())
|
|
: Collections.emptyList();
|
|
|
|
List<String> injuryClassesNames = appointment.getInjuryClassIds() != null
|
|
? Arrays.stream(appointment.getInjuryClassIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> injuryClassRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(InjuryClass::getInjClassName)
|
|
.collect(Collectors.toList())
|
|
: Collections.emptyList();
|
|
|
|
List<String> injuryMechsNames = appointment.getInjuryMechIds() != null
|
|
? Arrays.stream(appointment.getInjuryMechIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> injuryMechanismRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(InjuryMechanism::getInjuryMechName)
|
|
.collect(Collectors.toList())
|
|
: Collections.emptyList();
|
|
|
|
List<String> healthAdvicesNames = appointment.getHealthAdviceIds() != null
|
|
? Arrays.stream(appointment.getHealthAdviceIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> healthAdviceRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(HealthAdvice::getHealthAdviceName)
|
|
.collect(Collectors.toList())
|
|
: Collections.emptyList();
|
|
|
|
List<String> recommendedTestsNames = appointment.getCheckupFormSectionIds() != null
|
|
? Arrays.stream(appointment.getCheckupFormSectionIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> checkupFormSectionRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(CheckupFormSection::getSectionName)
|
|
.collect(Collectors.toList())
|
|
: Collections.emptyList();
|
|
|
|
List<String> recommendedTestParamsNames = appointment.getCheckupParameterIds() != null
|
|
? Arrays.stream(appointment.getCheckupParameterIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> checkupParameterRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(CheckupParameter::getParameterName)
|
|
.collect(Collectors.toList())
|
|
: Collections.emptyList();
|
|
|
|
List<Abnormality> abnormalityNames = appointment.getPrescriptionMasterIds() != null
|
|
? Arrays.stream(appointment.getPrescriptionMasterIds().split(","))
|
|
.filter(id -> !id.trim().isEmpty())
|
|
.map(Long::valueOf)
|
|
.map(id -> prescriptionMasterRepo.findById(id).orElse(null))
|
|
.filter(Objects::nonNull)
|
|
.map(PrescriptionMaster::getChronicIllness)
|
|
.collect(Collectors.toList())
|
|
: Collections.emptyList();
|
|
|
|
String referredByName = appointment.getReferredBy() != null
|
|
? referredByRepo.findById(appointment.getReferredBy().getId())
|
|
.map(ReferredBy::getReferredBy)
|
|
.orElse("Unknown")
|
|
: null ;
|
|
|
|
String referralName = appointment.getReferralPoint() != null
|
|
? referralPointRepo.findById(appointment.getReferralPoint().getId())
|
|
.map(ReferralPoint::getReferralPointName)
|
|
.orElse("Unknown")
|
|
: null ;
|
|
|
|
String ohcName = appointment.getOhcType() != null
|
|
? ohcTypeRepo.findById(appointment.getOhcType().getId())
|
|
.map(OhcType::getOhcName)
|
|
.orElse("Unknown")
|
|
: null ;
|
|
|
|
String empName = appointment.getPatient() != null
|
|
? patientRepo.findById(appointment.getPatient().getId())
|
|
.map(Patient::getPatientName)
|
|
.orElse("Unknown")
|
|
: null ;
|
|
|
|
Map<String, Object> map = new LinkedHashMap<>();
|
|
map.put("id", appointment.getId());
|
|
map.put("weight", appointment.getWeight());
|
|
map.put("height", appointment.getHeight());
|
|
map.put("bmi", appointment.getBmi());
|
|
map.put("bpSbp", appointment.getBpSbp());
|
|
map.put("bpDbp", appointment.getBpDbp());
|
|
map.put("temperature", appointment.getTemperature());
|
|
map.put("respiratoryRate", appointment.getRespiratoryRate());
|
|
map.put("pulseOutput", appointment.getPulseOutput());
|
|
map.put("spo2Percent", appointment.getSpo2Percent());
|
|
map.put("glasgowComaScale", appointment.getGlasgowComaScale());
|
|
map.put("ticketNo", appointment.getTicketNo());
|
|
map.put("appointmentDate", appointment.getAppointmentDate());
|
|
map.put("appointmentType",appointment.getAppointmentType());
|
|
map.put("clearanceTime", appointment.getClearanceTime());
|
|
map.put("caseType", appointment.getCaseType());
|
|
map.put("followupToOpd", appointment.getFollowupToOpd());
|
|
map.put("referredBy", referredByName);
|
|
map.put("complaints", complaintsNames);
|
|
map.put("examinationRemarks", examinationRemarksNames);
|
|
map.put("ailmentsNew", ailmentsNames);
|
|
map.put("injuryTime", appointment.getInjuryTime());
|
|
map.put("injuryAreaCat", appointment.getInjuryAreaCat());
|
|
map.put("injuryAreaType", appointment.getInjuryAreaType());
|
|
map.put("incidentLocation", appointment.getIncidentLocation());
|
|
map.put("diseaseType", appointment.getDiseaseType());
|
|
map.put("drugAllergies", drugAllergiesNames);
|
|
map.put("docComment", appointment.getDocComment());
|
|
map.put("injuryTypes", injuryTypesNames);
|
|
map.put("injuryParts", injuryPartsNames);
|
|
map.put("injuryClasses", injuryClassesNames);
|
|
map.put("injuryMechs", injuryMechsNames);
|
|
map.put("injuryProcedure", appointment.getInjuryProcedure());
|
|
map.put("anyMedication", appointment.getAnyMedication());
|
|
map.put("abnormalitys", abnormalityNames);
|
|
map.put("doctorDiscussed", appointment.getDoctorDiscussed());
|
|
map.put("healthAdvices", healthAdvicesNames);
|
|
map.put("recommendedTests", recommendedTestsNames);
|
|
map.put("recommendedTestParams", recommendedTestParamsNames);
|
|
map.put("status", appointment.getStatus());
|
|
map.put("remarksRece", appointment.getRemarksRece());
|
|
map.put("followup", appointment.getFollowup());
|
|
map.put("followupRemarks", appointment.getFollowupRemarks());
|
|
map.put("restFromTime", appointment.getRestFromTime());
|
|
map.put("restToTime", appointment.getRestToTime());
|
|
map.put("injuryRemarks", appointment.getInjuryRemarks());
|
|
map.put("referralId", referralName);
|
|
map.put("referralDoc", appointment.getReferralDoc());
|
|
map.put("ambulanceUsed", appointment.getAmbulanceUsed());
|
|
map.put("dischargeTime", appointment.getDischargeTime());
|
|
map.put("empId", empName);
|
|
map.put("ohcTypeId", ohcName);
|
|
map.put("modifiedBy", appointment.getModifiedBy());
|
|
map.put("lastModified", appointment.getLastModified());
|
|
|
|
return map;
|
|
});
|
|
|
|
Map<String, Object> response = PaginationUtil.getPageResponse(dtoPage);
|
|
return new ResponseEntity<>(response, HttpStatus.OK);
|
|
}
|
|
|
|
@PostMapping
|
|
public ResponseEntity<Map<String, Object>> addEmployeeAppointment(@Valid @RequestBody EmployeeAppointmentDto employeeAppointmentDto) {
|
|
Long userId = authServiceImpl.getCurrentUserId();
|
|
EmployeeAppointment savedAppointment = employeeAppointmentServiceImpl.addEmployeeAppointment(employeeAppointmentDto, userId);
|
|
|
|
Map<String, Object> response = new HashMap<>();
|
|
response.put("appointmentId", savedAppointment.getId());
|
|
response.put("message", "Saved Successfully");
|
|
|
|
return new ResponseEntity<>(response, HttpStatus.CREATED);
|
|
}
|
|
|
|
@PutMapping("/{appointmentId}")
|
|
public ResponseEntity<?> updateEmployeeAppointment(@Valid @RequestBody EmployeeAppointmentDto employeeAppointmentDto) {
|
|
Long userId = authServiceImpl.getCurrentUserId();
|
|
employeeAppointmentServiceImpl.updateEmployeeAppointment(employeeAppointmentDto, userId);
|
|
return new ResponseEntity<>("Updated Successfully", HttpStatus.OK);
|
|
}
|
|
|
|
@DeleteMapping("/{appointmentId}")
|
|
public ResponseEntity<?> deleteEmployeeAppointment(@PathVariable Long appointmentId) {
|
|
employeeAppointmentServiceImpl.deleteEmployeeAppointment(appointmentId);
|
|
return new ResponseEntity<>(HttpStatus.OK);
|
|
}
|
|
}
|