PHP ConduitAPIRequest::getIsStrictlyTyped方法代码示例

 protected function execute(ConduitAPIRequest $request)
 {
     $viewer = $request->getUser();
     $build_target_phid = $request->getValue('buildTargetPHID');
     $build_target = id(new HarbormasterBuildTargetQuery())->setViewer($viewer)->withPHIDs(array($build_target_phid))->executeOne();
     if (!$build_target) {
         throw new Exception(pht('No such build target "%s"!', $build_target_phid));
     }
     $artifact_type = $request->getValue('artifactType');
     // Cast "artifactData" parameters to acceptable types if this request
     // is submitting raw HTTP parameters. This is not ideal. See T11887 for
     // discussion.
     $artifact_data = $request->getValue('artifactData');
     if (!$request->getIsStrictlyTyped()) {
         $impl = HarbormasterArtifact::getArtifactType($artifact_type);
         if ($impl) {
             foreach ($artifact_data as $key => $value) {
                 $artifact_data[$key] = $impl->readArtifactHTTPParameter($key, $value);
             }
         }
     }
     $artifact = $build_target->createArtifact($viewer, $request->getValue('artifactKey'), $artifact_type, $artifact_data);
     return array('data' => $this->returnArtifactList(array($artifact)));
 }

 public function buildConduitResponse(ConduitAPIRequest $request, ConduitAPIMethod $method)
 {
     $viewer = $this->requireViewer();
     $query_key = $request->getValue('queryKey');
     if (!strlen($query_key)) {
         $saved_query = new PhabricatorSavedQuery();
     } else {
         if ($this->isBuiltinQuery($query_key)) {
             $saved_query = $this->buildSavedQueryFromBuiltin($query_key);
         } else {
             $saved_query = id(new PhabricatorSavedQueryQuery())->setViewer($viewer)->withQueryKeys(array($query_key))->executeOne();
             if (!$saved_query) {
                 throw new Exception(pht('Query key "%s" does not correspond to a valid query.', $query_key));
             }
         }
     }
     $constraints = $request->getValue('constraints', array());
     $fields = $this->getSearchFieldsForConduit();
     foreach ($fields as $key => $field) {
         if (!$field->getConduitParameterType()) {
             unset($fields[$key]);
         }
     }
     $valid_constraints = array();
     foreach ($fields as $field) {
         foreach ($field->getValidConstraintKeys() as $key) {
             $valid_constraints[$key] = true;
         }
     }
     foreach ($constraints as $key => $constraint) {
         if (empty($valid_constraints[$key])) {
             throw new Exception(pht('Constraint "%s" is not a valid constraint for this query.', $key));
         }
     }
     foreach ($fields as $field) {
         if (!$field->getValueExistsInConduitRequest($constraints)) {
             continue;
         }
         $value = $field->readValueFromConduitRequest($constraints, $request->getIsStrictlyTyped());
         $saved_query->setParameter($field->getKey(), $value);
     }
     // NOTE: Currently, when running an ad-hoc query we never persist it into
     // a saved query. We might want to add an option to do this in the future
     // (for example, to enable a CLI-to-Web workflow where user can view more
     // details about results by following a link), but have no use cases for
     // it today. If we do identify a use case, we could save the query here.
     $query = $this->buildQueryFromSavedQuery($saved_query);
     $pager = $this->newPagerForSavedQuery($saved_query);
     $attachments = $this->getConduitSearchAttachments();
     // TODO: Validate this better.
     $attachment_specs = $request->getValue('attachments', array());
     $attachments = array_select_keys($attachments, array_keys($attachment_specs));
     foreach ($attachments as $key => $attachment) {
         $attachment->setViewer($viewer);
     }
     foreach ($attachments as $key => $attachment) {
         $attachment->willLoadAttachmentData($query, $attachment_specs[$key]);
     }
     $this->setQueryOrderForConduit($query, $request);
     $this->setPagerLimitForConduit($pager, $request);
     $this->setPagerOffsetsForConduit($pager, $request);
     $objects = $this->executeQuery($query, $pager);
     $data = array();
     if ($objects) {
         $field_extensions = $this->getConduitFieldExtensions();
         $extension_data = array();
         foreach ($field_extensions as $key => $extension) {
             $extension_data[$key] = $extension->loadExtensionConduitData($objects);
         }
         $attachment_data = array();
         foreach ($attachments as $key => $attachment) {
             $attachment_data[$key] = $attachment->loadAttachmentData($objects, $attachment_specs[$key]);
         }
         foreach ($objects as $object) {
             $field_map = $this->getObjectWireFieldsForConduit($object, $field_extensions, $extension_data);
             $attachment_map = array();
             foreach ($attachments as $key => $attachment) {
                 $attachment_map[$key] = $attachment->getAttachmentForObject($object, $attachment_data[$key], $attachment_specs[$key]);
             }
             // If this is empty, we still want to emit a JSON object, not a
             // JSON list.
             if (!$attachment_map) {
                 $attachment_map = (object) $attachment_map;
             }
             $id = (int) $object->getID();
             $phid = $object->getPHID();
             $data[] = array('id' => $id, 'type' => phid_get_type($phid), 'phid' => $phid, 'fields' => $field_map, 'attachments' => $attachment_map);
         }
     }
     return array('data' => $data, 'maps' => $method->getQueryMaps($query), 'query' => array('queryKey' => $saved_query->getQueryKey()), 'cursor' => array('limit' => $pager->getPageSize(), 'after' => $pager->getNextPageID(), 'before' => $pager->getPrevPageID(), 'order' => $request->getValue('order')));
 }

 /**
  * Generate transactions which can be applied from edit actions in a Conduit
  * request.
  *
  * @param ConduitAPIRequest The request.
  * @param list<PhabricatorEditType> Supported edit types.
  * @param PhabricatorApplicationTransaction Template transaction.
  * @return list<PhabricatorApplicationTransaction> Generated transactions.
  * @task conduit
  */
 private function getConduitTransactions(ConduitAPIRequest $request, array $types, PhabricatorApplicationTransaction $template)
 {
     $viewer = $request->getUser();
     $transactions_key = 'transactions';
     $xactions = $request->getValue($transactions_key);
     if (!is_array($xactions)) {
         throw new Exception(pht('Parameter "%s" is not a list of transactions.', $transactions_key));
     }
     foreach ($xactions as $key => $xaction) {
         if (!is_array($xaction)) {
             throw new Exception(pht('Parameter "%s" must contain a list of transaction descriptions, ' . 'but item with key "%s" is not a dictionary.', $transactions_key, $key));
         }
         if (!array_key_exists('type', $xaction)) {
             throw new Exception(pht('Parameter "%s" must contain a list of transaction descriptions, ' . 'but item with key "%s" is missing a "type" field. Each ' . 'transaction must have a type field.', $transactions_key, $key));
         }
         $type = $xaction['type'];
         if (empty($types[$type])) {
             throw new Exception(pht('Transaction with key "%s" has invalid type "%s". This type is ' . 'not recognized. Valid types are: %s.', $key, $type, implode(', ', array_keys($types))));
         }
     }
     $results = array();
     if ($this->getIsCreate()) {
         $results[] = id(clone $template)->setTransactionType(PhabricatorTransactions::TYPE_CREATE);
     }
     foreach ($xactions as $xaction) {
         $type = $types[$xaction['type']];
         // Let the parameter type interpret the value. This allows you to
         // use usernames in list<user> fields, for example.
         $parameter_type = $type->getConduitParameterType();
         $parameter_type->setViewer($viewer);
         try {
             $xaction['value'] = $parameter_type->getValue($xaction, 'value', $request->getIsStrictlyTyped());
         } catch (Exception $ex) {
             throw new PhutilProxyException(pht('Exception when processing transaction of type "%s": %s', $xaction['type'], $ex->getMessage()), $ex);
         }
         $type_xactions = $type->generateTransactions(clone $template, $xaction);
         foreach ($type_xactions as $type_xaction) {
             $results[] = $type_xaction;
         }
     }
     return $results;
 }