PHP PhabricatorApplicationTransaction::getMetadataValue方法代码示例

 protected function applyCustomInternalTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     $new = $xaction->getNewValue();
     switch ($xaction->getTransactionType()) {
         case ReleephRequestTransaction::TYPE_REQUEST:
             $object->setRequestCommitPHID($new);
             break;
         case ReleephRequestTransaction::TYPE_USER_INTENT:
             $user_phid = $xaction->getAuthorPHID();
             $intents = $object->getUserIntents();
             $intents[$user_phid] = $new;
             $object->setUserIntents($intents);
             break;
         case ReleephRequestTransaction::TYPE_EDIT_FIELD:
             $field = newv($xaction->getMetadataValue('fieldClass'), array());
             $field->setReleephRequest($object)->setValue($new);
             break;
         case ReleephRequestTransaction::TYPE_PICK_STATUS:
             $object->setPickStatus($new);
             break;
         case ReleephRequestTransaction::TYPE_COMMIT:
             $this->setInBranchFromAction($object, $xaction);
             $object->setCommitIdentifier($new);
             break;
         case ReleephRequestTransaction::TYPE_DISCOVERY:
             $this->setInBranchFromAction($object, $xaction);
             $object->setCommitPHID($new);
             break;
         case ReleephRequestTransaction::TYPE_MANUAL_IN_BRANCH:
             $object->setInBranch((int) $new);
             break;
     }
 }

 protected function applyCustomInternalTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     switch ($xaction->getTransactionType()) {
         case NuanceRequestorTransaction::TYPE_PROPERTY:
             $key = $xaction->getMetadataValue(NuanceRequestorTransaction::PROPERTY_KEY);
             $object->setNuanceProperty($key, $xaction->getNewValue());
             break;
     }
 }

 protected function applyCustomExternalTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     switch ($xaction->getTransactionType()) {
         case AlmanacTransaction::TYPE_PROPERTY_UPDATE:
             $property_key = $xaction->getMetadataValue('almanac.property');
             if ($object->hasAlmanacProperty($property_key)) {
                 $property = $object->getAlmanacProperty($property_key);
             } else {
                 $property = id(new AlmanacProperty())->setObjectPHID($object->getPHID())->setFieldName($property_key);
             }
             $property->setFieldValue($xaction->getNewValue())->save();
             return;
         case AlmanacTransaction::TYPE_PROPERTY_REMOVE:
             $property_key = $xaction->getMetadataValue('almanac.property');
             if ($object->hasAlmanacProperty($property_key)) {
                 $property = $object->getAlmanacProperty($property_key);
                 $property->delete();
             }
             return;
     }
     return parent::applyCustomExternalTransaction($object, $xaction);
 }

 protected function applyCustomInternalTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     $new = $xaction->getNewValue();
     switch ($xaction->getTransactionType()) {
         case PhabricatorMetaMTAApplicationEmailTransaction::TYPE_ADDRESS:
             $object->setAddress($new);
             return;
         case PhabricatorMetaMTAApplicationEmailTransaction::TYPE_CONFIG:
             $key = $xaction->getMetadataValue(PhabricatorMetaMTAApplicationEmailTransaction::KEY_CONFIG);
             $object->setConfigValue($key, $new);
             return;
     }
     return parent::applyCustomInternalTransaction($object, $xaction);
 }

 protected function applyCustomInternalTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     switch ($xaction->getTransactionType()) {
         case PhortunePaymentProviderConfigTransaction::TYPE_CREATE:
             return;
         case PhortunePaymentProviderConfigTransaction::TYPE_PROPERTY:
             $property_key = $xaction->getMetadataValue(PhortunePaymentProviderConfigTransaction::PROPERTY_KEY);
             $object->setMetadataValue($property_key, $xaction->getNewValue());
             return;
         case PhortunePaymentProviderConfigTransaction::TYPE_ENABLE:
             return $object->setIsEnabled((int) $xaction->getNewValue());
     }
     return parent::applyCustomInternalTransaction($object, $xaction);
 }

 protected function applyCustomInternalTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     $setting_key = $xaction->getMetadataValue(PhabricatorUserPreferencesTransaction::PROPERTY_SETTING);
     switch ($xaction->getTransactionType()) {
         case PhabricatorUserPreferencesTransaction::TYPE_SETTING:
             $new_value = $xaction->getNewValue();
             if ($new_value === null) {
                 $object->unsetPreference($setting_key);
             } else {
                 $object->setPreference($setting_key, $new_value);
             }
             return;
     }
     return parent::applyCustomInternalTransaction($object, $xaction);
 }

 protected function applyCustomInternalTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     switch ($xaction->getTransactionType()) {
         case PhabricatorProfilePanelConfigurationTransaction::TYPE_PROPERTY:
             $key = $xaction->getMetadataValue('property.key');
             $value = $xaction->getNewValue();
             $object->setPanelProperty($key, $value);
             return;
         case PhabricatorProfilePanelConfigurationTransaction::TYPE_ORDER:
             $object->setPanelOrder($xaction->getNewValue());
             return;
         case PhabricatorProfilePanelConfigurationTransaction::TYPE_VISIBILITY:
             $object->setVisibility($xaction->getNewValue());
             return;
     }
     return parent::applyCustomInternalTransaction($object, $xaction);
 }

 protected function applyCustomInternalTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     switch ($xaction->getTransactionType()) {
         case NuanceItemTransaction::TYPE_REQUESTOR:
             $object->setRequestorPHID($xaction->getNewValue());
             break;
         case NuanceItemTransaction::TYPE_SOURCE:
             $object->setSourcePHID($xaction->getNewValue());
             break;
         case NuanceItemTransaction::TYPE_OWNER:
             $object->setOwnerPHID($xaction->getNewValue());
             break;
         case NuanceItemTransaction::TYPE_PROPERTY:
             $key = $xaction->getMetadataValue(NuanceItemTransaction::PROPERTY_KEY);
             $object->setNuanceProperty($key, $xaction->getNewValue());
             break;
     }
 }

 protected function applyCustomInternalTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     $v = $xaction->getNewValue();
     switch ($xaction->getTransactionType()) {
         case PhabricatorAuthProviderConfigTransaction::TYPE_ENABLE:
             return $object->setIsEnabled($v);
         case PhabricatorAuthProviderConfigTransaction::TYPE_REGISTRATION:
             return $object->setShouldAllowRegistration($v);
         case PhabricatorAuthProviderConfigTransaction::TYPE_LINK:
             return $object->setShouldAllowLink($v);
         case PhabricatorAuthProviderConfigTransaction::TYPE_UNLINK:
             return $object->setShouldAllowUnlink($v);
         case PhabricatorAuthProviderConfigTransaction::TYPE_TRUST_EMAILS:
             return $object->setShouldTrustEmails($v);
         case PhabricatorAuthProviderConfigTransaction::TYPE_PROPERTY:
             $key = $xaction->getMetadataValue(PhabricatorAuthProviderConfigTransaction::PROPERTY_KEY);
             return $object->setProperty($key, $v);
     }
 }

 protected function applyCustomInternalTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     switch ($xaction->getTransactionType()) {
         case PhabricatorEditEngineConfigurationTransaction::TYPE_NAME:
             $object->setName($xaction->getNewValue());
             return;
         case PhabricatorEditEngineConfigurationTransaction::TYPE_PREAMBLE:
             $object->setPreamble($xaction->getNewValue());
             return;
         case PhabricatorEditEngineConfigurationTransaction::TYPE_ORDER:
             $object->setFieldOrder($xaction->getNewValue());
             return;
         case PhabricatorEditEngineConfigurationTransaction::TYPE_DEFAULT:
             $field_key = $xaction->getMetadataValue('field.key');
             $object->setFieldDefault($field_key, $xaction->getNewValue());
             return;
         case PhabricatorEditEngineConfigurationTransaction::TYPE_LOCKS:
             $object->setFieldLocks($xaction->getNewValue());
             return;
     }
     return parent::applyCustomInternalTransaction($object, $xaction);
 }

 /**
  * @task customfield
  */
 private function getCustomFieldForTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     $field_key = $xaction->getMetadataValue('customfield:key');
     if (!$field_key) {
         throw new Exception("Custom field transaction has no 'customfield:key'!");
     }
     $field = PhabricatorCustomField::getObjectField($object, PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS, $field_key);
     if (!$field) {
         throw new Exception("Custom field transaction has invalid 'customfield:key'; field " . "'{$field_key}' is disabled or does not exist.");
     }
     if (!$field->shouldAppearInApplicationTransactions()) {
         throw new Exception("Custom field transaction '{$field_key}' does not implement " . "integration for ApplicationTransactions.");
     }
     $field->setViewer($this->getActor());
     return $field;
 }

 protected function requireCapabilities(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     switch ($xaction->getTransactionType()) {
         case PhabricatorProjectTransaction::TYPE_NAME:
         case PhabricatorProjectTransaction::TYPE_STATUS:
         case PhabricatorProjectTransaction::TYPE_IMAGE:
         case PhabricatorProjectTransaction::TYPE_ICON:
         case PhabricatorProjectTransaction::TYPE_COLOR:
             PhabricatorPolicyFilter::requireCapability($this->requireActor(), $object, PhabricatorPolicyCapability::CAN_EDIT);
             return;
         case PhabricatorProjectTransaction::TYPE_LOCKED:
             PhabricatorPolicyFilter::requireCapability($this->requireActor(), newv($this->getEditorApplicationClass(), array()), ProjectCanLockProjectsCapability::CAPABILITY);
             return;
         case PhabricatorTransactions::TYPE_EDGE:
             switch ($xaction->getMetadataValue('edge:type')) {
                 case PhabricatorProjectProjectHasMemberEdgeType::EDGECONST:
                     $old = $xaction->getOldValue();
                     $new = $xaction->getNewValue();
                     $add = array_keys(array_diff_key($new, $old));
                     $rem = array_keys(array_diff_key($old, $new));
                     $actor_phid = $this->requireActor()->getPHID();
                     $is_join = $add === array($actor_phid) && !$rem;
                     $is_leave = $rem === array($actor_phid) && !$add;
                     if ($is_join) {
                         // You need CAN_JOIN to join a project.
                         PhabricatorPolicyFilter::requireCapability($this->requireActor(), $object, PhabricatorPolicyCapability::CAN_JOIN);
                     } else {
                         if ($is_leave) {
                             // You usually don't need any capabilities to leave a project.
                             if ($object->getIsMembershipLocked()) {
                                 // you must be able to edit though to leave locked projects
                                 PhabricatorPolicyFilter::requireCapability($this->requireActor(), $object, PhabricatorPolicyCapability::CAN_EDIT);
                             }
                         } else {
                             // You need CAN_EDIT to change members other than yourself.
                             PhabricatorPolicyFilter::requireCapability($this->requireActor(), $object, PhabricatorPolicyCapability::CAN_EDIT);
                         }
                     }
                     return;
             }
             break;
     }
     return parent::requireCapabilities($object, $xaction);
 }

 protected function applyCustomExternalTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     $type = $xaction->getTransactionType();
     switch ($type) {
         case FundInitiativeTransaction::TYPE_NAME:
         case FundInitiativeTransaction::TYPE_DESCRIPTION:
         case FundInitiativeTransaction::TYPE_RISKS:
         case FundInitiativeTransaction::TYPE_STATUS:
         case FundInitiativeTransaction::TYPE_MERCHANT:
             return;
         case FundInitiativeTransaction::TYPE_BACKER:
         case FundInitiativeTransaction::TYPE_REFUND:
             $backer = id(new FundBackerQuery())->setViewer($this->requireActor())->withPHIDs(array($xaction->getNewValue()))->executeOne();
             if (!$backer) {
                 throw new Exception(pht('Unable to load %s!', 'FundBacker'));
             }
             $subx = array();
             if ($type == FundInitiativeTransaction::TYPE_BACKER) {
                 $subx[] = id(new FundBackerTransaction())->setTransactionType(FundBackerTransaction::TYPE_STATUS)->setNewValue(FundBacker::STATUS_PURCHASED);
             } else {
                 $amount = $xaction->getMetadataValue(FundInitiativeTransaction::PROPERTY_AMOUNT);
                 $subx[] = id(new FundBackerTransaction())->setTransactionType(FundBackerTransaction::TYPE_STATUS)->setNewValue($amount);
             }
             $editor = id(new FundBackerEditor())->setActor($this->requireActor())->setContentSource($this->getContentSource())->setContinueOnMissingFields(true)->setContinueOnNoEffect(true);
             $editor->applyTransactions($backer, $subx);
             return;
     }
     return parent::applyCustomExternalTransaction($object, $xaction);
 }

 protected function applyCustomExternalTransaction(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     switch ($xaction->getTransactionType()) {
         case PhabricatorAuditActionConstants::ACTION:
         case PhabricatorAuditTransaction::TYPE_COMMIT:
             return;
         case PhabricatorAuditActionConstants::INLINE:
             $reply = $xaction->getComment()->getReplyToComment();
             if ($reply && !$reply->getHasReplies()) {
                 $reply->setHasReplies(1)->save();
             }
             return;
         case PhabricatorAuditActionConstants::ADD_AUDITORS:
             $new = $xaction->getNewValue();
             if (!is_array($new)) {
                 $new = array();
             }
             $old = $xaction->getOldValue();
             if (!is_array($old)) {
                 $old = array();
             }
             $add = array_diff_key($new, $old);
             $actor = $this->requireActor();
             $requests = $object->getAudits();
             $requests = mpull($requests, null, 'getAuditorPHID');
             foreach ($add as $phid) {
                 if (isset($requests[$phid])) {
                     continue;
                 }
                 if ($this->getIsHeraldEditor()) {
                     $audit_requested = $xaction->getMetadataValue('auditStatus');
                     $audit_reason_map = $xaction->getMetadataValue('auditReasonMap');
                     $audit_reason = $audit_reason_map[$phid];
                 } else {
                     $audit_requested = PhabricatorAuditStatusConstants::AUDIT_REQUESTED;
                     $audit_reason = $this->getAuditReasons($phid);
                 }
                 $requests[] = id(new PhabricatorRepositoryAuditRequest())->setCommitPHID($object->getPHID())->setAuditorPHID($phid)->setAuditStatus($audit_requested)->setAuditReasons($audit_reason)->save();
             }
             $object->attachAudits($requests);
             return;
     }
     return parent::applyCustomExternalTransaction($object, $xaction);
 }

 protected function requireCapabilities(PhabricatorLiskDAO $object, PhabricatorApplicationTransaction $xaction)
 {
     switch ($xaction->getTransactionType()) {
         case PhabricatorProjectTransaction::TYPE_NAME:
         case PhabricatorProjectTransaction::TYPE_STATUS:
         case PhabricatorProjectTransaction::TYPE_IMAGE:
         case PhabricatorProjectTransaction::TYPE_ICON:
         case PhabricatorProjectTransaction::TYPE_COLOR:
             PhabricatorPolicyFilter::requireCapability($this->requireActor(), $object, PhabricatorPolicyCapability::CAN_EDIT);
             return;
         case PhabricatorTransactions::TYPE_EDGE:
             switch ($xaction->getMetadataValue('edge:type')) {
                 case PhabricatorEdgeConfig::TYPE_PROJ_MEMBER:
                     $old = $xaction->getOldValue();
                     $new = $xaction->getNewValue();
                     $add = array_keys(array_diff_key($new, $old));
                     $rem = array_keys(array_diff_key($old, $new));
                     $actor_phid = $this->requireActor()->getPHID();
                     $is_join = $add === array($actor_phid) && !$rem;
                     $is_leave = $rem === array($actor_phid) && !$add;
                     if ($is_join) {
                         // You need CAN_JOIN to join a project.
                         PhabricatorPolicyFilter::requireCapability($this->requireActor(), $object, PhabricatorPolicyCapability::CAN_JOIN);
                     } else {
                         if ($is_leave) {
                             // You don't need any capabilities to leave a project.
                         } else {
                             // You need CAN_EDIT to change members other than yourself.
                             PhabricatorPolicyFilter::requireCapability($this->requireActor(), $object, PhabricatorPolicyCapability::CAN_EDIT);
                         }
                     }
                     return;
             }
             break;
     }
     return parent::requireCapabilities($object, $xaction);
 }