Diffusion Phabricator (feature/testing) Browse

testing

PhabricatorPolicyQuery.php
View Options

			<?php

			final class PhabricatorPolicyQuery
			extends PhabricatorCursorPagedPolicyAwareQuery {

			private $object;
			private $phids;

			const OBJECT_POLICY_PREFIX = 'obj.';

			public function setObject(PhabricatorPolicyInterface $object) {
			$this->object = $object;
			return $this;
			}

			public function withPHIDs(array $phids) {
			$this->phids = $phids;
			return $this;
			}

			public static function loadPolicies(
			PhabricatorUser $viewer,
			PhabricatorPolicyInterface $object) {

			$results = array();

			$map = array();
			foreach ($object->getCapabilities() as $capability) {
			$map[$capability] = $object->getPolicy($capability);
			}

			$policies = id(new PhabricatorPolicyQuery())
			->setViewer($viewer)
			->withPHIDs($map)
			->execute();

			foreach ($map as $capability => $phid) {
			$results[$capability] = $policies[$phid];
			}

			return $results;
			}

			public static function renderPolicyDescriptions(
			PhabricatorUser $viewer,
			PhabricatorPolicyInterface $object,
			$icon = false) {

			$policies = self::loadPolicies($viewer, $object);

			foreach ($policies as $capability => $policy) {
			$policies[$capability] = $policy->renderDescription($icon);
			}

			return $policies;
			}

			protected function loadPage() {
			if ($this->object && $this->phids) {
			throw new Exception(
			pht(
			'You can not issue a policy query with both %s and %s.',
			'setObject()',
			'setPHIDs()'));
			} else if ($this->object) {
			$phids = $this->loadObjectPolicyPHIDs();
			} else {
			$phids = $this->phids;
			}

			$phids = array_fuse($phids);

			$results = array();

			// First, load global policies.
			foreach (self::getGlobalPolicies() as $phid => $policy) {
			if (isset($phids[$phid])) {
			$results[$phid] = $policy;
			unset($phids[$phid]);
			}
			}

			// Now, load object policies.
			foreach (self::getObjectPolicies($this->object) as $phid => $policy) {
			if (isset($phids[$phid])) {
			$results[$phid] = $policy;
			unset($phids[$phid]);
			}
			}

			// If we still need policies, we're going to have to fetch data. Bucket
			// the remaining policies into rule-based policies and handle-based
			// policies.
			if ($phids) {
			$rule_policies = array();
			$handle_policies = array();
			foreach ($phids as $phid) {
			$phid_type = phid_get_type($phid);
			if ($phid_type == PhabricatorPolicyPHIDTypePolicy::TYPECONST) {
			$rule_policies[$phid] = $phid;
			} else {
			$handle_policies[$phid] = $phid;
			}
			}

			if ($handle_policies) {
			$handles = id(new PhabricatorHandleQuery())
			->setViewer($this->getViewer())
			->withPHIDs($handle_policies)
			->execute();
			foreach ($handle_policies as $phid) {
			$results[$phid] = PhabricatorPolicy::newFromPolicyAndHandle(
			$phid,
			$handles[$phid]);
			}
			}

			if ($rule_policies) {
			$rules = id(new PhabricatorPolicy())->loadAllWhere(
			'phid IN (%Ls)',
			$rule_policies);
			$results += mpull($rules, null, 'getPHID');
			}
			}

			$results = msort($results, 'getSortKey');

			return $results;
			}

			public static function isGlobalPolicy($policy) {
			$global_policies = self::getGlobalPolicies();

			if (isset($global_policies[$policy])) {
			return true;
			}

			return false;
			}

			public static function getGlobalPolicy($policy) {
			if (!self::isGlobalPolicy($policy)) {
			throw new Exception(pht("Policy '%s' is not a global policy!", $policy));
			}
			return idx(self::getGlobalPolicies(), $policy);
			}

			private static function getGlobalPolicies() {
			static $constants = array(
			PhabricatorPolicies::POLICY_PUBLIC,
			PhabricatorPolicies::POLICY_USER,
			PhabricatorPolicies::POLICY_ADMIN,
			PhabricatorPolicies::POLICY_NOONE,
			);

			$results = array();
			foreach ($constants as $constant) {
			$results[$constant] = id(new PhabricatorPolicy())
			->setType(PhabricatorPolicyType::TYPE_GLOBAL)
			->setPHID($constant)
			->setName(self::getGlobalPolicyName($constant))
			->setShortName(self::getGlobalPolicyShortName($constant))
			->makeEphemeral();
			}

			return $results;
			}

			private static function getGlobalPolicyName($policy) {
			switch ($policy) {
			case PhabricatorPolicies::POLICY_PUBLIC:
			return pht('Public (No Login Required)');
			case PhabricatorPolicies::POLICY_USER:
			return pht('All Users');
			case PhabricatorPolicies::POLICY_ADMIN:
			return pht('Administrators');
			case PhabricatorPolicies::POLICY_NOONE:
			return pht('No One');
			default:
			return pht('Unknown Policy');
			}
			}

			private static function getGlobalPolicyShortName($policy) {
			switch ($policy) {
			case PhabricatorPolicies::POLICY_PUBLIC:
			return pht('Public');
			default:
			return null;
			}
			}

			private function loadObjectPolicyPHIDs() {
			$phids = array();
			$viewer = $this->getViewer();

			if ($viewer->getPHID()) {
			$projects = id(new PhabricatorProjectQuery())
			->setViewer($viewer)
			->withMemberPHIDs(array($viewer->getPHID()))
			->execute();
			foreach ($projects as $project) {
			$phids[] = $project->getPHID();
			}

			// Include the "current viewer" policy. This improves consistency, but
			// is also useful for creating private instances of normally-shared object
			// types, like repositories.
			$phids[] = $viewer->getPHID();
			}

			$capabilities = $this->object->getCapabilities();
			foreach ($capabilities as $capability) {
			$policy = $this->object->getPolicy($capability);
			if (!$policy) {
			continue;
			}
			$phids[] = $policy;
			}

			// If this install doesn't have "Public" enabled, don't include it as an
			// option unless the object already has a "Public" policy. In this case we
			// retain the policy but enforce it as though it was "All Users".
			$show_public = PhabricatorEnv::getEnvConfig('policy.allow-public');
			foreach (self::getGlobalPolicies() as $phid => $policy) {
			if ($phid == PhabricatorPolicies::POLICY_PUBLIC) {
			if (!$show_public) {
			continue;
			}
			}
			$phids[] = $phid;
			}

			foreach (self::getObjectPolicies($this->object) as $phid => $policy) {
			$phids[] = $phid;
			}

			return $phids;
			}

			protected function shouldDisablePolicyFiltering() {
			// Policy filtering of policies is currently perilous and not required by
			// the application.
			return true;
			}

			public function getQueryApplicationClass() {
			return 'PhabricatorPolicyApplication';
			}

			public static function isSpecialPolicy($identifier) {
			if (self::isObjectPolicy($identifier)) {
			return true;
			}

			if (self::isGlobalPolicy($identifier)) {
			return true;
			}

			return false;
			}


			/* -( Object Policies )---------------------------------------------------- */


			public static function isObjectPolicy($identifier) {
			$prefix = self::OBJECT_POLICY_PREFIX;
			return !strncmp($identifier, $prefix, strlen($prefix));
			}

			public static function getObjectPolicy($identifier) {
			if (!self::isObjectPolicy($identifier)) {
			return null;
			}

			$policies = self::getObjectPolicies(null);
			return idx($policies, $identifier);
			}

			public static function getObjectPolicyRule($identifier) {
			if (!self::isObjectPolicy($identifier)) {
			return null;
			}

			$rules = self::getObjectPolicyRules(null);
			return idx($rules, $identifier);
			}

			public static function getObjectPolicies($object) {
			$rule_map = self::getObjectPolicyRules($object);

			$results = array();
			foreach ($rule_map as $key => $rule) {
			$results[$key] = id(new PhabricatorPolicy())
			->setType(PhabricatorPolicyType::TYPE_OBJECT)
			->setPHID($key)
			->setIcon($rule->getObjectPolicyIcon())
			->setName($rule->getObjectPolicyName())
			->setShortName($rule->getObjectPolicyShortName())
			->makeEphemeral();
			}

			return $results;
			}

			public static function getObjectPolicyRules($object) {
			$rules = id(new PhutilClassMapQuery())
			->setAncestorClass('PhabricatorPolicyRule')
			->execute();

			$results = array();
			foreach ($rules as $rule) {
			$key = $rule->getObjectPolicyKey();
			if (!$key) {
			continue;
			}

			$full_key = $rule->getObjectPolicyFullKey();
			if (isset($results[$full_key])) {
			throw new Exception(
			pht(
			'Two policy rules (of classes "%s" and "%s") define the same '.
			'object policy key ("%s"), but each object policy rule must use '.
			'a unique key.',
			get_class($rule),
			get_class($results[$full_key]),
			$key));
			}

			$results[$full_key] = $rule;
			}

			if ($object !== null) {
			foreach ($results as $key => $rule) {
			if (!$rule->canApplyToObject($object)) {
			unset($results[$key]);
			}
			}
			}

			return $results;
			}

			public static function getDefaultPolicyForObject(
			PhabricatorUser $viewer,
			PhabricatorPolicyInterface $object,
			$capability) {

			$phid = $object->getPHID();
			if (!$phid) {
			return null;
			}

			$type = phid_get_type($phid);

			$map = self::getDefaultObjectTypePolicyMap();

			if (empty($map[$type][$capability])) {
			return null;
			}

			$policy_phid = $map[$type][$capability];

			return id(new PhabricatorPolicyQuery())
			->setViewer($viewer)
			->withPHIDs(array($policy_phid))
			->executeOne();
			}

			private static function getDefaultObjectTypePolicyMap() {
			static $map;

			if ($map === null) {
			$map = array();

			$apps = PhabricatorApplication::getAllApplications();
			foreach ($apps as $app) {
			$map += $app->getDefaultObjectTypePolicyMap();
			}
			}

			return $map;
			}


			}

phab/src/applications/policy/query/PhabricatorPolicyQuery.phpe470b6bee2d2feature/testing

PhabricatorPolicyQuery.phpView Options

phab/src/applications/policy/query/PhabricatorPolicyQuery.php
e470b6bee2d2feature/testing

PhabricatorPolicyQuery.php
View Options