36476868921

Committed 28 Sep 2026 08:06PM UTC coverage: 66.046% (-0.06%) from 66.105%

Build # 36476868921

Build Type

push

github

Committed by

ibacher

Commit Message

Test improvements: in-memory search index and speed-up metadata reads

Coverage Stats

25524 of 38646 relevant lines covered (66.05%)

0.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.23

/api/src/main/java/org/openmrs/api/context/UserContext.java

/**
 * This Source Code Form is subject to the terms of the Mozilla Public License,
 * v. 2.0. If a copy of the MPL was not distributed with this file, You can
 * obtain one at http://mozilla.org/MPL/2.0/. OpenMRS is also distributed under
 * the terms of the Healthcare Disclaimer located at http://openmrs.org/license.
 *
 * Copyright (C) OpenMRS Inc. OpenMRS is a registered trademark and the OpenMRS
 * graphic logo is a trademark of OpenMRS Inc.
 */
package org.openmrs.api.context;

import org.apache.commons.lang3.StringUtils;
import org.openmrs.Location;
import org.openmrs.PrivilegeListener;
import org.openmrs.Role;
import org.openmrs.User;
import org.openmrs.UserSessionListener;
import org.openmrs.UserSessionListener.Event;
import org.openmrs.UserSessionListener.Status;
import org.openmrs.api.APIAuthenticationException;
import org.openmrs.api.LocationService;
import org.openmrs.api.cache.RolePrivilegeCache;
import org.openmrs.api.cache.RolePrivileges;
import org.openmrs.util.LocaleUtility;
import org.openmrs.util.OpenmrsConstants;
import org.openmrs.util.RoleConstants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * Represents an OpenMRS <code>User Context</code> which stores the current user information. Only
 * one <code>User</code> may be authenticated within a UserContext at any given time. The
 * UserContext should not be accessed directly, but rather used through the <code>Context</code>.
 * This class should be kept light-weight. There is one instance of this class per user that is
 * logged into the system.
 *
 * @see org.openmrs.api.context.Context
 */
public class UserContext implements Serializable {
        
        private static final long serialVersionUID = -806631231941890648L;
        
        /**
         * Logger - shared by entire class
         */
        private static final Logger log = LoggerFactory.getLogger(UserContext.class);
        
        /**
         * Guards the one-time warning emitted when the role privilege cache component cannot be obtained
         * outside of a context refresh. Static so the warning is emitted once across all user contexts
         * rather than once per session.
         */
        private static final AtomicBoolean rolePrivilegeCacheUnavailableWarned = new AtomicBoolean(false);

        /**
         * User object containing details about the authenticated user
         */
        private User user = null;
        
        /**
         * User's permission proxies
         */
        private final List<String> proxies = Collections.synchronizedList(new ArrayList<>());
        
        /**
         * User's locale
         */
        private Locale locale = null;
        
        /**
         * Cached Role given to all authenticated users
         */
        private Role authenticatedRole = null;
        
        /**
         * Cache Role given to all users
         */
        private Role anonymousRole = null;
        
        /**
         * User's defined location
         */
        private Integer locationId;
        
        /**
         * The authentication scheme for this user
         */
        private final AuthenticationScheme authenticationScheme;
        
        /**
         * Creates a user context based on the provided auth. scheme.
         *
         * @param authenticationScheme The auth. scheme that applies for this user context.
         * @since 2.3.0
         */
        public UserContext(AuthenticationScheme authenticationScheme) {
                this.authenticationScheme = authenticationScheme;
        }
        
        /**
         * Authenticate user with the provided credentials. The authentication scheme must be Spring wired, see {@link Context#getAuthenticationScheme()}.
         *
         * @param credentials The credentials to use to authenticate
         * @return The authenticated client information
         * @throws ContextAuthenticationException if authentication fails
         * @since 2.3.0
         */
        public Authenticated authenticate(Credentials credentials)
                throws ContextAuthenticationException {
                
                log.debug("Authenticating client '{}' with scheme '{}'", credentials.getClientName(),
                        credentials.getAuthenticationScheme());
                
                Authenticated authenticated = null;
                try {
                        authenticated = authenticationScheme.authenticate(credentials);
                        this.user = authenticated.getUser();
                        notifyUserSessionListener(this.user, Event.LOGIN, Status.SUCCESS);
                }
                catch (ContextAuthenticationException e) {
                        User loggingInUser = new User();
                        loggingInUser.setUsername(credentials.getClientName());
                        notifyUserSessionListener(loggingInUser, Event.LOGIN, Status.FAIL);
                        throw e;
                }
                
                setUserLocation(true);
                setUserLocale(true);
                
                log.debug("Authenticated as: {}", this.user);
                
                return authenticated;
        }
        
        /**
         * Refresh the authenticated user object in this UserContext. This should be used when updating
         * information in the database about the current user and it needs to be reflecting in the
         * (cached) {@link #getAuthenticatedUser()} User object.
         *
         * @since 1.5
         */
        public void refreshAuthenticatedUser() {
                log.debug("Refreshing authenticated user");
                
                if (user != null) {
                        user = Context.getUserService().getUser(user.getUserId());
                        //update the stored location in the user's session
                        setUserLocation(false);
                        setUserLocale(false);
                }
        }
        
        /**
         * Change current authentication to become another user. (You can only do this if you're already
         * authenticated as a superuser.)
         *
         * @param systemId
         * @return The new user that this context has been set to. (null means no change was made)
         * @throws ContextAuthenticationException
         */
        public User becomeUser(String systemId) throws ContextAuthenticationException {
                if (!Daemon.isDaemonThread() && !Context.getAuthenticatedUser().isSuperUser()) {
                        throw new APIAuthenticationException("You must be a superuser to assume another user's identity");
                }
                
                log.debug("Turning the authenticated user into user with systemId: {}", systemId);
                
                User userToBecome = Context.getUserService().getUserByUsername(systemId);
                
                if (userToBecome == null) {
                        throw new ContextAuthenticationException("User not found with systemId: " + systemId);
                }
                
                // hydrate the user object
                if (userToBecome.getAllRoles() != null) {
                        userToBecome.getAllRoles().size();
                }
                
                if (userToBecome.getUserProperties() != null) {
                        userToBecome.getUserProperties().size();
                }
                
                if (userToBecome.getPrivileges() != null) {
                        userToBecome.getPrivileges().size();
                }
                
                this.user = userToBecome;
                
                //update the user's location and locale
                setUserLocation(false);
                setUserLocale(false);
                
                log.debug("Becoming user: {}", user);
                
                return userToBecome;
        }
        
        /**
         * @return "active" user who has been authenticated, otherwise <code>null</code>
         */
        public User getAuthenticatedUser() {
                return user;
        }
        
        /**
         * @return true if user has been authenticated in this UserContext
         */
        public boolean isAuthenticated() {
                return user != null;
        }
        
        /**
         * logs out the "active" (authenticated) user within this UserContext
         *
         * @see #authenticate
         */
        public void logout() {
                log.debug("setting user to null on logout");
                notifyUserSessionListener(user, Event.LOGOUT, Status.SUCCESS);
                user = null;
                locationId = null;
                locale = null;
                proxies.clear();
        }
        
        /**
         * Gives the given privilege to all calls to hasPrivilege. This method was visualized as being
         * used as follows (try/finally is important):
         *
         * <pre>
         * try {
         *   Context.addProxyPrivilege(&quot;AAA&quot;);
         *   Context.get*Service().methodRequiringAAAPrivilege();
         * }
         * finally {
         *   Context.removeProxyPrivilege(&quot;AAA&quot;);
         * }
         * </pre>
         *
         * @param privilege to give to users
         */
        public void addProxyPrivilege(String privilege) {
                if (privilege == null) {
                        throw new IllegalArgumentException("UserContext.addProxyPrivilege does not accept null privileges");
                }

                log.debug("Adding proxy privilege: {}", privilege);
                proxies.add(privilege);
        }
        
        /**
         * Will remove one instance of privilege from the privileges that are currently proxied
         *
         * @param privilege Privilege to remove in string form
         */
        public void removeProxyPrivilege(String privilege) {
                if (privilege == null) {
                        return;
                }

                log.debug("Removing privilege: {}", privilege);
                proxies.remove(privilege);
        }
        
        /**
         * Adds one or more privileges to the list of privileges that that {@link #hasPrivilege(String)} will
         * regard as available regardless of whether the user would otherwise have the privilege.
         * <p/>
         * This is useful for situations where a system process may need access to some piece of data that the
         * user would not otherwise have access to, like a GlobalProperty. <strong>This facility should not be
         * used to return data to the user that they otherwise would be unable to see.</strong>
         * <p/>
         * The expected usage is:
         * <p/>
         * <pre>{@code
         * try {
         *   Context.addProxyPrivilege(&quot;AAA&quot;);
         *   Context.get*Service().methodRequiringAAAPrivilege();
         * }
         * finally {
         *   Context.removeProxyPrivilege(&quot;AAA&quot;);
         * }}
         * </pre>
         * <p/>
         *
         * @param privileges privileges to add in string form
         * @see #hasPrivilege(String)
         * @see #removeProxyPrivilege(String...)
         */
        public void addProxyPrivilege(String... privileges) {
                if (privileges == null || Arrays.stream(privileges).anyMatch(Objects::isNull)) {
                        throw new IllegalArgumentException("UserContext.addProxyPrivilege does not accept null privileges");
                }
                
                for (String privilege : privileges) {
                        addProxyPrivilege(privilege);
                }
        }
        
        /**
         * Removes one or more privileges to the list of privileges that that {@link #hasPrivilege(String)} will
         * regard as available regardless of whether the user would otherwise have the privilege.
         * <p/>
         * This is the compliment for {@link #addProxyPrivilege(String...)} to clean-up the context.
         * <p/>
         *
         * @param privileges privileges to remove in string form
         * @see #hasPrivilege(String)
         * @see #addProxyPrivilege(String...)
         */
        public void removeProxyPrivilege(String... privileges) {
                if (privileges == null || Arrays.stream(privileges).allMatch(Objects::isNull)) {
                        return;
                }
                
                for (String privilege : privileges) {
                        if (privilege != null) {
                                removeProxyPrivilege(privilege);
                        }
                }
        }

        /**
         * @return true if there are any proxy privileges
         * @since 2.9.0
         */
        public boolean hasProxyPrivileges() {
                return !proxies.isEmpty();
        }
        
        /**
         * @param locale new locale for this context
         */
        public void setLocale(Locale locale) {
                this.locale = locale;
        }
        
        /**
         * @return current locale for this context
         */
        public Locale getLocale() {
                if (locale == null) {
                        // don't cache default locale - allows recognition of changed default at login page
                        return LocaleUtility.getDefaultLocale();
                }
                
                return locale;
        }
        
        /**
         * Gets all the roles for the (un)authenticated user. Anonymous and Authenticated roles are
         * appended if necessary
         *
         * @return all expanded roles for a user
         * @throws Exception
         */
        public Set<Role> getAllRoles() throws Exception {
                return getAllRoles(getAuthenticatedUser());
        }
        
        /**
         * Gets all the roles for a user. Anonymous and Authenticated roles are appended if necessary
         *
         * @param user
         * @return all expanded roles for a user
         * <strong>Should</strong> not fail with null user
         * <strong>Should</strong> add anonymous role to all users
         * <strong>Should</strong> add authenticated role to all authenticated users
         * <strong>Should</strong> return same roles as user getAllRoles method
         */
        public Set<Role> getAllRoles(User user) throws Exception {
                Set<Role> roles = new HashSet<>();
                
                // add the Anonymous Role
                roles.add(getAnonymousRole());
                
                // add the Authenticated role
                if (getAuthenticatedUser() != null && getAuthenticatedUser().equals(user)) {
                        roles.addAll(user.getAllRoles());
                        roles.add(getAuthenticatedRole());
                }
                
                return roles;
        }
        
        /**
         * Tests whether the currently authenticated user has a particular privilege
         *
         * @param privilege The privilege to check if it's available
         * @return true if authenticated user has given privilege
         * <strong>Should</strong> authorize if authenticated user has specified privilege
         * <strong>Should</strong> authorize if authenticated role has specified privilege
         * <strong>Should</strong> authorize if proxied user has specified privilege
         * <strong>Should</strong> authorize if anonymous user has specified privilege
         * <strong>Should</strong> not authorize if authenticated user does not have specified privilege
         * <strong>Should</strong> not authorize if authenticated role does not have specified privilege
         * <strong>Should</strong> not authorize if proxied user does not have specified privilege
         * <strong>Should</strong> not authorize if anonymous user does not have specified privilege
         */
        public boolean hasPrivilege(String privilege) {
                return hasPrivilege(privilege, true);
        }

        /**
         * Tests whether the current user has a particular privilege, optionally excluding proxy privileges.
         * <p>
         * Passing <code>false</code> resolves the privilege only from the user's roles (and the anonymous
         * and authenticated roles), ignoring any {@link #addProxyPrivilege(String...) proxy privileges}.
         * This is intended for per-resource access checks that must reflect the user's actual granted roles
         * and must not be satisfied by a proxy privilege added merely to invoke the surrounding service
         * method. Role privileges are still resolved authoritatively (from the role privilege cache),
         * unlike {@link User#hasPrivilege(String)} which reads a potentially stale in-memory role graph.
         *
         * @param privilege The privilege to check if it's available
         * @param includeProxyPrivileges whether proxy privileges may satisfy the check
         * @return true if the current user has the given privilege
         * @since 3.0.0, 2.9.0, 2.8.9
         */
        public boolean hasPrivilege(String privilege, boolean includeProxyPrivileges) {
                if (includeProxyPrivileges) {
                        log.debug("Checking '{}' against proxies: {}", privilege, proxies);
                        // check proxied privileges; ArrayList so we have a consistent view
                        for (String s : new ArrayList<>(proxies)) {
                                if (s.equals(privilege)) {
                                        notifyPrivilegeListeners(getAuthenticatedUser(), privilege, true);
                                        return true;
                                }
                        }
                }

                boolean hasPrivilege = resolvePrivilege(privilege);
                notifyPrivilegeListeners(getAuthenticatedUser(), privilege, hasPrivilege);
                return hasPrivilege;
        }

        /**
         * Resolves whether the current user (authenticated or anonymous) holds the given privilege by
         * consulting the per-role privilege cache instead of recursively re-expanding the role graph on
         * every call. Proxy privileges are handled separately by {@link #hasPrivilege(String)}.
         *
         * @param privilege the privilege to check
         * @return true if the privilege is granted
         */
        private boolean resolvePrivilege(String privilege) {
                RolePrivilegeCache cache = getRolePrivilegeCache();

                // if a user has logged in, check their privileges
                if (isAuthenticated()) {
                        // All authenticated users have the "" (empty) privilege, matching User.hasPrivilege.
                        if (StringUtils.isEmpty(privilege)) {
                                return true;
                        }

                        User authenticatedUser = getAuthenticatedUser();
                        if (authenticatedUser.getRoles() != null) {
                                for (Role role : authenticatedUser.getRoles()) {
                                        if (roleGrants(cache, role, privilege)) {
                                                return true;
                                        }
                                }
                        }

                        if (roleGrants(cache, getAuthenticatedRole(), privilege)) {
                                return true;
                        }
                }

                return roleGrants(cache, getAnonymousRole(), privilege);
        }

        /**
         * Tests whether a single role (and its inherited closure) grants the given privilege, using the
         * cached flattening when available and falling back to a direct computation otherwise.
         *
         * @param cache the role privilege cache, or <code>null</code> if unavailable
         * @param role the directly assigned role to test
         * @param privilege the privilege to check
         * @return true if the role grants superuser status or contains the privilege
         */
        private boolean roleGrants(RolePrivilegeCache cache, Role role, String privilege) {
                RolePrivileges rolePrivileges = (cache != null) ? cache.getRolePrivileges(role)
                        : RolePrivilegeCache.computeRolePrivileges(role);
                return rolePrivileges.grantsSuperuser() || rolePrivileges.containsPrivilege(privilege);
        }

        /**
         * Looks up the {@link RolePrivilegeCache} component, or returns <code>null</code> so callers fall
         * back to direct computation. Absence during a context refresh is expected (logged at debug);
         * absence otherwise is a misconfiguration that silently drops every check to the uncached path, so
         * it is warned once.
         *
         * @return the cache component, or <code>null</code> if unavailable
         */
        private RolePrivilegeCache getRolePrivilegeCache() {
                try {
                        return Context.getRegisteredComponent("rolePrivilegeCache", RolePrivilegeCache.class);
                } catch (Exception e) {
                        if (Context.isRefreshingContext()) {
                                log.debug("Role privilege cache is unavailable while the context is refreshing; "
                                        + "computing role privileges directly",
                                    e);
                        } else if (rolePrivilegeCacheUnavailableWarned.compareAndSet(false, true)) {
                                log.warn("Could not obtain the rolePrivilegeCache component; privilege checks will recompute role "
                                        + "privileges on every call until this is resolved",
                                    e);
                        }
                        return null;
                }
        }
        
        /**
         * Convenience method to get the Role in the system designed to be given to all users
         *
         * @return Role
         * <strong>Should</strong> fail if database doesn't contain anonymous role
         */
        private Role getAnonymousRole() {
                if (anonymousRole != null) {
                        return anonymousRole;
                }
                
                anonymousRole = Context.getUserService().getRole(RoleConstants.ANONYMOUS);
                if (anonymousRole == null) {
                        throw new RuntimeException(
                                "Database out of sync with code: " + RoleConstants.ANONYMOUS + " role does not exist");
                }
                
                return anonymousRole;
        }
        
        /**
         * Convenience method to get the Role in the system designed to be given to all users that have
         * authenticated in some manner
         *
         * @return Role
         * <strong>Should</strong> fail if database doesn't contain authenticated role
         */
        private Role getAuthenticatedRole() {
                if (authenticatedRole != null) {
                        return authenticatedRole;
                }
                
                authenticatedRole = Context.getUserService().getRole(RoleConstants.AUTHENTICATED);
                if (authenticatedRole == null) {
                        throw new RuntimeException("Database out of sync with code: " + RoleConstants.AUTHENTICATED
                                + " role does not exist");
                }
                
                return authenticatedRole;
        }
        
        /**
         * @return locationId for this user context if any is set
         * @since 1.10
         */
        public Integer getLocationId() {
                return locationId;
        }
        
        /**
         * @param locationId locationId to set
         * @since 1.10
         */
        public void setLocationId(Integer locationId) {
                this.locationId = locationId;
        }
        
        /**
         * @return current location for this user context if any is set
         * @since 1.9
         */
        public Location getLocation() {
                if (locationId == null) {
                        return null;
                }
                return Context.getLocationService().getLocation(locationId);
        }
        
        /**
         * @param location the location to set to
         * @since 1.9
         */
        public void setLocation(Location location) {
                if (location != null) {
                        this.locationId = location.getLocationId();
                }
        }
        
        /**
         * Convenience method that sets the default location of the currently authenticated user using
         * the value of the user's default location property
         */
        private void setUserLocation(boolean useDefault) {
                // location should be null if no user is logged in
                if (this.user == null) {
                        this.locationId = null;
                        return;
                }
                
                // intended to be when the user initially authenticates
                if (this.locationId == null && useDefault) {
                        this.locationId = getDefaultLocationId(this.user);
                }
        }

        /**
         * Convenience method that sets the default locale used by the currently authenticated user, using
         * the value of the user's default local property
         */
        private void setUserLocale(boolean useDefault) {
                // local should be null if no user is logged in
                if (this.user == null) {
                        this.locale = null;
                        return;
                }

                // intended to be when the user initially authenticates
                if (user.getUserProperties().containsKey("defaultLocale")) {
                        String localeString = user.getUserProperty("defaultLocale");
                        locale = LocaleUtility.fromSpecification(localeString);
                }

                if (locale == null && useDefault) {
                        locale = LocaleUtility.getDefaultLocale();
                }

        }
        
        protected Integer getDefaultLocationId(User user) {
                String defaultLocation = user.getUserProperty(OpenmrsConstants.USER_PROPERTY_DEFAULT_LOCATION);
                if (StringUtils.isNotBlank(defaultLocation)) {
                        LocationService ls = Context.getLocationService();
                        //only go ahead if it has actually changed OR if wasn't set before
                        try {
                                int defaultId = Integer.parseInt(defaultLocation);
                                if (this.locationId == null || this.locationId != defaultId) {
                                        // validate that the id is a valid id
                                        if (ls.getLocation(defaultId) != null) {
                                                return defaultId;
                                        }
                                }
                        }
                        catch (NumberFormatException ignored) {
                        }

                        Location possibleLocation = ls.getLocationByUuid(defaultLocation);

                        if (possibleLocation != null && (this.locationId == null || !this.locationId.equals(possibleLocation.getId()))) {
                                return possibleLocation.getId();
                        }

                        log.warn("The default location for user '{}' is set to '{}', which is not a valid location",
                                user.getUsername(), defaultLocation);
                }
                
                return null;
        }
        
        /**
         * Notifies privilege listener beans about any privilege check.
         * <p>
         * It is called by {@link UserContext#hasPrivilege(java.lang.String)}.
         *
         * @param user         the authenticated user or <code>null</code> if not authenticated
         * @param privilege    the checked privilege
         * @param hasPrivilege <code>true</code> if the authenticated user has the required privilege or
         *                     if it is a proxy privilege
         * @see PrivilegeListener
         * @since 1.8.4, 1.9.1, 1.10
         */
        private void notifyPrivilegeListeners(User user, String privilege, boolean hasPrivilege) {
                for (PrivilegeListener privilegeListener : Context.getRegisteredComponents(PrivilegeListener.class)) {
                        try {
                                privilegeListener.privilegeChecked(user, privilege, hasPrivilege);
                        }
                        catch (Exception e) {
                                log.error("Privilege listener has failed", e);
                        }
                }
        }
        
        private void notifyUserSessionListener(User user, Event event, Status status) {
                for (UserSessionListener userSessionListener : Context.getRegisteredComponents(UserSessionListener.class)) {
                        userSessionListener.loggedInOrOut(user, event, status);
                }
        }
}

openmrs / openmrs-core / 36476868921

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous