com.opengamma.engine.view.client.PortfolioPermissionChecker.java Source code

Introduction

Here is the source code for com.opengamma.engine.view.client.PortfolioPermissionChecker.java

Source

/**
 * Copyright (C) 2013 - present by OpenGamma Inc. and the OpenGamma group of companies
 *
 * Please see distribution for license.
 */
package com.opengamma.engine.view.client;

import static com.opengamma.engine.view.permission.PortfolioPermission.ALLOW;
import static com.opengamma.engine.view.permission.PortfolioPermission.DENY;
import static com.opengamma.engine.view.permission.PortfolioPermission.PARTIAL;

import java.util.List;
import java.util.Map;

import com.google.common.collect.ImmutableMap;
import com.opengamma.core.position.Portfolio;
import com.opengamma.core.position.PortfolioNode;
import com.opengamma.engine.view.permission.PortfolioPermission;
import com.opengamma.util.ArgumentChecker;

/**
 * Responsible for scanning a portfolio and, based on whether
 * a node's children are accessible, determines the permissions
 * for each individual node.
 */
public class PortfolioPermissionChecker {

    /**
     * The permissions determined for each node in the portfolio. Note
     * that not all nodes may have an entry. Any not can be assumed
     * to be denied access.
     */
    private final Map<PortfolioNode, PortfolioPermission> _permissions;

    /**
     * Constructor for the permission checker taking the portfolio to
     * check and the checker for each individual node.
     *
     * @param portfolio the portfolio to check, not null
     * @param nodeChecker the checker for each node in the portfolio, not null
     */
    public PortfolioPermissionChecker(Portfolio portfolio, NodeChecker nodeChecker) {
        ArgumentChecker.notNull(portfolio, "portfolio");
        ArgumentChecker.notNull(nodeChecker, "nodeChecker");
        _permissions = checkNodes(portfolio.getRootNode(), nodeChecker);
    }

    /**
     * Recursively check each node in the portfolio.
     *
     * @param node the node to check
     * @param nodeChecker the checker for the node
     * @return map of nodes with permissions
     */
    private Map<PortfolioNode, PortfolioPermission> checkNodes(PortfolioNode node, NodeChecker nodeChecker) {

        // TODO This should probably use PortfolioNodeTraverser for doing the depth-first traversal of the portfolio

        if (nodeChecker.check(node) == DENY) {
            return ImmutableMap.of(node, DENY);
        } else {
            List<PortfolioNode> children = node.getChildNodes();
            ImmutableMap.Builder<PortfolioNode, PortfolioPermission> builder = ImmutableMap.builder();
            // Result for node of interest is dependent on whether the children are accessible
            // so keep track of whether we are denied access to any
            boolean allAllowed = true;

            for (PortfolioNode child : children) {
                Map<PortfolioNode, PortfolioPermission> result = checkNodes(child, nodeChecker);
                builder.putAll(result);
                allAllowed = allAllowed && result.get(child) == ALLOW;
            }

            builder.put(node, allAllowed ? ALLOW : PARTIAL);
            return builder.build();
        }
    }

    /**
     * Returns the permissions for the specified node.
     *
     * @param node the node to check
     * @return the permissions for the node
     */
    public PortfolioPermission permissionCheck(PortfolioNode node) {
        return _permissions.containsKey(node) ? _permissions.get(node) : DENY;
    }
}