LiferayBridge.java

package org.aperteworkflow.util.liferay;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.aperteworkflow.util.liferay.exceptions.RoleNotFoundException;

import pl.net.bluesoft.rnd.processtool.model.UserAttribute;
import pl.net.bluesoft.rnd.processtool.model.UserData;
import pl.net.bluesoft.util.lang.Collections;
import pl.net.bluesoft.util.lang.Predicate;

import com.liferay.portal.NoSuchRoleException;
import com.liferay.portal.NoSuchUserException;
import com.liferay.portal.kernel.exception.PortalException;
import com.liferay.portal.kernel.exception.SystemException;
import com.liferay.portal.model.Group;
import com.liferay.portal.model.Role;
import com.liferay.portal.model.RoleConstants;
import com.liferay.portal.model.User;
import com.liferay.portal.model.UserGroup;
import com.liferay.portal.service.GroupLocalServiceUtil;
import com.liferay.portal.service.RoleLocalServiceUtil;
import com.liferay.portal.service.UserLocalServiceUtil;
import com.liferay.portal.util.PortalUtil;

/**
 * Facade for all Liferay operations
 *
 * @author tlipski@bluesoft.net.pl, mpawlak@bluesoft.net.pl
 */
public class LiferayBridge {
    private static final Logger logger = Logger.getLogger(LiferayBridge.class.getName());

    public static class LiferayBridgeException extends RuntimeException {
        public LiferayBridgeException() {
        }
        public LiferayBridgeException(String message) {
            super(message);
        }
        public LiferayBridgeException(String message, Throwable cause) {
            super(message, cause);
        }
        public LiferayBridgeException(Throwable cause) {
            super(cause);
        }
    }

    public static UserData convertLiferayUser(User user) throws SystemException {
        if (user == null) {
            return null;
        }
        UserData ud = new UserData();
        ud.setEmail(user.getEmailAddress());
        ud.setLogin(user.getScreenName());
        ud.setFirstName(user.getFirstName());
        ud.setLastName(user.getLastName());
        ud.setJobTitle(user.getJobTitle());
        ud.setCompanyId(user.getCompanyId());
        ud.setLiferayUserId(user.getUserId());
        for (Role role : user.getRoles()) 
        {
            ud.addRoleName(role.getName(), role.getDescription());
        }
        setGroupRoles(ud, user);
        return ud;
    }
    
    private static void setGroupRoles(UserData ud, User user) {
        try {
            for (UserGroup userGroup : user.getUserGroups()) {
                List<Role> roles = RoleLocalServiceUtil.getGroupRoles(userGroup.getGroup().getGroupId());
                for (Role role : roles) {
                    ud.addRoleName(role.getName());
                }
            }
        }
        catch (Exception e) {
            throw new LiferayBridgeException(e);
        }
    }

    public static UserData getLiferayUser(String login, Long companyId) {
        try {
            User user = UserLocalServiceUtil.getUserByScreenName(companyId, login);
            return convertLiferayUser(user);
        }
        catch (Exception e) {
            throw new LiferayBridgeException(e);
        }
    }

    public static UserData getLiferayUser(final String login) {
        if (login == null) {
            return null;
        }
        try {
            long[] companyIds = PortalUtil.getCompanyIds();
            for (int i = 0; i < companyIds.length; ++i) {
                long ci = companyIds[i];
                try {
                    User u = UserLocalServiceUtil.getUserByScreenName(ci, login);
                    if (u != null) {
                        return convertLiferayUser(u);
                    }
                }
                catch (NoSuchUserException e) {
                    // continue
                }
            }
            return null;
        }
        catch (Exception e) {
            throw new LiferayBridgeException(e);
        }
    }

    public static UserData getLiferayUserByEmail(String email, Long companyId) {
        try {
            User user = UserLocalServiceUtil.getUserByEmailAddress(companyId, email);
            return convertLiferayUser(user);
        }
        catch (Exception e) {
            throw new LiferayBridgeException(e);
        }
    }

    public static UserData getLiferayUserByAttributeNoException(final UserAttribute attribute, Long companyId) {
        try {
            return getLiferayUserByAttribute(attribute, companyId);
        }
        catch (Exception e) {
            return null;
        }
    }

    public static UserData getLiferayUserByAttribute(final UserAttribute attribute, Long companyId) {
        try {
            return Collections.firstMatching(getUsersByCompanyId(companyId), new Predicate<UserData>() {
                @Override
                public boolean apply(UserData input) {
                    UserAttribute userAttribute = input.findAttribute(attribute.getKey());
                    return userAttribute != null && userAttribute.getValue().equals(attribute.getValue());
                }
            });
        }
        catch (Exception e) {
            throw new LiferayBridgeException(e);
        }
    }

	public static UserData getLiferayUserByEmailNoException(String email, Long companyId) {
        try {
            User user = UserLocalServiceUtil.getUserByEmailAddress(companyId, email);
            return convertLiferayUser(user);
        }
        catch (Exception e) {
            return null;
        }
    }

    public static List<UserData> getAllUsersByCurrentUser(UserData currentUser) {
        try {
            if (currentUser == null) {
                return new ArrayList<UserData>(0);
            }
            return convertLiferayUsers(UserLocalServiceUtil.getCompanyUsers(currentUser.getCompanyId(), 0, Integer.MAX_VALUE));
        }
        catch (SystemException e) {
            throw new LiferayBridgeException(e);
        }
    }

    public static List<UserData> getUsersByCompanyId(Long companyId) {
        try {
            if (companyId == null) {
                return new ArrayList<UserData>(0);
            }
            return convertLiferayUsers(UserLocalServiceUtil.getCompanyUsers(companyId, 0, Integer.MAX_VALUE));
        }
        catch (SystemException e) {
            throw new LiferayBridgeException(e);
        }
    }

    public static List<UserData> getAllUsers() {
        try {
            return convertLiferayUsers(UserLocalServiceUtil.getUsers(0, UserLocalServiceUtil.getUsersCount()));
        }
        catch (SystemException e) {
            throw new LiferayBridgeException(e);
        }
    }

    public static List<UserData> getLiferayUsers(final Collection<String> logins) {
        List<UserData> result = new LinkedList<UserData>();
        if (logins != null && !logins.isEmpty()) {
            for (String login : logins) {
                UserData user = getLiferayUser(login);
                if (user != null) {
                    result.add(user);
                }
            }
        }
        return result;
    }

    private static List<UserData> convertLiferayUsers(List<User> liferayUsers) throws SystemException {
        List<UserData> users = new ArrayList<UserData>(liferayUsers.size());
        for (User liferayUser : liferayUsers) {
            users.add(convertLiferayUser(liferayUser));
        }
        return users;
    }

    /** Get all users with given role name. The role must be assigned directly to user
     * or to user group which contains users
     */
    public static List<UserData> getUsersByRole(String roleName) 
    {
        try 
        {
        	/* Search for role with given name */
        	Role role = getRoleByName(roleName);
        	
        	List<User> liferayUsers = new ArrayList<User>();
        	
        	/* Get users with directly assigned role */
        	liferayUsers.addAll(UserLocalServiceUtil.getRoleUsers(role.getRoleId()));
        	
        	/* Get user groups with assigned role */
        	List<Group> liferayGroups = GroupLocalServiceUtil.getRoleGroups(role.getRoleId());
        	
	
        	for(Group liferayGroup: liferayGroups)
        	{    		
        		/* Get all users from selected group. ClassPK is the id of the UserGroup instance
        		 * Group is something diffrent then UserGroup and there are no users in Group */
        		List<User> groupUsers = UserLocalServiceUtil.getUserGroupUsers(liferayGroup.getClassPK());
        		
        		/* If there is no user from group in liferay users list yet, add him */
        		for(User groupLiferayUser: groupUsers)
        			if(!liferayUsers.contains(groupLiferayUser))
        				liferayUsers.add(groupLiferayUser);
        	}
        	
        	
        	List<UserData> userDatas = new ArrayList<UserData>();
        	
        	/* Map all liferay users to aperte users */
        	for(User liferayUser: liferayUsers)
        		userDatas.add(convertLiferayUser(liferayUser));
        	
        	
        	return userDatas;
        }
        catch (SystemException e) 
        {
            throw new LiferayBridgeException(e);
        } 
        catch (RoleNotFoundException ex) 
        {
        	throw new LiferayBridgeException(ex);
		} 
    }
    
    /** Find Liferay role by given name. The role is searched in all company ids */
    public static Role getRoleByName(String roleName) throws RoleNotFoundException
    {
    	try
    	{
    		/* Search for role in all companies. There is commonly only one company in system */
	        long[] companyIds = PortalUtil.getCompanyIds();
	        for (int i = 0; i < companyIds.length; ++i) 
	        {
	        	long companyId = companyIds[i];
	        	Role role = RoleLocalServiceUtil.getRole(companyId, roleName);
	        	
	        	if(role != null)
	        		return role;
	        }
	        
	        /* No role with given name found, throw exception */
	        throw new RoleNotFoundException("No role found with given name: "+roleName);
    	}
    	catch(NoSuchRoleException ex)
    	{
    		throw new RoleNotFoundException("No role found with given name: "+roleName);
    	}
    	catch (PortalException e) 
    	{
    		throw new RoleNotFoundException("Error during role ["+roleName+"]", e);
		} 
    	catch (SystemException e) 
    	{
    		throw new RoleNotFoundException("Error during role ["+roleName+"]", e);
		}
    }
    
    public static boolean createRoleIfNotExists(String roleName, String description) 
    {
    	try 
    	{
    		/* Look for the role with provided name */
        	Role role = null;
        	try
        	{
        		/* Look for the role with provided name */
        		role = getRoleByName(roleName);
        	}
        	catch(RoleNotFoundException ex)
        	{
				Map<Locale, String> titles = new HashMap<Locale,  String>();
				RoleLocalServiceUtil.addRole(0, PortalUtil.getDefaultCompanyId(), roleName, titles, description, RoleConstants.TYPE_REGULAR);
				return true;
        	}

			/* Role found, maybe there is need to update description */
			if(description != null && !description.equals(role.getDescription()))
			{
				role.setDescription(description);
				RoleLocalServiceUtil.updateRole(role);
			}
			return false;
		}
		catch (Exception e) 
		{
			throw new LiferayBridgeException(e);
		}
    }

	public static List<String> getRoleNames(long companyId) {
		List<String> roleNames = new ArrayList<String>();
		try {
			List<Role> roles = RoleLocalServiceUtil.getRoles(companyId);
			for (Role r : roles) {
				roleNames.add(r.getName());
			}
		} catch (SystemException e) {
			logger.log(Level.SEVERE, "Error getting liferay roles", e);
		}
		return roleNames;
	}

	public static List<String> getRegularRoleNames() {
		List<String> roleNames = new ArrayList<String>();
		try {
			List<Role> roles = RoleLocalServiceUtil.getRoles(PortalUtil.getDefaultCompanyId());
			for (Role r : roles) {
				if (r.getType() == RoleConstants.TYPE_REGULAR) {
					roleNames.add(r.getName());
				}
			}
		}
		catch (SystemException e) {
			logger.log(Level.SEVERE, e.getMessage(), e);
		}
		return roleNames;
	}
}