/*
 * 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.ProcedureComponentService;
import com.bestray.healthcarecommonutil.service.ProcedureMasterService;
import com.bestray.healthcarecommonutil.vo.TComponentMaster;
import com.bestray.healthcarecommonutil.vo.TProcedureMaster;
import java.util.List;
import java.util.Vector;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateOptimisticLockingFailureException;
import org.springframework.stereotype.Controller;

// TODO: Auto-generated Javadoc
/**
 * The Class ProcedureMasterController.
 *
 * @author user3
 */
@Controller
public class ProcedureMasterController {
     
     /** The procedure master service. */
     @Autowired
     private ProcedureMasterService procedureMasterService;
     @Autowired
     private ProcedureComponentService procedureComponentService;
    
    /**
     * Instantiates a new procedure master controller.
     *
     * @param procedureMasterService the procedure master service
     
    public ProcedureMasterController(ProcedureMasterService procedureMasterService,ProcedureComponentService procedureComponentService) {
        this.procedureMasterService= procedureMasterService;
        this.procedureComponentService = procedureComponentService;
    }
    
    /**
     * Save procedure master.
     *
     * @param procedureMaster the procedure master
     * @throws ProcessingException the processing exception
     * @throws HibernateOptimisticLockingFailureException the hibernate optimistic locking failure exception
     */
    public void saveProcedureMaster(TProcedureMaster procedureMaster,List<TComponentMaster> componentSelectedList)throws ProcessingException,HibernateOptimisticLockingFailureException {
        try{
            procedureMasterService.saveProcedureMaster(procedureMaster,componentSelectedList);
        }catch(  HibernateOptimisticLockingFailureException | ProcessingException e){
            throw e;
        }
    }

    /**
     * Gets the procedure list.
     *
     * @param expr the expr
     * @param min the min
     * @param max the max
     * @return the procedure list
     * @throws ProcessingException the processing exception
     */
    public Vector<Vector<String>> getProcedureList(String expr,int min,int max)throws ProcessingException {
        try{
            return procedureMasterService.getProcedureList(expr,min,max);
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Delete procedure master.
     *
     * @param procedureId the procedure id
     * @throws ProcessingException the processing exception
     * @throws IllegalArgumentException the illegal argument exception
     */
    public void deleteProcedureMaster(Long procedureId)throws ProcessingException,IllegalArgumentException {
        try{
            procedureMasterService.deleteProcedureMaster(procedureId);
        }catch(  IllegalArgumentException | ProcessingException e){
            throw e;
        }
    }

    /**
     * Gets the procedure values.
     *
     * @param procedureId the procedure id
     * @return the procedure values
     * @throws ProcessingException the processing exception
     */
    public TProcedureMaster getProcedureValues(Long procedureId)throws ProcessingException {
        try{
            return procedureMasterService.getProcedureValues(procedureId);
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    /**
     * Number of procedure records.
     *
     * @param expr the expr
     * @return the int
     * @throws ProcessingException the processing exception
     */
    public int numberOfProcedureRecords(String expr)throws ProcessingException {
        try{
            return procedureMasterService.numberOfProcedureRecords(expr);
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Gets the all procedure.
     *
     * @return the all procedure
     * @throws ProcessingException the processing exception
     */
    public Vector<TProcedureMaster> getAllProcedure()throws ProcessingException {
        try{
            Vector procedures = new Vector();
            List<TProcedureMaster> procedureList = procedureMasterService.getAllProcedureList();
            for(TProcedureMaster procedure:procedureList){
                TProcedureMaster tempprocedure = new TProcedureMaster();
                tempprocedure.setId(procedure.getId());
                tempprocedure.setProcedureName(procedure.getProcedureName());
                procedures.addElement(tempprocedure);
            }
            return procedures;
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    /**
     * Gets the procedure list by name.
     *
     * @param procedureName the procedure name
     * @return the procedure list by name
     * @throws ProcessingException the processing exception
     */
    public Vector<TProcedureMaster> getProcedureListBySearch(String expr) throws ProcessingException{
        try{
            Vector<TProcedureMaster> procedures = new Vector<TProcedureMaster>();
            List<TProcedureMaster> procedureList = procedureMasterService.getProcedureListBySearch(expr);
            for(TProcedureMaster procedure:procedureList){
                procedures.addElement(procedure);
            }
            return procedures;
        }catch(ProcessingException e){
            throw e;
        }
    }

    public List<TComponentMaster> getSelectedComponentByProcedure(TProcedureMaster procedureMaster)throws ProcessingException{
        try{
            return procedureComponentService.getSelectedComponentByProcedure(procedureMaster);
        }catch(ProcessingException e){
            throw e;
        }
    }
    public TProcedureMaster getProcedureByName(String procedureName) throws ProcessingException {
        try{
            return procedureMasterService.getProcedureByName(procedureName);
        }catch(ProcessingException e){
            throw e;
        }
    }
    
     public boolean isDuplicateProcedure(TProcedureMaster procedure)throws ProcessingException{
    
        try{
            return procedureMasterService.isDuplicateProcedure(procedure);
        }catch(ProcessingException e){
           throw e;
        }
    }
}