DELETE /placements/1
 DELETE /placements/1.json
338601
def destroy
      @placement = Placement.find(params[:id])
      @placement.destroy
  
      respond_to do |format|
        format.html { redirect_to placements_url }
        format.json { head :no_content }
      end
    end
603878
def delete(options = {})
      options = options.merge(bucket: @bucket_name)
      resp = @client.delete_bucket_lifecycle(options)
      resp.data
    end
760509
function deleteOrganizationAttachedPolicy (params, cb) {
      let promise = null
      if (typeof cb !== 'function') [promise, cb] = asyncify()

      const { id, policyId, instance } = params
      const tasks = [
        (job, next) => {
          Joi.validate({ id, policyId, instance }, validationRules.deleteOrganizationPolicy, (err) => {
            if (err) return next(Boom.badRequest(err))
            next()
          })
        },
        (job, next) => {
          job.id = id
          job.policyId = policyId
          job.instance = instance

          next()
        },
        checkOrg,
        clearOrganizationAttachedPolicy
      ]

      db.withTransaction(tasks, (err, res) => {
        if (err) return cb(err)

        organizationOps.readById(id, cb)
      })

      return promise
    }
319287
def delete(url, options={}, &block)
      http_options = options.merge(@basic_options)
      if block_given?
        RestClient.delete(url, http_options, &block)
      else
        RestClient.delete(url, http_options)
      end
    end
509684
async function deleteDeploymentFolder() {
  del.sync(deploymentTmpFolder, { force: true });
  del.sync(deploymentFolder, { force: true });
}
1277284
function cleanup() {

  var ds = application.dataStore;

  //delete the application's directory.  This will auto-delete any contained accounts and groups:
  ds.getResource(application.defaultAccountStoreMapping.href, function(err, mapping) {
    if (err) throw err;

    console.log('Retrieved application accountStoreMapping for deletion:');
    console.log(mapping);

    ds.deleteResource(mapping.accountStore, function(err) {
      if(err) throw err;

      console.log('Deleted application directory.');

      application.delete(function(err) {
        if (err) throw err;
        console.log('Deleted application.');
      });
    });
  });
}
46015
function deleteAllOperations(req, res) {
	taskStore.getTasksForUser(req.user.username, function(err, tasks) {
		if (err) {
			return writeError(500, res, err.toString());
		}
		var locations = [];
		var doneCount = 0;
		var done = function() {
			if (!tasks.length || ++doneCount === tasks.length) {
				writeResponse(200, res, null, locations);
			}
		};
		if (!tasks.length) {
			done();
			return;
		}
		tasks.forEach(function(task) {
			if (task.result || task.Result) {
				// task in single user case doesn't have Location, it has keep instead
				taskStore.deleteTask(getTaskMeta(req, (task.Location && task.Location.substring(req.baseUrl.length)) || task.keep, task.id), done); /* task is completed */
			} else {
				locations.push(toJSON(task, true).Location);
				done();
			}
		});
	});
}
965619
def _delete(url, profile):
    ''''''
    request_url = "{0}/api/dashboards/{1}".format(profile.get('grafana_url'),
                                                  url)
    response = requests.delete(
        request_url,
        headers={
            "Accept": "application/json",
            "Authorization": "Bearer {0}".format(profile.get('grafana_token'))
        },
        timeout=profile.get('grafana_timeout'),
    )
    data = response.json()
    return data
349973
def delete(path: nil, payload: nil, headers: {}, query: {})
      execute(method: :delete, path: path, headers: headers, query: query, payload: payload)
    end
763474
function deleteOrganizationAttachedPolicies (params, cb) {
      let promise = null
      if (typeof cb !== 'function') [promise, cb] = asyncify()

      const { id } = params
      const tasks = [
        (job, next) => {
          Joi.validate({ id }, validationRules.deleteOrganizationPolicies, (err) => {
            if (err) return next(Boom.badRequest(err))
            next()
          })
        },
        (job, next) => {
          job.id = id

          next()
        },
        checkOrg,
        clearOrganizationAttachedPolicies
      ]

      db.withTransaction(tasks, (err, res) => {
        if (err) return cb(err)

        organizationOps.readById(id, cb)
      })

      return promise
    }
889313
def destroy
      @project = Project.find(params[:id])
      @project.destroy
  
      respond_to do |format|
        format.html { redirect_to projects_url }
        format.json { head :no_content }
      end
    end
42350
def delete(options = {})
      options = options.merge(
        account_id: @account_id,
        vault_name: @vault_name,
        archive_id: @id
      )
      resp = @client.delete_archive(options)
      resp.data
    end
903975
def delete_job(job_id,
               deployment_name,
               token_manager=None,
               app_url=defaults.APP_URL):
    
    headers = token_manager.get_access_token_headers()
    data_url = get_data_url_for_job(job_id,
                                    deployment_name,
                                    token_manager=token_manager,
                                    app_url=app_url)

    url = '%s/api/v1/jobs/%s' % (data_url, job_id)
    response = requests.delete(url, headers=headers)

    if response.status_code != 200:
        raise JutException('Error %s: %s' % (response.status_code, response.text))
409791
def delete(self, path, data=None, headers=None, params=None):
        
        self.request('DELETE', path=path, data=data, headers=headers, params=params)
1173710
def delete!(request_options = {})
      res = delete(request_options)
      wait_task(res['taskID'], WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY, request_options)
      res
    end
999155
def delete!
      Scripts.call(
        :delete,
        redis_pool,
        keys: [exists_key, grabbed_key, available_key, version_key, UNIQUE_SET, unique_digest],
      )
    end
1364413
function removePofile(done) {
            if (!self.userDir) return done(null);

            rimraf(self.userDir, done);
        }