/*
This file is part of Cyclos (www.cyclos.org).
A project of the Social Trade Organisation (www.socialtrade.org).
Cyclos is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
Cyclos is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Cyclos; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package nl.strohalm.cyclos.utils.access;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import nl.strohalm.cyclos.entities.access.User;
import nl.strohalm.cyclos.entities.accounts.AccountOwner;
import nl.strohalm.cyclos.entities.accounts.pos.Pos;
import nl.strohalm.cyclos.entities.groups.AdminGroup;
import nl.strohalm.cyclos.entities.groups.BrokerGroup;
import nl.strohalm.cyclos.entities.groups.Group;
import nl.strohalm.cyclos.entities.groups.MemberGroup;
import nl.strohalm.cyclos.entities.groups.OperatorGroup;
import nl.strohalm.cyclos.entities.members.Element;
import nl.strohalm.cyclos.entities.members.Member;
import nl.strohalm.cyclos.entities.members.Operator;
import nl.strohalm.cyclos.entities.services.ServiceClient;
import nl.strohalm.cyclos.services.access.exceptions.NotConnectedException;
import org.apache.commons.collections.MapUtils;
/**
* Class that provides static access to the logged user, as well as custom attributes, using a ThreadLocal
* @author luis
*/
public class LoggedUser {
public static enum AccessType {
SYSTEM, USER, WEB_SERVICE
}
private static final String ACCESS_TYPE_KEY = "cyclos.loggedUser.accessType";
private static final String ELEMENT_KEY = "cyclos.loggedUser.element";
private static final String GROUP_KEY = "cyclos.loggedUser.group";
private static final String USER_KEY = "cyclos.loggedUser.user";
private static final String REMOTE_ADDRESS_KEY = "cyclos.loggedUser.remoteAddress";
private static final String SERVICE_CLIENT_KEY = "cyclos.loggedUser.serviceClient";
private static final String POS_KEY = "cyclos.loggedUser.pos";
private static final ThreadLocal<Map<String, Object>> ATTRIBUTES = new ThreadLocal<Map<String, Object>>();
/**
* Return the current account owner - system when an admin is logged, or the member
*/
public static AccountOwner accountOwner() {
final Element loggedElement = element();
return loggedElement.getAccountOwner();
}
/**
* Release resources. Should be called before the current thread dies
*/
public static void cleanup() {
final Map<String, Object> map = ATTRIBUTES.get();
if (map != null) {
map.clear();
}
ATTRIBUTES.remove();
}
/**
* Returns the logged element
*/
@SuppressWarnings("unchecked")
public static <E extends Element> E element() {
final Element element = getAttribute(ELEMENT_KEY);
if (element == null) {
throw new NotConnectedException();
}
return (E) element;
}
/**
* Returns the access type for the current execution
*/
public static AccessType getAccessType() {
return getAttribute(ACCESS_TYPE_KEY);
}
/**
* Returns the attribute for the given key
*/
@SuppressWarnings("unchecked")
public static <T> T getAttribute(final String key) {
final Map<String, Object> map = ATTRIBUTES.get();
if (map != null) {
return (T) map.get(key);
}
return null;
}
/**
* Returns all attributes. The returned map is just a defensive copy - changing it won't change the internal attributes
*/
public static Map<String, Object> getAttributes() {
final Map<String, Object> attributes = ATTRIBUTES.get();
if (attributes == null) {
return null;
}
// Return a defensive copy
return new HashMap<String, Object>(attributes);
}
/**
* Returns the logged user's group
*/
@SuppressWarnings("unchecked")
public static <G extends Group> G group() {
final Group group = getAttribute(GROUP_KEY);
if (group == null) {
throw new NotConnectedException();
}
return (G) group;
}
/**
* Returns whether there is an user in the current transaction
*/
public static boolean hasUser() {
return getAttribute(ELEMENT_KEY) != null;
}
/**
* Initializes. Should be called before any other methods on the current thread
*/
public static void init(final Map<String, Object> attributes) {
if (MapUtils.isNotEmpty(attributes)) {
ATTRIBUTES.set(attributes);
}
}
/**
* Initializes as a {@link Pos} web service
*/
public static void init(final Pos pos, final String remoteAddress, final Map<String, Object> attributes) {
final Member member = pos.getMemberPos().getMember();
final Map<String, Object> map = initMap(AccessType.WEB_SERVICE, member, remoteAddress, attributes);
map.put(POS_KEY, pos);
}
/**
* Initializes as a {@link ServiceClient} web service
*/
public static void init(final ServiceClient serviceClient, final String remoteAddress, final Map<String, Object> attributes) {
final Member member = serviceClient.getMember();
final Map<String, Object> map = initMap(AccessType.WEB_SERVICE, member, remoteAddress, attributes);
map.put(SERVICE_CLIENT_KEY, serviceClient);
}
/**
* Initializes. Should be called before any other methods on the current thread
*/
public static void init(final User user) {
init(user, null, null);
}
/**
* Initializes. Should be called before any other methods on the current thread
*/
public static void init(final User user, final String remoteAddress) {
init(user, remoteAddress, null);
}
/**
* Initializes. Should be called before any other methods on the current thread
*/
public static void init(final User user, final String remoteAddress, final Map<String, Object> attributes) {
initMap(AccessType.USER, user.getElement(), remoteAddress, attributes);
}
/**
* Returns if the logged user is an administrator
*/
public static boolean isAdministrator() {
return getAttribute(GROUP_KEY) instanceof AdminGroup;
}
/**
* Returns if the logged user is an broker. Note that a broker is also a member
*/
public static boolean isBroker() {
return getAttribute(GROUP_KEY) instanceof BrokerGroup;
}
/**
* Returns if the logged user is a member. Note that this is also true if the member is a broker
*/
public static boolean isMember() {
return getAttribute(GROUP_KEY) instanceof MemberGroup;
}
/**
* Return if the logged user is an operator
*/
public static boolean isOperator() {
return getAttribute(GROUP_KEY) instanceof OperatorGroup;
}
/**
* Returns whether the current context is of a system task
*/
public static boolean isSystem() {
return getAccessType() == AccessType.SYSTEM;
}
/**
* Returns whether the current context is either a system or an unrestricted service client (member is null)
*/
public static boolean isSystemOrUnrestrictedClient() {
return isSystem() || isUnrestrictedClient();
}
/**
* An unrestricted client is a (WS) client working as any member in the system.<br>
* But it only can do member's related tasks
* @return
*/
public static boolean isUnrestrictedClient() {
return isWebService() && ATTRIBUTES.get().get(SERVICE_CLIENT_KEY) != null && !hasUser();
}
/**
* Returns whether the current context is of a WS task
*/
public static boolean isWebService() {
return getAccessType() == AccessType.WEB_SERVICE;
}
/**
* Returns the member if the current user is either a member (returning himself) or an operator (returning his member). Otherwise, returns null.
*/
public static Member member() {
final Object element = getAttribute(ELEMENT_KEY);
if (element instanceof Member) {
return (Member) element;
} else if (element instanceof Operator) {
return ((Operator) element).getMember();
}
return null;
}
/**
* Returns the POS if the current transaction was started by a POS access, null otherwise
*/
public static Pos pos() {
return getAttribute(POS_KEY);
}
/**
* Returns the remote address of the logged user
*/
public static String remoteAddress() {
return getAttribute(REMOTE_ADDRESS_KEY);
}
public static <T> T runAs(final User user, final Callable<T> callable) {
return runAs(user, null, callable);
}
public static <T> T runAs(final User user, final String remoteAddress, final Callable<T> callable) {
final Map<String, Object> previousAttributes = ATTRIBUTES.get();
try {
init(user, remoteAddress);
return callable.call();
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new RuntimeException(e);
} finally {
ATTRIBUTES.set(previousAttributes);
}
}
public static <T> T runAsSystem(final Callable<T> callable) {
Map<String, Object> previousAttributes = null;
final boolean alreadyRunninAsSystem = isSystem();
if (!alreadyRunninAsSystem) {
previousAttributes = ATTRIBUTES.get();
}
try {
if (!alreadyRunninAsSystem) {
initAsSystem();
}
return callable.call();
} catch (final RuntimeException e) {
throw e;
} catch (final Exception e) {
throw new RuntimeException(e);
} finally {
if (!alreadyRunninAsSystem) {
ATTRIBUTES.set(previousAttributes);
}
}
}
/**
* Returns the service client if the current transaction was started by a web service access, null otherwise
*/
public static ServiceClient serviceClient() {
return getAttribute(SERVICE_CLIENT_KEY);
}
/**
* Sets an attribute for the given key
*/
public static void setAttribute(final String key, final Object value) {
final Map<String, Object> map = ATTRIBUTES.get();
if (map != null) {
map.put(key, value);
}
}
/**
* Returns the logged user
*/
@SuppressWarnings("unchecked")
public static <U extends User> U user() {
final User user = getAttribute(USER_KEY);
if (user == null) {
throw new NotConnectedException();
}
return (U) user;
}
/**
* Sets the current access as system
*/
private static void initAsSystem() {
initMap(AccessType.SYSTEM, null, null, null);
}
private static Map<String, Object> initMap(final AccessType accessType, final Element element, final String remoteAddress, final Map<String, Object> attributes) {
final Map<String, Object> map = new HashMap<String, Object>();
map.put(ACCESS_TYPE_KEY, accessType);
if (element != null) {
map.put(ELEMENT_KEY, element);
map.put(USER_KEY, element.getUser());
map.put(GROUP_KEY, element.getGroup());
}
map.put(REMOTE_ADDRESS_KEY, remoteAddress);
if (attributes != null) {
map.putAll(attributes);
}
ATTRIBUTES.set(map);
return map;
}
}