PHP phid_get_type函数代码示例

 public function withIdentifiers(array $identifiers)
 {
     $ids = array();
     $callsigns = array();
     $phids = array();
     $monograms = array();
     foreach ($identifiers as $identifier) {
         if (ctype_digit($identifier)) {
             $ids[$identifier] = $identifier;
         } else {
             if (preg_match('/^(r[A-Z]+)|(R[1-9]\\d*)\\z/', $identifier)) {
                 $monograms[$identifier] = $identifier;
             } else {
                 $repository_type = PhabricatorRepositoryRepositoryPHIDType::TYPECONST;
                 if (phid_get_type($identifier) === $repository_type) {
                     $phids[$identifier] = $identifier;
                 } else {
                     $callsigns[$identifier] = $identifier;
                 }
             }
         }
     }
     $this->numericIdentifiers = $ids;
     $this->callsignIdentifiers = $callsigns;
     $this->phidIdentifiers = $phids;
     $this->monogramIdentifiers = $monograms;
     return $this;
 }

 protected function execute(ConduitAPIRequest $request)
 {
     $user = $request->getUser()->getPHID();
     $phid = $request->getValue('objectPHID');
     $new = false;
     $flag = id(new PhabricatorFlag())->loadOneWhere('objectPHID = %s AND ownerPHID = %s', $phid, $user);
     if ($flag) {
         $params = $request->getAllParameters();
         if (isset($params['color'])) {
             $flag->setColor($params['color']);
         }
         if (isset($params['note'])) {
             $flag->setNote($params['note']);
         }
     } else {
         $default_color = PhabricatorFlagColor::COLOR_BLUE;
         $flag = id(new PhabricatorFlag())->setOwnerPHID($user)->setType(phid_get_type($phid))->setObjectPHID($phid)->setReasonPHID($user)->setColor($request->getValue('color', $default_color))->setNote($request->getValue('note', ''));
         $new = true;
     }
     $this->attachHandleToFlag($flag, $request->getUser());
     $flag->save();
     $ret = $this->buildFlagInfoDictionary($flag);
     $ret['new'] = $new;
     return $ret;
 }

 public function markupHandle(array $matches)
 {
     $engine = $this->getEngine();
     $viewer = $engine->getConfig('viewer');
     if (!$this->isFlatText($matches[0])) {
         return $matches[0];
     }
     $phid_type = phid_get_type($matches[1]);
     if ($phid_type == PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN) {
         return $matches[0];
     }
     $token = $engine->storeText($matches[0]);
     if ($engine->isTextMode()) {
         return $token;
     }
     $original_key = self::KEY_RULE_HANDLE_ORIGINAL;
     $original = $engine->getTextMetadata($original_key, array());
     $original[$token] = $matches[0];
     $engine->setTextMetadata($original_key, $original);
     $metadata_key = self::KEY_RULE_HANDLE;
     $metadata = $engine->getTextMetadata($metadata_key, array());
     $phid = $matches[1];
     if (empty($metadata[$phid])) {
         $metadata[$phid] = array();
     }
     $metadata[$phid][] = $token;
     $engine->setTextMetadata($metadata_key, $metadata);
     return $token;
 }

 public function renderView()
 {
     $view = $this->newStoryView();
     $handle = $this->getHandle($this->getPrimaryObjectPHID());
     $view->setHref($handle->getURI());
     $type = phid_get_type($handle->getPHID());
     $phid_types = PhabricatorPHIDType::getAllTypes();
     $icon = null;
     if (!empty($phid_types[$type])) {
         $phid_type = $phid_types[$type];
         $class = $phid_type->getPHIDTypeApplicationClass();
         if ($class) {
             $application = PhabricatorApplication::getByClass($class);
             $icon = $application->getIcon();
         }
     }
     $view->setAppIcon($icon);
     $xaction_phids = $this->getValue('transactionPHIDs');
     $xaction = $this->getPrimaryTransaction();
     $xaction->setHandles($this->getHandles());
     $view->setTitle($xaction->getTitleForFeed());
     foreach ($xaction_phids as $xaction_phid) {
         $secondary_xaction = $this->getObject($xaction_phid);
         $secondary_xaction->setHandles($this->getHandles());
         $body = $secondary_xaction->getBodyForFeed($this);
         if (nonempty($body)) {
             $view->appendChild($body);
         }
     }
     $view->setImage($this->getHandle($xaction->getAuthorPHID())->getImageURI());
     return $view;
 }

 public static function loadAffiliatedUserPHIDs(array $package_ids)
 {
     if (!$package_ids) {
         return array();
     }
     $owners = id(new PhabricatorOwnersOwner())->loadAllWhere('packageID IN (%Ls)', $package_ids);
     $type_user = PhabricatorPeopleUserPHIDType::TYPECONST;
     $type_project = PhabricatorProjectProjectPHIDType::TYPECONST;
     $user_phids = array();
     $project_phids = array();
     foreach ($owners as $owner) {
         $owner_phid = $owner->getUserPHID();
         switch (phid_get_type($owner_phid)) {
             case PhabricatorPeopleUserPHIDType::TYPECONST:
                 $user_phids[] = $owner_phid;
                 break;
             case PhabricatorProjectProjectPHIDType::TYPECONST:
                 $project_phids[] = $owner_phid;
                 break;
         }
     }
     if ($project_phids) {
         $projects = id(new PhabricatorProjectQuery())->setViewer(PhabricatorUser::getOmnipotentUser())->withPHIDs($project_phids)->needMembers(true)->execute();
         foreach ($projects as $project) {
             foreach ($project->getMemberPHIDs() as $member_phid) {
                 $user_phids[] = $member_phid;
             }
         }
     }
     $user_phids = array_fuse($user_phids);
     return array_values($user_phids);
 }

 public function execute()
 {
     $phids = array_fuse($this->phids);
     $actors = array();
     $type_map = array();
     foreach ($phids as $phid) {
         $type_map[phid_get_type($phid)][] = $phid;
     }
     // TODO: Generalize this somewhere else.
     $results = array();
     foreach ($type_map as $type => $phids) {
         switch ($type) {
             case PhabricatorProjectProjectPHIDType::TYPECONST:
                 // NOTE: We're loading the projects here in order to respect policies.
                 $projects = id(new PhabricatorProjectQuery())->setViewer($this->getViewer())->withPHIDs($phids)->execute();
                 $subscribers = id(new PhabricatorSubscribersQuery())->withObjectPHIDs($phids)->execute();
                 $projects = mpull($projects, null, 'getPHID');
                 foreach ($phids as $phid) {
                     $project = idx($projects, $phid);
                     if (!$project) {
                         $results[$phid] = array();
                     } else {
                         $results[$phid] = idx($subscribers, $phid, array());
                     }
                 }
                 break;
             default:
                 break;
         }
     }
     return $results;
 }

 protected function getValueFromRequest(AphrontRequest $request, $key)
 {
     $list = $this->getListFromRequest($request, $key);
     $phids = array();
     $slugs = array();
     $project_type = PhabricatorProjectProjectPHIDType::TYPECONST;
     foreach ($list as $item) {
         $type = phid_get_type($item);
         if ($type == $project_type) {
             $phids[] = $item;
         } else {
             if (PhabricatorTypeaheadDatasource::isFunctionToken($item)) {
                 // If this is a function, pass it through unchanged; we'll evaluate
                 // it later.
                 $phids[] = $item;
             } else {
                 $slugs[] = $item;
             }
         }
     }
     if ($slugs) {
         $projects = id(new PhabricatorProjectQuery())->setViewer($this->requireViewer())->withSlugs($slugs)->execute();
         foreach ($projects as $project) {
             $phids[] = $project->getPHID();
         }
         $phids = array_unique($phids);
     }
     return $phids;
 }

 public function execute()
 {
     $phids = array_fuse($this->phids);
     $actors = array();
     $type_map = array();
     foreach ($phids as $phid) {
         $type_map[phid_get_type($phid)][] = $phid;
         $actors[$phid] = id(new PhabricatorMetaMTAActor())->setPHID($phid);
     }
     // TODO: Move this to PhabricatorPHIDType, or the objects, or some
     // interface.
     foreach ($type_map as $type => $phids) {
         switch ($type) {
             case PhabricatorPeopleUserPHIDType::TYPECONST:
                 $this->loadUserActors($actors, $phids);
                 break;
             case PhabricatorPeopleExternalPHIDType::TYPECONST:
                 $this->loadExternalUserActors($actors, $phids);
                 break;
             default:
                 $this->loadUnknownActors($actors, $phids);
                 break;
         }
     }
     return $actors;
 }

 protected function loadPropertyObject()
 {
     $viewer = $this->getViewer();
     $request = $this->getRequest();
     $object_phid = $request->getStr('objectPHID');
     switch (phid_get_type($object_phid)) {
         case AlmanacBindingPHIDType::TYPECONST:
             $query = new AlmanacBindingQuery();
             break;
         case AlmanacDevicePHIDType::TYPECONST:
             $query = new AlmanacDeviceQuery();
             break;
         case AlmanacServicePHIDType::TYPECONST:
             $query = new AlmanacServiceQuery();
             break;
         default:
             return new Aphront404Response();
     }
     $object = $query->setViewer($viewer)->withPHIDs(array($object_phid))->requireCapabilities(array(PhabricatorPolicyCapability::CAN_VIEW, PhabricatorPolicyCapability::CAN_EDIT))->needProperties(true)->executeOne();
     if (!$object) {
         return new Aphront404Response();
     }
     if (!$object instanceof AlmanacPropertyInterface) {
         return new Aphront404Response();
     }
     $this->propertyObject = $object;
     return null;
 }

 public function withIdentifiers(array $identifiers)
 {
     $identifiers = array_fuse($identifiers);
     $ids = array();
     $callsigns = array();
     $phids = array();
     $monograms = array();
     $slugs = array();
     foreach ($identifiers as $identifier) {
         if (ctype_digit((string) $identifier)) {
             $ids[$identifier] = $identifier;
             continue;
         }
         if (preg_match('/^(r[A-Z]+|R[1-9]\\d*)\\z/', $identifier)) {
             $monograms[$identifier] = $identifier;
             continue;
         }
         $repository_type = PhabricatorRepositoryRepositoryPHIDType::TYPECONST;
         if (phid_get_type($identifier) === $repository_type) {
             $phids[$identifier] = $identifier;
             continue;
         }
         if (preg_match('/^[A-Z]+\\z/', $identifier)) {
             $callsigns[$identifier] = $identifier;
             continue;
         }
         $slugs[$identifier] = $identifier;
     }
     $this->numericIdentifiers = $ids;
     $this->callsignIdentifiers = $callsigns;
     $this->phidIdentifiers = $phids;
     $this->monogramIdentifiers = $monograms;
     $this->slugIdentifiers = $slugs;
     return $this;
 }

 private function resolvePHIDs(array $phids)
 {
     // If we have a function like `projects(alincoln)`, try to resolve the
     // username first. This won't happen normally, but can be passed in from
     // the query string.
     // The user might also give us an invalid username. In this case, we
     // preserve it and return it in-place so we get an "invalid" token rendered
     // in the UI. This shows the user where the issue is and  best represents
     // the user's input.
     $usernames = array();
     foreach ($phids as $key => $phid) {
         if (phid_get_type($phid) != PhabricatorPeopleUserPHIDType::TYPECONST) {
             $usernames[$key] = $phid;
         }
     }
     if ($usernames) {
         $users = id(new PhabricatorPeopleQuery())->setViewer($this->getViewer())->withUsernames($usernames)->execute();
         $users = mpull($users, null, 'getUsername');
         foreach ($usernames as $key => $username) {
             $user = idx($users, $username);
             if ($user) {
                 $phids[$key] = $user->getPHID();
             }
         }
     }
     return $phids;
 }

 protected function getUsersFromRequest(AphrontRequest $request, $key, array $allow_types = array())
 {
     $list = $this->getListFromRequest($request, $key);
     $phids = array();
     $names = array();
     $allow_types = array_fuse($allow_types);
     $user_type = PhabricatorPeopleUserPHIDType::TYPECONST;
     foreach ($list as $item) {
         $type = phid_get_type($item);
         if ($type == $user_type) {
             $phids[] = $item;
         } else {
             if (isset($allow_types[$type])) {
                 $phids[] = $item;
             } else {
                 if (PhabricatorTypeaheadDatasource::isFunctionToken($item)) {
                     // If this is a function, pass it through unchanged; we'll evaluate
                     // it later.
                     $phids[] = $item;
                 } else {
                     $names[] = $item;
                 }
             }
         }
     }
     if ($names) {
         $users = id(new PhabricatorPeopleQuery())->setViewer($this->getViewer())->withUsernames($names)->execute();
         foreach ($users as $user) {
             $phids[] = $user->getPHID();
         }
         $phids = array_unique($phids);
     }
     return $phids;
 }

 protected function loadITem(PhutilArgumentParser $argv, $key)
 {
     $item = $argv->getArg($key);
     if (!strlen($item)) {
         throw new PhutilArgumentUsageException(pht('Specify a item with %s.', '--' . $key));
     }
     $query = id(new NuanceItemQuery())->setViewer($this->getViewer())->setRaisePolicyExceptions(true);
     $type_unknown = PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN;
     if (ctype_digit($item)) {
         $kind = 'id';
         $query->withIDs(array($item));
     } else {
         if (phid_get_type($item) !== $type_unknown) {
             $kind = 'phid';
             $query->withPHIDs($item);
         } else {
             throw new PhutilArgumentUsageException(pht('Specify the ID or PHID of an item to update. Parameter "%s" ' . 'is not an ID or PHID.', $item));
         }
     }
     $items = $query->execute();
     if (!$items) {
         switch ($kind) {
             case 'id':
                 $message = pht('No item exists with ID "%s".', $item);
                 break;
             case 'phid':
                 $message = pht('No item exists with PHID "%s".', $item);
                 break;
         }
         throw new PhutilArgumentUsageException($message);
     }
     return head($items);
 }

 public function handleRequest(AphrontRequest $request)
 {
     $viewer = $request->getViewer();
     $phid = $request->getURIData('phid');
     $action = $request->getURIData('action');
     if (!$request->isFormPost()) {
         return new Aphront400Response();
     }
     switch ($action) {
         case 'add':
             $is_add = true;
             break;
         case 'delete':
             $is_add = false;
             break;
         default:
             return new Aphront400Response();
     }
     $handle = id(new PhabricatorHandleQuery())->setViewer($viewer)->withPHIDs(array($phid))->executeOne();
     if (phid_get_type($phid) == PhabricatorProjectProjectPHIDType::TYPECONST) {
         // TODO: This is a big hack, but a weak argument for adding some kind
         // of "load for role" feature to ObjectQuery, and also not a really great
         // argument for adding some kind of "load extra stuff" feature to
         // SubscriberInterface. Do this for now and wait for the best way forward
         // to become more clear?
         $object = id(new PhabricatorProjectQuery())->setViewer($viewer)->withPHIDs(array($phid))->needWatchers(true)->executeOne();
     } else {
         $object = id(new PhabricatorObjectQuery())->setViewer($viewer)->withPHIDs(array($phid))->executeOne();
     }
     if (!$object instanceof PhabricatorSubscribableInterface) {
         return $this->buildErrorResponse(pht('Bad Object'), pht('This object is not subscribable.'), $handle->getURI());
     }
     if ($object->isAutomaticallySubscribed($viewer->getPHID())) {
         return $this->buildErrorResponse(pht('Automatically Subscribed'), pht('You are automatically subscribed to this object.'), $handle->getURI());
     }
     if ($object instanceof PhabricatorApplicationTransactionInterface) {
         if ($is_add) {
             $xaction_value = array('+' => array($viewer->getPHID()));
         } else {
             $xaction_value = array('-' => array($viewer->getPHID()));
         }
         $xaction = id($object->getApplicationTransactionTemplate())->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)->setNewValue($xaction_value);
         $editor = id($object->getApplicationTransactionEditor())->setActor($viewer)->setContinueOnNoEffect(true)->setContinueOnMissingFields(true)->setContentSourceFromRequest($request);
         $editor->applyTransactions($object->getApplicationTransactionObject(), array($xaction));
     } else {
         // TODO: Eventually, get rid of this once everything implements
         // PhabriatorApplicationTransactionInterface.
         $editor = id(new PhabricatorSubscriptionsEditor())->setActor($viewer)->setObject($object);
         if ($is_add) {
             $editor->subscribeExplicit(array($viewer->getPHID()), $explicit = true);
         } else {
             $editor->unsubscribe(array($viewer->getPHID()));
         }
         $editor->save();
     }
     // TODO: We should just render the "Unsubscribe" action and swap it out
     // in the document for Ajax requests.
     return id(new AphrontReloadResponse())->setURI($handle->getURI());
 }

 public function getAttachmentForObject($object, $data, $spec)
 {
     $uris = array();
     foreach ($object->getURIs() as $uri) {
         $uris[] = array('id' => $uri->getID(), 'type' => phid_get_type($uri->getPHID()), 'phid' => $uri->getPHID(), 'fields' => $uri->getFieldValuesForConduit());
     }
     return array('uris' => $uris);
 }