PHP Request::delete方法代码示例

 /**
  * PUT command
  * @return bool true if ok
  */
 public function DELETE($url)
 {
     try {
         $this->response = Request::delete($url)->authenticateWith($this->username, $this->password)->expectsType('xml')->send();
     } catch (Exception $ex) {
         \Yii::error($exc->getMessage() . "\n" . $exc->getTraceAsString());
         return false;
     }
     if ($this->isOk()) {
         return true;
     }
     return false;
 }

 /**
  * Interface for performing requests to PromisePay endpoints
  *
  * @param string $method required One of the four supported requests methods (get, post, delete, patch)
  * @param string $entity required Endpoint name
  * @param string $payload optional URL encoded data query
  * @param string $mime optional Set specific MIME type. Supported list can be seen here: http://phphttpclient.com/docs/class-Httpful.Mime.html
  */
 public static function RestClient($method, $entity, $payload = null, $mime = null)
 {
     // Check whether critical constants are defined.
     if (!defined(__NAMESPACE__ . '\\API_URL')) {
         die("Fatal error: API_URL constant missing. Check if environment has been set.");
     }
     if (!defined(__NAMESPACE__ . '\\API_LOGIN')) {
         die("Fatal error: API_LOGIN constant missing.");
     }
     if (!defined(__NAMESPACE__ . '\\API_PASSWORD')) {
         die("Fatal error: API_PASSWORD constant missing.");
     }
     if (!is_null($payload)) {
         if (is_array($payload) || is_object($payload)) {
             $payload = http_build_query($payload);
         }
         // if the payload isn't array or object, leave it intact
     }
     $url = constant(__NAMESPACE__ . '\\API_URL') . $entity . '?' . $payload;
     switch ($method) {
         case 'get':
             $response = Request::get($url)->authenticateWith(constant(__NAMESPACE__ . '\\API_LOGIN'), constant(__NAMESPACE__ . '\\API_PASSWORD'))->send();
             break;
         case 'post':
             $response = Request::post($url)->body($payload, $mime)->authenticateWith(constant(__NAMESPACE__ . '\\API_LOGIN'), constant(__NAMESPACE__ . '\\API_PASSWORD'))->send();
             break;
         case 'delete':
             $response = Request::delete($url)->authenticateWith(constant(__NAMESPACE__ . '\\API_LOGIN'), constant(__NAMESPACE__ . '\\API_PASSWORD'))->send();
             break;
         case 'patch':
             $response = Request::patch($url)->body($payload, $mime)->authenticateWith(constant(__NAMESPACE__ . '\\API_LOGIN'), constant(__NAMESPACE__ . '\\API_PASSWORD'))->send();
             break;
         default:
             throw new Exception\ApiUnsupportedRequestMethod("Unsupported request method {$method}.");
     }
     // check for errors
     if ($response->hasErrors()) {
         $errors = static::buildErrorMessage($response);
         switch ($response->code) {
             case 401:
                 throw new Exception\Unauthorized($errors);
                 break;
             case 404:
                 throw new Exception\NotFound($errors);
             default:
                 throw new Exception\Api($errors);
                 break;
         }
     }
     return $response;
 }

 /**
  * @param Request $request
  *
  * @return HttpServer
  */
 public function getHttpServer(Request $request)
 {
     $url = $request->getUri();
     switch ($request->getMethod()) {
         case Request::METHOD_POST:
             $httpServer = HttpServer::post($url);
             break;
         case Request::METHOD_PUT:
             $httpServer = HttpServer::put($url);
             break;
         case Request::METHOD_DELETE:
             $httpServer = HttpServer::delete($url);
             break;
         default:
             $httpServer = HttpServer::get($url);
             break;
     }
     if ($request->headers) {
         $httpServer->addHeaders($request->headers->all());
     }
     if ($request->getUser()) {
         $httpServer->authenticateWith($request->getUser(), $request->getPassword());
     }
     if ($request->getContent()) {
         $httpServer->body($request->getContent());
     }
     return $httpServer;
 }

 /**
  * {@inheritdoc}
  */
 public function delete($url, $content = '')
 {
     $response = Request::delete()->addHeader("Accept", "application/json")->addHeader('Content-type', "application/json")->addHeader("X-TOKEN", $this->api)->body($content)->send();
     if ($this->isResponseOk($response->code)) {
         return $response->body;
     }
 }

 protected function delete($uri, array $params = null)
 {
     if (!is_null($params)) {
         $params = self::clean_array($params);
         return self::process_response(Request::delete(self::$base_uri . $uri . '?' . http_build_query($params))->send());
     }
     return self::process_response(Request::delete(self::$base_uri . $uri)->send());
 }

 public static function delete($url, $data = [], $auth = true)
 {
     $api = self::$api;
     $response = \Httpful\Request::delete($api->url . $url);
     // Will parse based on Content-Type
     if ($auth) {
         $response->authenticateWith($api->username, $api->password);
     }
     $response = $response->sendsJson()->body(json_encode($data))->send();
     return (array) $response->body;
 }

 public static function _DELETE($url)
 {
     $real_url = \Marketcloud\Marketcloud::$apiBaseUrl . $url;
     $response = \Httpful\Request::delete($real_url)->expectsJson()->addHeader('Authorization', \Marketcloud\Marketcloud::getAuthorizationHeader())->send();
     // We check the response code
     // If the code is 401, then the Token might be expired.
     // If it is the case, we re-authenticate the client using the stored credentials.
     //
     if ($response->code == 401) {
         // We have to re-authenticate
         $auth_response = \Marketcloud\Marketcloud::authenticate();
         return self::_DELETE($url);
     } else {
         return $response;
     }
 }

 public static function CallAPI($method, $url, $data = false)
 {
     $response = null;
     switch ($method) {
         case "GET":
             $response = \Httpful\Request::get($url)->expects("json")->send();
             break;
         case "POST":
             $response = \Httpful\Request::post($url)->body($data)->sendsAndExpects("json")->send();
             break;
         case "PUT":
             $response = \Httpful\Request::put($url)->body($data)->sendsAndExpects("json")->send();
             break;
         case "DELETE":
             $response = \Httpful\Request::delete($url)->body($data)->sendsAndExpects("json")->send();
             break;
     }
     return is_null($response) ? null : $response->body;
 }

 public function RestClient($method, $entity, $payload = null, $mime = null)
 {
     $username = $this->Login();
     $password = $this->Password();
     $url = $this->BaseUrl() . $entity . "?" . $payload;
     switch ($method) {
         case 'get':
             $response = Request::get($url)->authenticateWith($username, $password)->send();
             return $response;
             break;
         case 'post':
             $response = Request::post($url)->body($payload, $mime)->authenticateWith($username, $password)->send();
             return $response;
             break;
         case 'delete':
             $response = Request::delete($url)->authenticateWith($username, $password)->send();
             return $response;
             break;
         case 'patch':
             $response = Request::patch($url)->body($payload, $mime)->authenticateWith($username, $password)->send();
             return $response;
             break;
     }
 }

 public function processAction(CRM_Civirules_TriggerData_TriggerData $triggerData)
 {
     //do the http post process
     $uri = $this->getFullUri($triggerData);
     $method = $this->getHttpMethod();
     $body = http_build_query($this->getBodyParams($triggerData));
     switch (strtolower($method)) {
         case 'post':
             $request = \Httpful\Request::post($uri, $body);
             break;
         case 'put':
             $request = \Httpful\Request::put($uri, $body);
             break;
         case 'delete':
             $request = \Httpful\Request::delete($uri);
             break;
         case 'head':
             $request = \Httpful\Request::head($uri);
             break;
         case 'patch':
             $request = \Httpful\Request::patch($uri, $body);
             break;
         case 'options':
             $request = \Httpful\Request::options($uri, $body);
             break;
         case 'get':
             $request = $response = \Httpful\Request::get($uri);
             break;
         default:
             throw new Exception('Invalid HTTP Method');
     }
     $request->neverSerializePayload();
     $request = $this->alterHttpRequestObject($request, $triggerData);
     $response = $request->send();
     $this->handleResponse($response, $request, $triggerData);
 }

 public function request($url, $data, $header, $method = 'POST')
 {
     $logger = JPushLog::getLogger();
     $logger->debug("Send " . $method, array("method" => $method, "uri" => $url, "headers" => $header, "body" => $data));
     $request = null;
     if ($method === 'POST') {
         $request = Request::post($url);
     } else {
         if ($method == 'DELETE') {
             $request = Request::delete($url);
         } else {
             $request = Request::get($url);
         }
     }
     if (!is_null($data)) {
         $request->body($data);
     }
     $request->addHeaders($header)->authenticateWith($this->appKey, $this->masterSecret)->timeout(self::READ_TIMEOUT);
     $response = null;
     for ($retryTimes = 0;; $retryTimes++) {
         try {
             $response = $request->send();
             break;
         } catch (ConnectionErrorException $e) {
             if (strpos($e->getMessage(), '28')) {
                 throw new APIConnectionException("Response timeout. Your request has probably be received by JPush Server,please check that whether need to be pushed again.", true);
             }
             if (strpos($e->getMessage(), '56')) {
                 // resolve error[56 Problem (2) in the Chunked-Encoded data]
                 throw new APIConnectionException("Response timeout, maybe cause by old CURL version. Your request has probably be received by JPush Server, please check that whether need to be pushed again.", true);
             }
             if ($retryTimes >= $this->retryTimes) {
                 throw new APIConnectionException("Connect timeout. Please retry later.");
             } else {
                 $logger->debug("Exception - Message:" . $e->getMessage() . ", Code:" . $e->getCode());
                 $logger->debug("Retry again send " . $method, array("method" => $method, "uri" => $url, "headers" => $header, "body" => $data, "retryTimes" => $retryTimes + 1));
             }
         }
     }
     return $response;
 }

 public function delete(Entity $instance)
 {
     if (!$instance->isAllowedMethod(__FUNCTION__)) {
         throw new \DomainException(__FUNCTION__ . ' not allowed on this entity.');
     }
     $url = sprintf('%s/%s/%s/%s', $this->getApiUrl(), $this->getNetworkId(), $this->getEndpointName($instance), $instance->getId());
     $response = \Httpful\Request::delete($url)->authenticateWith($this->getLogin(), $this->getPassword())->send();
     if ($response->hasErrors()) {
         $exception = json_decode($response->raw_body);
         throw new \UnexpectedValueException(sprintf("API response raised a '%s' exception with a message: '%s'. Status code %s", $exception->name, $exception->message, $response->code));
     }
     return $instance;
 }

 public function delete($endpoint, $options = [])
 {
     $uri = Client::endpoint() . $endpoint . Client::getUriOptions($options);
     $response = \Httpful\Request::delete($uri)->authenticateWith(Client::key(), Client::secret())->addHeaders(Client::headers())->send();
     return $response;
 }

echo "response http status: " . $response->code . "\n\n";
echo "Teilinhalt der response: " . $response->body->createdPersonWithName . "\n\n";
// var_dump($response);
// ------------- der anfang des var_dump - outputs hier: ---------------------
// ["body"]=>
// object(stdClass)#14 (2) {
// ["func"]=>
// string(6) "create"
// ["createdPersonWithName"]=>
// string(4) "emma"
// }
// ["raw_body"]=>
// string(48) "{"func":"create","createdPersonWithName":"emma"}"
// ===================================================================
// PUT Request  (update single person)
// ===================================================================
$uri = "http://localhost/testapp/index.php/api/persons/emma";
$payload = array('attributeToBeUPdated' => 'newValue');
echo "\n\n================ PUT:  {$uri} \n";
$response = \Httpful\Request::put($uri)->sendsJson()->body($payload)->send();
// and finally, fire that thing off!
# var_dump($response);
echo "response http status: " . $response->code . "\n\n";
echo "Teilinhalt der response: " . $response->body->updatedPersonWithId . "\n\n";
// ===================================================================
// DELETE Request  (delete single person)
// ===================================================================
$uri = "http://localhost/testapp/index.php/api/persons/todelete";
echo "\n\n================ DELETE:  {$uri} \n";
$response = \Httpful\Request::delete($uri)->send();
echo "response http status: " . $response->code . "\n\n";

 /**
  * Delete a project run. This cancels a run if running, and deletes the run
  * and its data.
  * @param  string $run_token run token of a project run.
  * @return string            json response with run token that run was
  *                                deleted.
  */
 public function deleteProjectRun($run_token)
 {
     $url = $this->getProjectRunDeleteApiUrl($run_token);
     $api_key = self::$config['api_key'];
     $response = PHPHttpful::delete($url)->send();
     if ($this->isResponseValid($response)) {
         self::$logger->info("Project run deleted successfully on parsehub of run_token {$run_token}");
         $data = $response->body;
         return $data;
     }
 }