DELETE /apis/1
 DELETE /apis/1.json
559025
def destroy
      @project = Project.find params[:project_id]
      @api = @project.apis.find(params[:id])
      @api.destroy
  
      respond_to do |format|
        format.html { redirect_to project_apis_path }
        format.json { head :no_content }
      end
    end
1135305
def delete_custom_public_read_api(
        request,
        database_name,
        collection_name,
        slug):
    """"""
    ss = get_object_or_404(CustomPublicReadAPI, datbase_name=database_name,
                           collection_name=collection_name, slug=slug)
    ss.delete()
    messages.success(request, _("Custom Public Read API deleted."))
    return HttpResponseRedirect(
        reverse('djmongo_show_apis',
                args=(ss.database_name, ss.collection_name)))
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
1220602
def delete(self, ids):
        
        url = build_uri_with_ids('api/v4/as/%s/', ids)
        return super(ApiV4As, self).delete(url)
566550
def delete(options = {})
      options = options.merge(stack_id: @id)
      resp = @client.delete_stack(options)
      resp.data
    end
271272
def delete(self, endpoint, json=None, params=None, **kwargs):
        
        json = kwargs['data'] if 'data' in kwargs else json
        return self._make_request('delete', endpoint, data=json, params=params)
662611
def delete_api(awsclient, api_name):
    
    _sleep()
    client_api = awsclient.get_client('apigateway')

    print('deleting api: %s' % api_name)
    api = _api_by_name(awsclient, api_name)

    if api is not None:
        print(json2table(api))

        response = client_api.delete_rest_api(
            restApiId=api['id']
        )

        print(json2table(response))
    else:
        print('API name unknown')
903811
def delete(path, body = nil, params = {}, headers = {}, auth = true)
      request(http_method: :delete, path: path, body: body, query: params, headers: headers, auth: auth)
    end
1099783
def delete(path, params = {})
      headers = request_headers(:delete, path, params)
      request(:delete, path, params, headers)
    end
349973
def delete(path: nil, payload: nil, headers: {}, query: {})
      execute(method: :delete, path: path, headers: headers, query: query, payload: payload)
    end
670688
def delete_simple_public_read_api(
        request,
        database_name,
        collection_name,
        slug):
    """"""
    ss = get_object_or_404(PublicReadAPI, database_name=database_name,
                           collection_name=collection_name, slug=slug)
    ss.delete()
    messages.success(request, _("Simple Public Read API deleted."))
    return HttpResponseRedirect(
        reverse('djmongo_show_apis',
                args=(ss.database_name, ss.collection_name)))
1111988
def delete(alias_value, platform = nil)
      params = platform.nil? ? nil : { platform: build_platform(platform) }
      url = base_url + alias_value
      Http::Client.delete(@jpush, url, params: params)
    end
419944
def remove(cls, name):
        

        api = Client.instance().api

        api.collection(name).delete()
1017809
def clean():
        
        shutil.rmtree(BUILD_PATH, ignore_errors=True)
        shutil.rmtree(os.path.join(SOURCE_PATH, 'reference', 'api'),
                      ignore_errors=True)
27898
function destroy(req, res, next) {
  db.users.del(req.params.user, function(err) {
    if(err) { return next(err); }
    res.json(null);
  });
}
1314903
def _cleanup_api(self):
        '''
        
        '''
        resources = __salt__['boto_apigateway.describe_api_resources'](restApiId=self.restApiId,
                                                                       **self._common_aws_args)
        if resources.get('resources'):
            res = resources.get('resources')[1:]
            res.reverse()
            for resource in res:
                delres = __salt__['boto_apigateway.delete_api_resources'](restApiId=self.restApiId,
                                                                          path=resource.get('path'),
                                                                          **self._common_aws_args)
                if not delres.get('deleted'):
                    return delres

        models = __salt__['boto_apigateway.describe_api_models'](restApiId=self.restApiId, **self._common_aws_args)
        if models.get('models'):
            for model in models.get('models'):
                delres = __salt__['boto_apigateway.delete_api_model'](restApiId=self.restApiId,
                                                                      modelName=model.get('name'),
                                                                      **self._common_aws_args)
                if not delres.get('deleted'):
                    return delres

        return {'deleted': True}
938265
def api_delete(service, file_id, owner_token):
    """"""
    service += 'api/delete/%s' % file_id
    r = requests.post(service, json={'owner_token': owner_token, 'delete_token': owner_token})
    r.raise_for_status()

    if r.text == 'OK':
        return True
    return False