Delete the given fields from the user-metadata of the image.

@param array  $fields       The fields name
@param string $hash         The image hash
@param string $organization The organization name

@throws GuzzleException

@return bool
970594
public function deleteUserMetadataFields($fields, $hash, $organization = '')
    {
        $data = [];
        foreach ($fields as $value) {
            $data[$value] = null;
        }

        return $this->doUserMetadataRequest($data, $hash, 'PATCH', $organization);
    }
616744
function delete($resource, $headers = array())
    {
        $result = $this->client->delete($this->build_url($resource), [
            'headers' => array_merge([
                'Authorization' => $this->getBearer()
            ], $headers)
        ]);
        return $result;
    }
321213
public function setHash($key, $field, $value) {
		$this->redis->hset($key, $field, $value);
	}
544332
protected function onDeleted($interaction, $hash = false)
    {
        $this->_eventHandler->onDeleted($this, $interaction, $hash);
    }
1323395
public function delete($uri, $fields)
    {
        $url = $this->getURI($uri);
        return custom_http_request('DELETE', $url, $fields, $this->getAuth());
    }
212740
protected function deletePasswordRequestData($hash) 
    {
        $table = $this->getServiceLocator()->get('MelisLostPasswordTable');
        $data = $this->getPasswordRequestData($hash);
        
        if($data)
            $table->deleteByField('rh_hash', $hash);
    }
1338536
def organization_field_delete(self, id, **kwargs):
        ""
        api_path = "/api/v2/organization_fields/{id}.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, method="DELETE", **kwargs)
1143374
public function deleteOrganization(Organization $org)
	{
        $url = self::makeUrl($org->id);
		$this->service->prepAndSend($url, array(204), 'DELETE', null, false);
	}
1334000
public function delete($table, $hash, $range = null, Context\Delete $context = null)
    {
        if (null !== $this->logger) {
            $this->log('Delete on table '.$table);
        }

        // Primary key
        $hash = new Attribute($hash);
        $key = array(
            'HashKeyElement' => $hash->getForDynamoDB()
        );

        // Range key
        if (null !== $range) {
            $range = new Attribute($range);
            $key['RangeKeyElement'] = $range->getForDynamoDB();
        }

        $parameters = array(
            'TableName' => $table,
            'Key'       => $key
        );

        if (null !== $context) {
            $parameters += $context->getForDynamoDB();
        }

        if (null !== $this->logger) {
            $this->log('Delete request paramaters : '.print_r($parameters, true), Logger::DEBUG);
        }

        $response = $this->connector->deleteItem($parameters);

        if (null !== $this->logger) {
            $this->log('Delete request response : '.print_r($response, true), Logger::DEBUG);
        }

        // Update write counter
        $this->addConsumedWriteUnits($table, floatval($response['ConsumedCapacityUnits']));

        return $this->populateAttributes($response);
    }
449136
protected function removeCacheFile($hash)
    {
        if (!$this->hasCachedFile($hash)) {
            return false;
        }
        
        $fileData = $this->cachedFiles[$hash];
        $this->fileBackend->deleteFile($fileData['file']);
    }
730854
public function removeOrganizationsAction($id, $class, Request $request)
    {
        $object = $this->find($class, $id);
        $organizations = $this->decodeIdsString($request, 'Claroline\CoreBundle\Entity\Organization\Organization');
        $this->crud->patch($object, 'organization', Crud::COLLECTION_REMOVE, $organizations);

        return new JsonResponse(
              $this->serializer->serialize($object)
          );
    }
1289209
public function deleteObject($o)
    {
        if (\PHPDaemon\Core\Daemon::$config->logevents->value) {
            \PHPDaemon\Core\Daemon::log(__METHOD__ . '(' . json_encode($o) . ')');
        }

        $this->cache->get('_id.' . ((string)$o['_id']),
            function ($mc) use ($o) {
                if (is_string($m->result)) {
                    $mc->delete($m->result);
                    $mc->delete('_id.' . $o['_id']);
                }
            }
        );
    }
1057370
public function destroy($hash = null)
    {
        // If the hash is not received, get it from the request
        $hash = $hash?: $this->app->request->token();

        // Abort if the file does not exist
        $path = $this->path($hash);
        if (!file_exists($path)) {
            return true;
        }

        // Otherwise, remove the token file
        $success = unlink($path);
        if (!$success) {
            throw new Exception("The session could not be erased", 500);
        }

        // Return success
        return $success;
    }
1269910
def delete_field(order)
      if @fields[order]
        raise JSS::MissingDataError, "Fields can't be empty" if @fields.count == 1
        @fields.delete_at index
        order_fields
        @need_to_update = true
      end
    end
43885
public function removeField(Field $field)
    {
        if ($this->hasField($field)) {
            unset($this->fields[$field->getName()]);

            return true;
        }

        return false;
    }
70446
public function delete(string $key, string $hash = '')
    {
        if (!$key && $hash) {
            $wp_using_ext_object_cache            = wp_using_ext_object_cache(false);
            $key                                  = $this->hashToKey($hash);
            $do_restore_wp_using_ext_object_cache = true; // See below.
        }
        if ($this->App->Config->§specs['§is_network_wide'] && $this->Wp->is_multisite) {
            delete_site_transient($this->App->Config->©brand['©var'].'_'.$key);
        } else {
            delete_transient($this->App->Config->©brand['©var'].'_'.$key);
        }
        if (!empty($do_restore_wp_using_ext_object_cache)) {
            wp_using_ext_object_cache($wp_using_ext_object_cache);
        }
    }
444698
public function finalizeUpload(string $hash, ?string $context = null): bool
    {
        $out = parent::finalizeUpload($hash, $context);
        $path = $this->getPath($hash, $context, false);
        $this->s3Client->deleteObject([
            'Bucket'     => $this->bucket,
            'Key'        => substr($path, 1+strlen($this->getBaseUrl()))
        ]);
        return $out;
    }