/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.bestray.healthcareemr.Controller;

import com.bestray.healthcarecommonutil.exception.ProcessingException;
import com.bestray.healthcarecommonutil.service.AllergiesMasterService;
import com.bestray.healthcarecommonutil.service.DiagnosisMasterService;
import com.bestray.healthcarecommonutil.service.MedicationMasterService;
import com.bestray.healthcarecommonutil.service.ProcedureMasterService;
import com.bestray.healthcarecommonutil.util.TimeRange;
import com.bestray.healthcarecommonutil.vo.TAllergiesMaster;
import com.bestray.healthcarecommonutil.vo.TAppointment;
import com.bestray.healthcarecommonutil.vo.TDepartmentMaster;
import com.bestray.healthcarecommonutil.vo.TDiagnosisMaster;
import com.bestray.healthcarecommonutil.vo.TDoctorInformation;
import com.bestray.healthcarecommonutil.vo.TEncounterAllergy;
import com.bestray.healthcarecommonutil.vo.TEncounterDiagnosis;
import com.bestray.healthcarecommonutil.vo.TEncounterHistoryVisit;
import com.bestray.healthcarecommonutil.vo.TEncounterMedication;
import com.bestray.healthcarecommonutil.vo.TEncounterProcedure;
import com.bestray.healthcarecommonutil.vo.TEncounterVitalSign;
import com.bestray.healthcarecommonutil.vo.TMedicationMaster;
import com.bestray.healthcarecommonutil.vo.TPatEncOrderResults;
import com.bestray.healthcarecommonutil.vo.TPatient;
import com.bestray.healthcarecommonutil.vo.TPatientEncounter;
import com.bestray.healthcarecommonutil.vo.TProcedureMaster;
import com.bestray.healthcareemr.Service.PatientEncounterAllergiesService;
import com.bestray.healthcareemr.Service.PatientEncounterDiagnosisService;
import com.bestray.healthcareemr.Service.PatientEncounterMedicationService;
import com.bestray.healthcareemr.Service.PatientEncounterProcedureService;
import com.bestray.healthcareemr.Service.PatientEncounterService;
import com.bestray.healthcareemr.Service.PatientEncounterVisitHistoryService;
import com.bestray.healthcareemr.Service.PatientEncounterVitalSignsService;
import com.bestray.healthcareemr.Vo.XrayImage;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.Vector;
import javax.swing.JTable;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateOptimisticLockingFailureException;
import org.springframework.stereotype.Controller;

// TODO: Auto-generated Javadoc
/**
 * The Class OutPatientController.
 *
 * @author user3
 */
@Controller
public class OutPatientController {
    
    /** The out patient service. */
    @Autowired
    private PatientEncounterService patientEncounterService;
    @Autowired
    private PatientEncounterAllergiesService patientEncounterAllergiesService;
    @Autowired
    private PatientEncounterDiagnosisService patientEncounterDiagnosisService;
    @Autowired
    private PatientEncounterMedicationService patientEncounterMedicationService;
    @Autowired
    private PatientEncounterProcedureService patientEncounterProcedureService;
    @Autowired
    private PatientEncounterVitalSignsService patientEncounterVitalSignsService;
    @Autowired
    private PatientEncounterVisitHistoryService patientEncounterVisitHistoryService;
    @Autowired
    private AllergiesMasterService allergiesMasterService;
    @Autowired
    private ProcedureMasterService procedureMasterService;
    @Autowired
    private DiagnosisMasterService diagnosisMasterService;
    @Autowired
    private MedicationMasterService medicationMasterService;
    
    private SimpleDateFormat sdftime = new SimpleDateFormat("hh:mm a");
    
    private SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy");
    
    /**
     * Instantiates a new out patient controller.
     *
     * @param outPatientService the out patient service
     */
        
    /*public TPatientEncounter savePatientInfo(TPatientEncounter encounter,String allergyname,TEncounterAllergy encounterAllergy)throws ProcessingException {
        try{
            TPatientEncounter enc = outPatientService.savePatientInfo(encounter,allergyname,encounterAllergy);
            return enc;
        }catch(ProcessingException e){
            throw e;
        }
    }*/

    /**
     * Save encounter.
     *
     * @param encounter the encounter
     * @param allergy_table the allergy_table
     * @param medication_table the medication_table
     * @param procedure_table the procedure_table
     * @param vitalsign the vitalsign
     * @param visitHistory the visit history
     * @throws ProcessingException the processing exception
     */
    public TPatientEncounter saveEncounter(TPatientEncounter encounter, JTable allergy_table, JTable medication_table,JTable diagnosis_table, JTable procedure_table,TEncounterVitalSign vitalsign,TEncounterHistoryVisit visitHistory,List<Long> removeprocids,List<Long> removediaglist,List<Long> removeallergylist) throws ProcessingException,HibernateOptimisticLockingFailureException {
        try{
            return patientEncounterService.saveEncounter(encounter,allergy_table,medication_table,procedure_table,diagnosis_table,vitalsign,visitHistory,removeprocids,removediaglist,removeallergylist);
        }catch(  HibernateOptimisticLockingFailureException | ProcessingException | IllegalArgumentException e){
            throw e;
        }
    }

    /**
     * Gets the encounter dates.
     *
     * @param patientinfo the patientinfo
     * @return the encounter dates
     * @throws ProcessingException the processing exception
     */
    public List<TPatientEncounter> getEncounterDates(TPatient patientinfo) throws ProcessingException {
        try{
            return patientEncounterService.getEncounterDates(patientinfo);
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Count number of visit.
     *
     * @param patientinfo the patientinfo
     * @return the string
     * @throws ProcessingException the processing exception
     */
    public String countNumberOfVisit(TPatient patientinfo) throws ProcessingException {
        try{
            return patientEncounterService.countNumberOfVisit(patientinfo);
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Gets the medication.
     *
     * @param encid the encid
     * @return the medication
     * @throws ProcessingException the processing exception
     */
    public List<TEncounterMedication> getEncounterMedication(List<TPatientEncounter> encid, int status) throws ProcessingException {
        try{
           return patientEncounterMedicationService.getEncounterMedication(encid,status);
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Gets the vital details.
     *
     * @param encid the encid
     * @return the vital details
     * @throws ProcessingException the processing exception
     */
    public TEncounterVitalSign getEncounterVitalDetails(TPatientEncounter encid) throws ProcessingException{
        try{
           return patientEncounterVitalSignsService.getEncounterVitalDetails(encid);
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Gets the encounter.
     *
     * @param encid the encid
     * @return the encounter
     * @throws ProcessingException the processing exception
     */
    public TPatientEncounter getEncounterById(Long encid)throws ProcessingException {
        try{
           return patientEncounterService.getEncounterById(encid);
        }catch(ProcessingException e){
            throw e;
        }
    }


    /**
     * Gets the allergy.
     *
     * @param enc the enc
     * @return the allergy
     * @throws ProcessingException the processing exception
     */
    public List<TEncounterAllergy> getEncounterAllergy(TPatientEncounter enc)throws ProcessingException {
        try{
           return patientEncounterAllergiesService.getEncounterAllergy(enc);
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Gets the labs procedure.
     *
     * @param enc the enc
     * @return the labs procedure
     * @throws ProcessingException the processing exception
     */
    public List<TEncounterProcedure> getEncounterLabsProcedure(TPatientEncounter enc)throws ProcessingException {
        try{
           return patientEncounterProcedureService.getEncounterLabsProcedure(enc);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public List<TEncounterMedication> getEncounterMedication(TPatientEncounter enc) throws ProcessingException{
        try{
           return patientEncounterMedicationService.getEncounterMedicationsList(enc);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public TPatientEncounter getEncounterByAppoitment(TAppointment appointmentinfo)throws ProcessingException {
        try{
           return patientEncounterService.getEncounterByAppoitment(appointmentinfo);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public TEncounterHistoryVisit getEncounterVistiHistory(TPatientEncounter patenc)throws ProcessingException{
        try{
           return patientEncounterVisitHistoryService.getEncounterVistiHistory(patenc);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public List<TEncounterDiagnosis> getEncounterDiagnosis(TPatientEncounter patenc)throws ProcessingException {
        try{
           return patientEncounterDiagnosisService.getEncounterDiagnosis(patenc);
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public TEncounterProcedure getProcedureByEncounterAndProcedure(TProcedureMaster procedure,TPatientEncounter encounterProcedure)throws ProcessingException{
        try{
           return patientEncounterProcedureService.getProcedureByEncounterAndProcedure(procedure,encounterProcedure);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public List<TPatEncOrderResults> getLabResultsByProcedureId(TEncounterProcedure encprocedure)throws ProcessingException {
        try{
           return patientEncounterService.getLabResultsByProcedureId(encprocedure);
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public TEncounterProcedure getProcedureEncounterByID(Long ID)throws ProcessingException {
        try{
            return patientEncounterProcedureService.getProcedureEncounterByID(ID);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public Vector<Vector<String>> getOPAppointmentListByDate(Date appointmentDate)throws ProcessingException{
        try {
            Vector<Vector<String>> appointments = new Vector<Vector<String>>();
            Vector<String> appointmentVector;
            List<TAppointment> appointmentList = patientEncounterService.getOPAppointmentListByDate(appointmentDate);
            
            for (TAppointment appointment : appointmentList) {
                appointmentVector = new Vector<String>();
                appointmentVector.add(String.valueOf(appointment.getId()));
                if(appointment.getPatientOpdNumber()!=null){
                appointmentVector.add(String.valueOf(appointment.getPatientOpdNumber()));
                }else{
                appointmentVector.add("");
                }
                appointmentVector.add(String.valueOf(sdf.format(appointment.getAppointmentDate())));
                appointmentVector.add(String.valueOf(appointment.getAppointmentTime()));
                TPatient patient = appointment.getPatientNameId();
                String patientFullName = null;
                if(patient!=null){
                if(patient.getPatientMName()!=null){
                    patientFullName = patient.getPatientFName()+" "+patient.getPatientMName()+" "+patient.getPatientLName();
                }else if(patient.getPatientMName()==null){
                    patientFullName = patient.getPatientFName()+" "+patient.getPatientLName();
                }
                appointmentVector.add(patientFullName);
                /*if(patient.getPatientHtNumber()==null){
                appointmentVector.add("");
                }else{
                appointmentVector.add(String.valueOf(patient.getPatientHtNumber()));
                }*/
                appointmentVector.add(String.valueOf(appointment.getScheduleType()));
                }
                //appointmentVector.add(String.valueOf(departmentMasterDao.getDepartmentDetails(appointment.getDepartmentNameId()).getDepartmentName()));
                appointmentVector.add(appointment.getDoctorNameId().getDoctor_name());
                appointmentVector.add(String.valueOf(appointment.getVisitType()));
                if(appointment.getPatientStatus().equalsIgnoreCase("SCHEDULED")){
                    appointmentVector.add("Scheduled");
                }else if(appointment.getPatientStatus().equalsIgnoreCase("CHECKED-IN")){
                    appointmentVector.add("Arrived");
                }else if(appointment.getPatientStatus().equalsIgnoreCase("CHECKED-OUT")){
                    appointmentVector.add("Checked-out");
                }else if(appointment.getPatientStatus().equalsIgnoreCase("CANCELED")){
                    appointmentVector.add("Canceled");
                }
                if(appointment.getPatientCheckinTime()!=null){
                appointmentVector.add(String.valueOf(sdftime.format(appointment.getPatientCheckinTime())));
                }else{
                appointmentVector.add("");
                }
                if(appointment.getPatientCheckoutTime()!=null){
                appointmentVector.add(String.valueOf(sdftime.format(appointment.getPatientCheckoutTime())));
                }else{
                appointmentVector.add("");
                }
                if(appointment.getPatientCheckoutTime()!=null && appointment.getPatientCheckinTime()!=null){
                    String visitDuration = TimeRange.visitDuration(appointment.getPatientCheckoutTime(),appointment.getPatientCheckinTime());
                    appointmentVector.add(visitDuration);
                }else{
                    appointmentVector.add("");
                }
                if(appointment.getPaidAmount()==0&&appointment.getFree_patient().equalsIgnoreCase("FREE PATIENT")){
                appointmentVector.add("FREE PATIENT");
                }else if(appointment.getPaidAmount()==0&&appointment.getFree_patient().equalsIgnoreCase("PAID PATIENT")){
                appointmentVector.add("");
                }else{
                appointmentVector.add(String.valueOf(appointment.getPaidAmount()));
                }
                appointments.add(appointmentVector);
            }
            return appointments;
        }catch(ProcessingException e){
            throw e;
        }
    }

    public Vector<TDiagnosisMaster> getDiagnosis(String expr)throws ProcessingException {
        try{
            Vector<TDiagnosisMaster> diagnosis = new Vector<TDiagnosisMaster>();
            List<TDiagnosisMaster> diagnosisList = patientEncounterDiagnosisService.getDiagnosis(expr);
            for(TDiagnosisMaster diagnos:diagnosisList){
                diagnosis.addElement(diagnos);
            }
            return diagnosis;
        }catch(ProcessingException e){
            throw e;
        }
    }

    public Vector<Vector<String>> getOPAppointmentListByDepartment(Date date, TDepartmentMaster departmentValues)throws ProcessingException {
        try {
            Vector<Vector<String>> appointments = new Vector<Vector<String>>();
            Vector<String> appointmentVector;
            List<TAppointment> appointmentList = patientEncounterService.getOPAppointmentListByDepartment(date,departmentValues);
            
            for (TAppointment appointment : appointmentList) {
                appointmentVector = new Vector<String>();
                appointmentVector.add(String.valueOf(appointment.getId()));
                if(appointment.getPatientOpdNumber()!=null){
                appointmentVector.add(String.valueOf(appointment.getPatientOpdNumber()));
                }else{
                appointmentVector.add("");
                }
                appointmentVector.add(String.valueOf(sdf.format(appointment.getAppointmentDate())));
                appointmentVector.add(String.valueOf(appointment.getAppointmentTime()));
                TPatient patient = appointment.getPatientNameId();
                String patientFullName = null;
                if(patient!=null){
                if(patient.getPatientMName()!=null){
                    patientFullName = patient.getPatientFName()+" "+patient.getPatientMName()+" "+patient.getPatientLName();
                }else if(patient.getPatientMName()==null){
                    patientFullName = patient.getPatientFName()+" "+patient.getPatientLName();
                }
                appointmentVector.add(patientFullName);
                /*if(patient.getPatientHtNumber()==null){
                appointmentVector.add("");
                }else{
                appointmentVector.add(String.valueOf(patient.getPatientHtNumber()));
                }*/
                appointmentVector.add(String.valueOf(appointment.getScheduleType()));
                }
                //appointmentVector.add(String.valueOf(departmentMasterDao.getDepartmentDetails(appointment.getDepartmentNameId()).getDepartmentName()));
                appointmentVector.add(appointment.getDoctorNameId().getDoctor_name());
                appointmentVector.add(String.valueOf(appointment.getVisitType()));
                if(appointment.getPatientStatus().equalsIgnoreCase("SCHEDULED")){
                    appointmentVector.add("Scheduled");
                }else if(appointment.getPatientStatus().equalsIgnoreCase("CHECKED-IN")){
                    appointmentVector.add("Arrived");
                }else if(appointment.getPatientStatus().equalsIgnoreCase("CHECKED-OUT")){
                    appointmentVector.add("Checked-out");
                }else if(appointment.getPatientStatus().equalsIgnoreCase("CANCELED")){
                    appointmentVector.add("Canceled");
                }
                if(appointment.getPatientCheckinTime()!=null){
                appointmentVector.add(String.valueOf(sdftime.format(appointment.getPatientCheckinTime())));
                }else{
                appointmentVector.add("");
                }
                if(appointment.getPatientCheckoutTime()!=null){
                appointmentVector.add(String.valueOf(sdftime.format(appointment.getPatientCheckoutTime())));
                }else{
                appointmentVector.add("");
                }
                if(appointment.getPatientCheckoutTime()!=null && appointment.getPatientCheckinTime()!=null){
                    String visitDuration = TimeRange.visitDuration(appointment.getPatientCheckoutTime(),appointment.getPatientCheckinTime());
                    appointmentVector.add(visitDuration);
                }else{
                    appointmentVector.add("");
                }
                if(appointment.getPaidAmount()==0&&appointment.getFree_patient().equalsIgnoreCase("FREE PATIENT")){
                appointmentVector.add("FREE PATIENT");
                }else if(appointment.getPaidAmount()==0&&appointment.getFree_patient().equalsIgnoreCase("PAID PATIENT")){
                appointmentVector.add("");
                }else{
                appointmentVector.add(String.valueOf(appointment.getPaidAmount()));
                }
                appointments.add(appointmentVector);
            }
            return appointments;
        }catch(ProcessingException e){
            throw e;
        }
    }

    public Vector<Vector<String>> getOPAppointmentListByDoctor(Date date, TDepartmentMaster departmentValues, TDoctorInformation DoctorDetails) throws ProcessingException{
        try {
            Vector<Vector<String>> appointments = new Vector<Vector<String>>();
            Vector<String> appointmentVector;
            List<TAppointment> appointmentList = patientEncounterService.getOPAppointmentListByDoctor(date,departmentValues,DoctorDetails);
            
            for (TAppointment appointment : appointmentList) {
                appointmentVector = new Vector<String>();
                appointmentVector.add(String.valueOf(appointment.getId()));
                if(appointment.getPatientOpdNumber()!=null){
                appointmentVector.add(String.valueOf(appointment.getPatientOpdNumber()));
                }else{
                appointmentVector.add("");
                }
                appointmentVector.add(String.valueOf(sdf.format(appointment.getAppointmentDate())));
                appointmentVector.add(String.valueOf(appointment.getAppointmentTime()));
                TPatient patient = appointment.getPatientNameId();
                String patientFullName = null;
                if(patient!=null){
                if(patient.getPatientMName()!=null){
                    patientFullName = patient.getPatientFName()+" "+patient.getPatientMName()+" "+patient.getPatientLName();
                }else if(patient.getPatientMName()==null){
                    patientFullName = patient.getPatientFName()+" "+patient.getPatientLName();
                }
                appointmentVector.add(patientFullName);
                /*if(patient.getPatientHtNumber()==null){
                appointmentVector.add("");
                }else{
                appointmentVector.add(String.valueOf(patient.getPatientHtNumber()));
                }*/
                appointmentVector.add(String.valueOf(appointment.getScheduleType()));
                }
                //appointmentVector.add(String.valueOf(departmentMasterDao.getDepartmentDetails(appointment.getDepartmentNameId()).getDepartmentName()));
                appointmentVector.add(appointment.getDoctorNameId().getDoctor_name());
                appointmentVector.add(String.valueOf(appointment.getVisitType()));
                if(appointment.getPatientStatus().equalsIgnoreCase("SCHEDULED")){
                    appointmentVector.add("Scheduled");
                }else if(appointment.getPatientStatus().equalsIgnoreCase("CHECKED-IN")){
                    appointmentVector.add("Arrived");
                }else if(appointment.getPatientStatus().equalsIgnoreCase("CHECKED-OUT")){
                    appointmentVector.add("Checked-out");
                }else if(appointment.getPatientStatus().equalsIgnoreCase("CANCELED")){
                    appointmentVector.add("Canceled");
                }
                if(appointment.getPatientCheckinTime()!=null){
                appointmentVector.add(String.valueOf(sdftime.format(appointment.getPatientCheckinTime())));
                }else{
                appointmentVector.add("");
                }
                if(appointment.getPatientCheckoutTime()!=null){
                appointmentVector.add(String.valueOf(sdftime.format(appointment.getPatientCheckoutTime())));
                }else{
                appointmentVector.add("");
                }
                if(appointment.getPatientCheckoutTime()!=null && appointment.getPatientCheckinTime()!=null){
                    String visitDuration = TimeRange.visitDuration(appointment.getPatientCheckoutTime(),appointment.getPatientCheckinTime());
                    appointmentVector.add(visitDuration);
                }else{
                    appointmentVector.add("");
                }
                if(appointment.getPaidAmount()==0&&appointment.getFree_patient().equalsIgnoreCase("FREE PATIENT")){
                appointmentVector.add("FREE PATIENT");
                }else if(appointment.getPaidAmount()==0&&appointment.getFree_patient().equalsIgnoreCase("PAID PATIENT")){
                appointmentVector.add("");
                }else{
                appointmentVector.add(String.valueOf(appointment.getPaidAmount()));
                }
                appointments.add(appointmentVector);
            }
            return appointments;
        }catch(ProcessingException e){
            throw e;
        }
    }

    public List<Object> /*TPatientEncounter*/ saveEncounter(TPatientEncounter patientenc,TEncounterHistoryVisit vh,
            List<TEncounterAllergy> encallergy,TEncounterVitalSign vitalsigns,List<Long> removeallergylist,
            List<TEncounterProcedure> encprocedure,List<Long> removeproclist,List<TEncounterMedication> encmedication,
            List<TEncounterDiagnosis> encdiagnosis,List<Long> removediagnosislist)throws ProcessingException {
        try{
           return patientEncounterService.saveEncounter(patientenc,vh,encallergy,vitalsigns,removeallergylist,
                   encprocedure,removeproclist,encmedication,encdiagnosis,removediagnosislist);
        }catch(Exception e){
            throw e;
        }
    }

    public TEncounterHistoryVisit saveVisitHistoryEnc(TEncounterHistoryVisit vh, TPatientEncounter patencbyappoitornew)throws ProcessingException {
        try{
           return patientEncounterService.saveVisitHistoryEnc(vh,patencbyappoitornew);
        }catch(Exception e){
            throw e;
        }
    }

    public TAllergiesMaster getAllergy(String allergyname) throws ProcessingException {
        try{
           List<TAllergiesMaster> allergys = allergiesMasterService.searchForAllergyName(allergyname);
           return (allergys.isEmpty())?null:allergys.get(0);
        }catch(Exception e){
            throw e;
        }
    }

    public TEncounterAllergy getEncAllergyById(Long id) throws ProcessingException{
        try{
           return patientEncounterService.getEncAllergyById(id);
        }catch(Exception e){
            throw e;
        }
    }

    public void saveAllergiesMaster(TAllergiesMaster allergy) throws ProcessingException {
        try{
           allergiesMasterService.saveAllergiesMaster(allergy);
        }catch(Exception e){
            throw e;
        }
    }

    public TProcedureMaster getProcedure(String procedurename)throws ProcessingException {
        try{
           return procedureMasterService.getProcedureByName(procedurename);
        }catch(Exception e){
            throw e;
        }
    }

    public void saveProcedureMaster(TProcedureMaster procedure)throws ProcessingException {
        try{
           patientEncounterService.saveProcedureMaster(procedure);
        }catch(Exception e){
            throw e;
        }
    }

    public TMedicationMaster getMedication(String medicationname)throws ProcessingException {
        try{
           List<TMedicationMaster> medic = medicationMasterService.getMedicationByName(medicationname);
           return (medic.isEmpty())?null:medic.get(0);
        }catch(Exception e){
            throw e;
        }
    }

    public void saveMedicationMaster(TMedicationMaster medication)throws ProcessingException {
        try{
           medicationMasterService.saveMedicationMaster(medication);
        }catch(Exception e){
            throw e;
        }
    }

    public TEncounterMedication getEncMedById(long id)throws ProcessingException {
        try{
           return patientEncounterService.getEncMedById(id);
        }catch(Exception e){
            throw e;
        }
    }

    public TDiagnosisMaster getDiagnosisByName(String diagnosisname)throws ProcessingException {
        try{
           List<TDiagnosisMaster> diagnosis = patientEncounterDiagnosisService.getDiagnosis(diagnosisname);
           return (diagnosis.isEmpty())?null:diagnosis.get(0);
        }catch(Exception e){
            throw e;
        }
    }

    public void saveDiagnosisMaster(TDiagnosisMaster diagnosis)throws ProcessingException {
        try{
           diagnosisMasterService.saveDiagnosisMaster(diagnosis);
        }catch(Exception e){
            throw e;
        }
    }

    public TEncounterDiagnosis getEncDiagById(Long id)throws ProcessingException{
        try{
           return patientEncounterDiagnosisService.getEncDiagById(id);
        }catch(Exception e){
            throw e;
        }
    }
    
    public void savexrayimages(Set<XrayImage> xrayImages)throws ProcessingException {
        try{
           patientEncounterService.savexrayimages(xrayImages);
        }catch(Exception e){
            throw e;
        }
    }
    
    public List<XrayImage> getXrayImages(TPatientEncounter patientenc)throws ProcessingException {
        try{
           return patientEncounterService.getXrayImages(patientenc);
        }catch(Exception e){
            throw e;
        }
    }

    public TPatientEncounter createNewEncounter(TPatientEncounter encounter) throws ProcessingException{
        try{
           return patientEncounterService.createNewEncounter(encounter);
        }catch(Exception e){
            throw e;
        }
    }
}