Subversion Repositories SmartDukaan

package in.shop2020.content.security;

import in.shop2020.metamodel.core.EntityState;
import in.shop2020.metamodel.core.EntityStatus;
import in.shop2020.storage.bdb.StorageManager;
import in.shop2020.util.Utils;

import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;


/**
 * Singleton class for managing users.
 * 
 * @author rajveer
 *
 */
public class UserManager {
        
        private static UserManager userManager;
        private Map<String, User> users;
        private String admin = "admin";
        static{
                synchronized(UserManager.class){
                        userManager = new UserManager();
                }
        }
        
        private UserManager(){
                //TODO Load initial list of users
                users = new HashMap<String, User>();
                this.loadUsers();
//              System.out.println(users);
//              users.put("vrinda", new User("vrinda", "vrinda", Role.EDITOR));
//              users.put("smriti", new User("smriti", "smriti", Role.DEVELOPER));
//              users.put("priyanka", new User("priyanka", "priyanka", Role.DEVELOPER));
//              users.put("rajveer", new User("rajveer", "rajveer", Role.ADMIN));
                
        }
        
        public static void main(String[] args){
                System.out.println(UserManager.getUserManager().getAllUsers());
        }
        
        /**
         * Read the xml file and populate current users with their roles.
         */
        private void loadUsers() {
               String xmlFile = Utils.CONTENT_DB_PATH + "definitions" + File.separator + "users.xml";
               File file = new File(xmlFile);
               if(file.exists()){
                   try{
                                 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
                             DocumentBuilder builder = factory.newDocumentBuilder();
                             Document doc = builder.parse(xmlFile);
                             NodeList list = doc.getElementsByTagName("User");
                             for(int i=0; i<list.getLength(); i++) {
                               Element element = (Element)list.item(i);
                               String name = element.getElementsByTagName("Username").item(0).getTextContent();
                               String password = element.getElementsByTagName("Password").item(0).getTextContent();
                                        int roleId = Integer.parseInt(element.getElementsByTagName("Role").item(0).getTextContent());
                                        
                                        Role role = Role.DEVELOPER;
                                        switch (roleId) {
                                        case 0:
                                                role = Role.DEVELOPER;
                                                break;

                                        case 1:
                                                role = Role.EDITOR;
                                                break;

                                        case 2:
                                                role = Role.ADMIN;
                                                admin = name;
                                                break;

                                        default:
                                                break;
                                        }
                                        User user = new User(name, password, role);
                                        users.put(name, user);
                                        System.out.println(name +password + role);
                                        
                             }
                   }catch(Exception ex){
                           
                   }
               }
        }
        
        /**
         * Method no more used.
         */
        private void loadUsers1(){
                InputSource inputSource = new InputSource(Utils.CONTENT_DB_PATH + "definitions" + File.separator + "users.xml");
                XPath xpath = XPathFactory.newInstance().newXPath();
                
                String expression = "/Definition";
                NodeList nodes = null;
                try {
                        nodes = (NodeList) xpath.evaluate(expression, inputSource,      XPathConstants.NODESET);
                } catch(XPathExpressionException xpee) {
                        
                }

                System.out.println(nodes);
                
                for(int i=nodes.getLength()-1; i>=0; i--) {
                        System.out.println(nodes.item(i));
                        
                        System.out.println(nodes.getLength());
                        
                        Element userInfo = (Element) nodes.item(i);
                        
                        String name = userInfo.getElementsByTagName("Username").item(0).getTextContent();
                        String password = userInfo.getElementsByTagName("Password").item(0).getTextContent();
                        int roleId = Integer.parseInt(userInfo.getElementsByTagName("role").item(0).getTextContent());
                        Role role = Role.DEVELOPER;
                        
                        switch (roleId) {
                        case 0:
                                role = Role.DEVELOPER;
                                break;

                        case 1:
                                role = Role.EDITOR;
                                break;

                        case 2:
                                role = Role.ADMIN;
                                break;

                        default:
                                break;
                        }
                        User user = new User(name, password, role);
                        users.put(name, user);
                }
                
        }
        
        /**
         * 
         * @return Singleton instance of user manager
         */
        public static UserManager getUserManager(){
                return userManager;
        }
        
        /**
         * 
         * @return All users with roles.
         */
        public Collection<User> getAllUsers(){
                Collection<User> allUsers = users.values();
                return allUsers;
        }

        
        /**
         * 
         * @return Names of all users.
         */
        public Set<String> getAllUserNames(){
                Set<String> allUsers = users.keySet();
                return allUsers;
        }

        /**
         * 
         * @return Name of the admin.
         */
        public String getAdminName(){
                return this.admin;
        }
        
        /**
         * 
         * @param role
         * @return all users for a particular role
         */
        public List<User> getAllUsersForRole(Role role){
                Collection<User> allUsers = users.values();
                List<User> usersForRole = new ArrayList<User>();
                for(User user: allUsers){
                        if(user.getRole() == role){
                                usersForRole.add(user);
                        }
                }
                return usersForRole;
        }
        
        
        /**
         * Create a new user.
         * @param username
         * @param password
         * @param role
         * @return false if user already exists else true 
         */
        public boolean createUser(String username, String password, Role role){
                User user = new User(username, password, role);
                if(users.containsKey(username)){
                        return false;
                }
                users.put(username, user);
                return true;
        }
        
        /**
         * Authenticate user
         * @param username
         * @param password
         * @return true if user is authenticated else false
         */
        public boolean authenticateUser(String username, String password){
                User user = users.get(username);
                if(user != null && user.getPassword().equals(password)){
                        return true;    
                }
                return false;
        }

        /**
         * Get user for given username
         * @param username
         * @return User
         */
        public User getUser(String username){
                return users.get(username);
        }

        /**
         * 
         * @param username
         * @return Role
         */
        public Role getUserRole(String username){
                return users.get(username).getRole();
        }

        /**
         * Checks weather user have permission to view the entity?
         * 
         * @param username
         * @param entityId
         * @return
         */
        public boolean canView(String username, long entityId){
                return RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.VIEW);
        }
        
        /**
         * 
         * @param username
         * @param entityId
         * @return
         */
        public boolean canDelete(String username, long entityId){
                if(RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.DELETE)){
                        EntityState state = StorageManager.getStorageManager().getEntityMetadata(entityId);
                        if(state.getStatus() != EntityStatus.READY){
                                return true;
                        }
                }
                return false;
        }
        
        /**
         * 
         * @param username
         * @param entityId
         * @return
         */
        public boolean canEdit(String username, long entityId){
                if(RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.EDIT)){
                        EntityState state = StorageManager.getStorageManager().getEntityMetadata(entityId);
                        if(state.getStatus() ==  EntityStatus.ASSIGNED &&  state.getAssignedTo().equalsIgnoreCase(username)){
                                return true;
                        }
                }
                return false;
        }
        
        /**
         * 
         * @param username
         * @param entityId
         * @return
         */
        public boolean canAssign(String username, long entityId){
                if(RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.ASSIGN)){
                    return true;
                    /* Now content editor will be able to change status from ready to non ready
                        EntityState state = StorageManager.getStorageManager().getEntityMetadata(entityId);
                        if(state.getStatus() !=  EntityStatus.READY){
                                return true;
                        }
                        else{
                                if(userManager.getUserRole(username) == Role.ADMIN){
                                        return true;
                                }
                        }
                        */
                }
                return false;
        }
        
        /**
         * 
         * @param username
         * @param entityId
         * @return
         */
        public boolean canComplete(String username, long entityId){
                if(RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.COMPLETE)){
                        EntityState state = StorageManager.getStorageManager().getEntityMetadata(entityId);
                        if(state.getStatus() == EntityStatus.ASSIGNED && state.getAssignedTo().equalsIgnoreCase(username)){
                                return true;
                        }
                }
                return false;
        }
        
        /**
         * 
         * @param username
         * @return
         */
        public boolean canCreate(String username){
                return RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.CREATE);
        }
        
        /**
         * 
         * @param username
         * @param entityId
         * @return
         */
        public boolean canMarkReady(String username, long entityId){
                if(RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.READY)){
                EntityState state = StorageManager.getStorageManager().getEntityMetadata(entityId);
                        if(state.getStatus() ==  EntityStatus.COMPLETE){
                                return true;
                        }
                }
                return false;
        }
        
        /*
        public boolean canView(String username, long entityId){
                return RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.VIEW);
        }
        
        public boolean canEdit(String username, long entityId){
                if(RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.EDIT)){
                        EntityState state = StorageManager.getStorageManager().getEntityMetadata(entityId);
                        if(state.getStatus() ==  EntityStatus.)
                }
                return false;
        }
        
        public boolean canDelete(String username, long entityId){
                return RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.DELETE);
        }
        
        public boolean canAssign(String username, long entityId){
                return RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.ASSIGN);
        }
        public boolean canComplete(String username, long entityId){
                return RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.COMPLETE);
        }
        public boolean canMarkReady(String username, long entityId){
                return RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.READY);
        }
        public boolean canCreate(String username, long entityId){
                return RoleManager.getRoleManager().hasPermission(userManager.getUserRole(username), Action.CREATE);
        }
*/
}