/*
 * 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.vo.TAccDeptRole;
import com.bestray.healthcarecommonutil.vo.TAccount;
import com.bestray.healthcarecommonutil.vo.TAccountDepartment;
import com.bestray.healthcarecommonutil.vo.TAccountRole;
import com.bestray.healthcarecommonutil.vo.TDepartmentMaster;
import com.bestray.healthcarecommonutil.vo.TDoctorInformation;
import com.bestray.healthcarecommonutil.vo.TPermission;
import com.bestray.healthcarecommonutil.vo.TRole;
import com.bestray.healthcarecommonutil.vo.TRolePermission;
import com.bestray.healthcareemr.Service.UserAccountDeptRoleService;
import com.bestray.healthcareemr.Service.UserAccountDeptService;
import com.bestray.healthcareemr.Service.UserAccountRoleService;
import com.bestray.healthcareemr.Service.UserPermissionService;
import com.bestray.healthcareemr.Service.UserRolePermissionService;
import com.bestray.healthcareemr.Service.UserRoleService;
import com.bestray.healthcareemr.Service.UserSetupService;
import java.util.List;
import java.util.Vector;
import javax.swing.DefaultListModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.HibernateOptimisticLockingFailureException;
import org.springframework.stereotype.Controller;

// TODO: Auto-generated Javadoc
/**
 * The Class UserSetupController.
 *
 * @author user3
 */
@Controller
public class UserSetupController {
    
    /** The user setup service. */
    @Autowired
    private UserSetupService userSetupService;
    @Autowired
    private UserAccountRoleService userAccountRoleService;
    @Autowired
    private UserAccountDeptService userAccountDeptService;
    @Autowired
    private UserRolePermissionService userRolePermissionService;
    @Autowired
    private UserRoleService userRoleService;
    @Autowired
    private UserPermissionService userPermissionService;
    @Autowired
    private UserAccountDeptRoleService userAccountDeptRoleService;

   
    /*public UserSetupController(UserSetupService userSetupService, UserAccountRoleService userAccountRoleService, 
            UserAccountDeptService userAccountDeptService, UserRolePermissionService userRolePermissionService,
            UserRoleService userRoleService,UserPermissionService userPermissionService) {
        this.userSetupService = userSetupService;
        this.userAccountRoleService = userAccountRoleService;
        this.userAccountDeptService = userAccountDeptService;
        this.userRolePermissionService = userRolePermissionService;
        this.userRoleService = userRoleService;
        this.userPermissionService = userPermissionService;
    }*/

    /**
     * Instantiates a new user setup controller.
     *
     * @param userSetupService the user setup service
     */
    
        
    /**
     * Save permission.
     *
     * @param permission the permission
     * @return true, if successful
     * @throws ProcessingException the processing exception
     */
    public boolean savePermission(TPermission permission)throws ProcessingException {
        try{
            return userPermissionService.savePermission(permission);
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Gets the permission list.
     *
     * @return the permission list
     * @throws ProcessingException the processing exception
     */
    public Vector<TPermission> getPermissionList()throws ProcessingException {
        try{
            Vector<TPermission> permissions = new Vector<TPermission>();
            List<TPermission> permissionList = userPermissionService.getPermissionList();
            for(TPermission perm:permissionList){
                permissions.addElement(perm);
            }
            return permissions;
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Save role with permission.
     *
     * @param role the role
     * @param permissionList the permission list
     * @throws ProcessingException the processing exception
     */
    public void saveRoleWithPermission(TRole role, List<TPermission> permissionList)throws ProcessingException,IllegalArgumentException,HibernateOptimisticLockingFailureException  {
        try{
            userRolePermissionService.saveRoleWithPermission(role,permissionList);
        }catch(ProcessingException | HibernateOptimisticLockingFailureException | IllegalArgumentException e){
            throw e;
        }
    }

    /**
     * Gets the role list.
     *
     * @return the role list
     * @throws ProcessingException the processing exception
     */
    public Vector<TRole> getRoleList()throws ProcessingException {
        try{
            Vector<TRole> roles = new Vector<TRole>();
            List<TRole> roleList = userRoleService.getRoleList();
            for(TRole role:roleList){
                roles.addElement(role);
            }
            return roles;
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Save account with role.
     *
     * @param account the account
     * @param rolelist the rolelist
     * @param deptList the dept list
     * @throws ProcessingException the processing exception
     */
    /*public void saveAccountWithRole(TAccount account, List<TRole> rolelist, List<TDepartmentMaster> deptList)throws ProcessingException {
        try{
            userAccountRoleService.saveAccountWithRole(account,rolelist,deptList);
        }catch(ProcessingException e){
            throw e;
        }
    }*/

    /**
     * Gets the permission by name.
     *
     * @param permissionName the permission name
     * @return the permission by name
     * @throws ProcessingException the processing exception
     */
    public TPermission getPermissionByName(String permissionName)throws ProcessingException {
        try{
            return  userPermissionService.getPermissionByName(permissionName);
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Gets the all role into table.
     *
     * @return the all role into table
     * @throws ProcessingException the processing exception
     */
    public Vector<Vector<String>> getAllRoleIntoTable()throws ProcessingException {
        try{
            return userRoleService.getAllRoleIntoTable();
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Gets the permission list by role.
     *
     * @param role the role
     * @return the permission list by role
     * @throws ProcessingException the processing exception
     */
    public List<TPermission> getPermissionListByRole(TRole role)throws ProcessingException {
        try{
            return userPermissionService.getPermissionListByRole(role);
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Gets the role by role id.
     *
     * @param roleid the roleid
     * @return the role by role id
     * @throws ProcessingException the processing exception
     */
    public TRole getRoleByRoleId(Long roleid)throws ProcessingException {
        try{
            return userRoleService.getRoleByRoleId(roleid);
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Gets the department list.
     *
     * @return the department list
     * @throws ProcessingException the processing exception
     */
    public Vector<TDepartmentMaster> getDepartmentList()throws ProcessingException {
        try{
            Vector<TDepartmentMaster> departments = new Vector<TDepartmentMaster>();
            List<TDepartmentMaster> departmentList = userSetupService.getDepartmentList();
            for(TDepartmentMaster department:departmentList){
                departments.addElement(department);
            }
            return departments;
        }catch(ProcessingException e){
            throw e;
        }
    }

    /**
     * Update user password.
     *
     * @param newUserAccount the new user account
     * @throws ProcessingException the processing exception
     */
    public void updateUserPassword(TAccount newUserAccount)throws ProcessingException {
        try{
            userSetupService.updateUserPassword(newUserAccount);
        }catch(ProcessingException | HibernateOptimisticLockingFailureException e){
            throw e;
        }
    }

    /**
     * Gets the doc info from doc id.
     *
     * @param docid the docid
     * @return the doc info from doc id
     * @throws ProcessingException the processing exception
     */
    public TDoctorInformation getDocInfoFromDocId(String docid)throws ProcessingException {
        try{
            return userSetupService.getDocInfoFromDocId(docid);
        }catch(ProcessingException e){
            throw e;
        }
        
    }

    /**
     * Number of user account records.
     *
     * @param expr the expr
     * @return the int
     * @throws ProcessingException the processing exception
     */
    public int numberOfUserAccountRecords(String expr)throws ProcessingException {
        try{
            return userSetupService.numberOfUserAccountRecords(expr);
        }catch(ProcessingException e){
            throw e;
        }
    }

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

    /**
     * Gets the user account values.
     *
     * @param ID the id
     * @return the user account values
     * @throws ProcessingException the processing exception
     */
    public TAccount getUserAccountValues(Integer ID)throws ProcessingException {
        try{
            return userSetupService.getUserAccountValues(ID);
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public List<TRole> getRolesByName(String name)throws ProcessingException{
        try{
            return userRoleService.getRolesByName(name);
        }catch(ProcessingException e){
            throw e;
        }
    }
    
    public List<TPermission> getAllPermissions()throws ProcessingException{
        try{
            return userPermissionService.getPermissionList();
        }catch(ProcessingException e){
            throw e;
        }
    }

    public void addRole(TRole newrole)throws ProcessingException {
        try{
           userRoleService.addRole(newrole);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public void saveRoleWithPermission(TRolePermission newrolepermission)throws ProcessingException {
        try{
           userRolePermissionService.saveRoleWithPermission(newrolepermission);
        }catch(ProcessingException e){
            throw e;
        }
    }
    
     public void saveRolePermissions(List<TRolePermission> rolePermissions) throws ProcessingException,IllegalArgumentException {
         try{
             userRolePermissionService.saveRolePermissions(rolePermissions);
        }catch(ProcessingException | IllegalArgumentException e){
            throw e;
        }
     }

    public void deletePermissionFromRole(TRolePermission getrolepermission) throws ProcessingException,IllegalArgumentException{
        try{
           userRolePermissionService.deletePermissionFromRole(getrolepermission);
        }catch(ProcessingException | IllegalArgumentException e){
            throw e;
        }
    }

    public TRolePermission getRolePermission(TRole role, TPermission selectedpermission)throws ProcessingException {
        try{
           return userRolePermissionService.getRolePermission(role,selectedpermission);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public List<TAccountDepartment> getDepartmentByAccount(TAccount account)throws ProcessingException {
        try{
           return userAccountDeptService.getDepartmentByAccount(account);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public void deleteDepartmentAssignedAcc(List<TAccountDepartment> accountDepartment)throws ProcessingException,IllegalArgumentException{
        try{
            userAccountDeptService.deleteDepartmentAssignedAcc(accountDepartment);
        }catch(ProcessingException | IllegalArgumentException e){
            throw e;
        }
    }

    public List<TAccountRole> getRoleByAccount(TAccount account)throws ProcessingException {
        try{
           return userAccountRoleService.getRoleByAccount(account);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public void deleteRoleAssignedAcc(List<TAccountRole> accountRole)throws ProcessingException,IllegalArgumentException {
        try{
            userAccountRoleService.deleteRoleAssignedAcc(accountRole);
        }catch(ProcessingException | IllegalArgumentException e){
            throw e;
        }
    }

    public void deleteAccount(TAccount account)throws ProcessingException,IllegalArgumentException {
        try{
            userSetupService.deleteAccount(account);
        }catch(ProcessingException | IllegalArgumentException e){
            throw e;
        }
    }

    public void saveAccountWithDept(TAccount account, DefaultListModel deptdestmodel)throws IllegalArgumentException,HibernateOptimisticLockingFailureException,ProcessingException {
        try{
            userAccountRoleService.saveAccountWithDept(account,deptdestmodel);
        }catch(ProcessingException | IllegalArgumentException | HibernateOptimisticLockingFailureException e){
            throw e;
        }
    }

    public List<TRolePermission> getRolePermission(TRole roleId) throws ProcessingException {
        try{
           return userRolePermissionService.getRolePermission(roleId);
        }catch(ProcessingException e){
            throw e;
        }
    }

    public void deleteRoleAssignedToDept(List<TAccDeptRole> accDeptRole)throws ProcessingException,IllegalArgumentException {
         try{
            userAccountDeptRoleService.deleteRoleAssignedToDept(accDeptRole);
        }catch(ProcessingException e){
            throw e;
        }catch(IllegalArgumentException e){
            throw e;
        }
    }
    
}