Deletes the project associated with the ID
@param {string} projectId
@return {Promise<void>}
772374
function deleteProjectWithId(projectId) {
	return fetchProject(projectId)
	.then(deleteProject)
	.catch((error) => {
		console.trace(error);
		throw error;
	});
}
225757
public function delete(string $projectKey, string $keyId)
    {
        $response = $this->httpDelete(sprintf('/api/v2/projects/%s/keys/%s', $projectKey, $keyId));

        if (!$this->hydrator) {
            return $response;
        }

        if ($response->getStatusCode() !== 204) {
            $this->handleErrors($response);
        }

        return true;
    }
1036628
public function setProjectId($projectId = '')
    {
        $this->projectId = $projectId;
        $this->_debug->info(__FUNCTION__, 'setProjectId: ', $this->projectId);
    }
46192
def removeforkrelation(self, project_id):
        
        request = requests.delete(
            '{0}/{1}/fork'.format(self.projects_url, project_id),
            headers=self.headers, verify=self.verify_ssl,
            auth=self.auth, timeout=self.timeout)

        if request.status_code == 200:
            return True
        else:
            return False
692671
public Observable<ServiceResponse<Void>> deleteProjectWithServiceResponseAsync(UUID projectId) {
        if (projectId == null) {
            throw new IllegalArgumentException("Parameter projectId is required and cannot be null.");
        }
        if (this.client.apiKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiKey() is required and cannot be null.");
        }
        return service.deleteProject(projectId, this.client.apiKey(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = deleteProjectDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
492319
public Project getProject(final int id) {
    Project fetchedProject = this.projectsById.get(id);
    if (fetchedProject == null) {
      try {
        fetchedProject = this.projectLoader.fetchProjectById(id);
      } catch (final ProjectManagerException e) {
        logger.error("Could not load project from store.", e);
      }
    }
    return fetchedProject;
  }
967170
def delete_project():
    
    assert request.method == "POST", "POST request expected received {}".format(request.method)
    if request.method == "POST":
        try:
            selections = json.loads(request.form["selections"])
            utils.drop_project(selections["project"])
            return jsonify({"response": "deleted {}".format(selections["project"])})
        except Exception as e:
            logging.error(e)
    return jsonify({"0": "__EMPTY"})
1183503
function(id) {
    if(this.hasNode(id)) {
      delete this.nodes[id];
      var adjs = this.edges[id];
      for(var to in adjs) {
        delete this.edges[to][id];
      }
      delete this.edges[id];
    }
  }
988026
public int deleteProjectPermissionOfAnyUser(DbSession dbSession, long projectId, String permission) {
    return mapper(dbSession).deleteProjectPermissionOfAnyUser(projectId, permission);
  }
619627
public AzkabanClientStatus deleteProject(String projectName) throws AzkabanClientException {

    AzkabanMultiCallables.DeleteProjectCallable callable =
        AzkabanMultiCallables.DeleteProjectCallable.builder()
            .client(this)
            .projectName(projectName)
            .build();

    return runWithRetry(callable, AzkabanClientStatus.class);
  }
1187383
function(apiId, stageName) {
        return new Promise(function(resolve, reject) {
            APIG.deleteStage({
                restApiId: apiId,
                stageName: stageName
            }, function(err) {
                if (err) {
                    // If no such stage, then success
                    if (err.code === 404 || err.code === 'NotFoundException') {
                        return resolve(apiId);
                    }

                    return reject(err);
                }

                resolve(apiId);
            });
        });
    }
110535
def delete_intent(project_id, intent_id):
    """"""
    import dialogflow_v2 as dialogflow
    intents_client = dialogflow.IntentsClient()

    intent_path = intents_client.intent_path(project_id, intent_id)

    intents_client.delete_intent(intent_path)
1222378
function checkProjectCompilationWithId(projectId, platform) {
	return fetchProject(projectId)
	.then((project) => {
		return checkProjectCompilation(project, platform);
	})
	.catch((error) => {
		console.trace(error);
		throw error;
	});
}
3112
public function delete($projectId)
    {
        $this->requireAdmin();

        $project = $this->projectStore->getById($projectId);
        $this->projectService->deleteProject($project);

        $response = new b8\Http\Response\RedirectResponse();
        $response->setHeader('Location', PHPCI_URL);
        return $response;
    }
1347098
public Observable<Void> deleteIterationAsync(UUID projectId, UUID iterationId) {
        return deleteIterationWithServiceResponseAsync(projectId, iterationId).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }
1097196
@PostMapping("/removeMappingProject")
  public String deleteMappingProject(@RequestParam() String mappingProjectId) {
    MappingProject project = mappingService.getMappingProject(mappingProjectId);
    LOG.info("Deleting mappingProject {}", project.getName());
    mappingService.deleteMappingProject(mappingProjectId);
    return "redirect:" + getMappingServiceMenuUrl();
  }
139412
public function deleteAvatar($projectId, $avatarId)
    {
        return $this->apiClient->callEndpoint(
            sprintf('%s/%s/avatar/%s', self::ENDPOINT, $projectId, $avatarId),
            array(),
            null,
            HttpMethod::REQUEST_DELETE
        );
    }