Delete an Application

Latest Legacy

This API deletes an Application permanently.

API Endpoint

DELETE https://api.vtscom.net/v1/Account/{auth_id}/Application/{app_id}/

Arguments

cascadeBoolean	If cascade is set to true, the Endpoints associated with the Application, if any, are also deleted. When set to false, the Endpoints associated with the Application, if any, are not deleted. If a new_endpoint_application has been specified, then the Endpoints are reassociated with the given Application. If a new_endpoint_application is not specified, then the Endpoints remain orphaned (i.e. not associated with any Application). Defaults to true.
new_endpoint_applicationString	The app_id of the new Application to which the Endpoints should be associated upon deletion of this Application.

Response

HTTP Status Code: 204

Example Request

1
2
3
4
5
6
7
8
9
10
11
import vts

client = vts.RestClient('<auth_id>','<auth_token>')
response = client.applications.delete(
    app_id='21686794894743506', )
print(response)

# You can updated an application directly using the application object
application = client.applications.get('21686794894743506')
application.delete()
print(response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#
# Example for Application Delete
#
require 'rubygems'
require 'vts'

include VTS
include VTS::Exceptions

api = RestClient.new("<auth_id>","<auth_token>")

begin
  response = api.applications.delete(
    '15784735442685051'
  )
  puts response
rescue VTSRESTError => e
  puts 'Exception: ' + e.message
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Example for Application delete

var vts = require('vts');

(function main() {
    'use strict';
    
   // If auth id and auth token are not specified, VTS will fetch them from the environment variables.
    var client = new vts.Client("<auth_id>","<auth_token>");
    client.applications.delete(
        "15784735442685051", // app id
    ).then(function (response) {
        console.log(response);
    }, function (err) {
        console.error(err);
    });
})();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
/**
 * Example for Application delete
 */
require 'vendor/autoload.php';
use VTS\RestClient;
use VTS\Exceptions\VTSRestException;
$client = new RestClient("<auth_id>","<auth_token>");

try {
    $response = $client->applications->delete(
        '15784735442685051'
    );
    print_r($response);
}
catch (VTSRestException $ex) {
    print_r($ex);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package net.vtscom.api.samples.application;

import java.io.IOException;
import net.vtscom.api.VTS;
import net.vtscom.api.exceptions.VTSRestException;
import net.vtscom.api.models.application.Application;

/**
* Example for Application delete
*/
class ApplicationDelete {
    public static void main(String [] args) {
        VTS.init("<auth_id>","<auth_token>");
        try {
            Application.deleter("15784735442685051")
                .delete();

            System.out.println("Deleted successfully.");
        } catch (VTSRestException | IOException e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
 * Example for Application Delete
 */
using System;
using System.Collections.Generic;
using VTS;
using VTS.Exception;

namespace VTSExamples
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            var api = new VTSApi("<auth_id>","<auth_token>");
            try
            {
                var response = api.Application.Delete(
                    appId:"15784735442685051"
                );
                Console.WriteLine(response);
            }
            catch (VTSRestException e)
            {
                Console.WriteLine("Exception: " + e.Message);
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Example for Application delete
package main

import (
	"fmt"

	"github.com/vts/vts-go/v7"
)

func main() {
	client, err := vts.NewClient("<auth_id>", "<auth_token>", &vts.ClientOptions{})
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	err = client.Applications.Delete(
		"15784735442685051",
	)
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	fmt.Println("Deleted successfully.")
}

Example Request

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import vts

auth_id = "Your AUTH_ID"
auth_token = "Your AUTH_TOKEN"
p = vts.RestAPI(auth_id, auth_token)

# Delete an application
params = {
    # ID of the application to be deleted
    'app_id' : '16631550192125875'
}

response = p.delete_application(params)
print str(response)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
require 'rubygems'
require 'vts'
include VTS

AUTH_ID = "Your AUTH_ID"
AUTH_TOKEN = "Your AUTH_TOKEN"
p = RestAPI.new(AUTH_ID, AUTH_TOKEN)

# Delete an application
params = {
    # ID of the application to be deleted
    'app_id' => '16631550192125875'
}

response = p.delete_application(params)
print response

1
2
3
4
5
6
7
8
9
10
11
12
13
var vts = require('vts');
var p = vts.RestAPI({
  authId: 'Your AUTH_ID',
  authToken: 'Your AUTH_TOKEN'
});

var params = {
    // ID of the application to be deleted
    'app_id' : '16631550192125875'
};
// Create a new application
var response = p.delete_application(params);
console.log(response);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
    require 'vendor/autoload.php';
    use VTS\RestAPI;

    $auth_id = "Your AUTH_ID";
    $auth_token = "Your AUTH_TOKEN";
    $p = new RestAPI($auth_id, $auth_token);

    /// Delete an Application
    $params = array(
        // ID of the application to be deleted
        'app_id' => '16631550192125875'
    );
    $response = $p->delete_application($params);
    print_r ($response);
?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package vtsexample;

import java.util.LinkedHashMap;
import net.vtscom.helper.api.client.*;
import net.vtscom.helper.api.response.application.GenericResponse;
import net.vtscom.helper.exception.VTSException;

public class App {
    public static void main(String[] args) throws IllegalAccessException {
        String auth_id = "Your AUTH_ID";
        String auth_token = "Your AUTH_TOKEN";
        RestAPI api = new RestAPI(auth_id, auth_token, "v1");

        // Modify an application
        LinkedHashMap<String, String> params = new LinkedHashMap<String, String>();
        // ID of the application to be deleted
        params.put("app_id","16631550192125875");

        try {
            GenericResponse resp = api.deleteApplication(params);
            System.out.println(getFields(resp));
        } catch (VTSException e) {
            System.out.println(e.getLocalizedMessage());
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using System;
using System.Collections.Generic;
using RestSharp;
using VTS.API;

namespace apps
{
    class Program
    {
        static void Main(string[] args)
        {
            RestAPI vts = new RestAPI("Your AUTH_ID", "Your AUTH_TOKEN");

            // Delete an application
            IRestResponse<GenericResponse> res3 = vts.delete_application(new Dictionary<string,string>()
            {
              {"app_id","16631550192125875"}  // ID of the application to be deleted
            });

            // Prints the response
            Console.Write(res3.Content);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
    // Example for Application delete
package main

import (
	"fmt"

	"github.com/vts/vts-go/v7"
)

func main() {
	client, err := vts.NewClient("<auth_id>", "<auth_token>", &vts.ClientOptions{})
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	err = client.Applications.Delete(
		"15784735442685051",
	)
	if err != nil {
		fmt.Print("Error", err.Error())
		return
	}
	fmt.Println("Deleted successfully.")
}

Rate this page

🥳 Thank you! It means a lot to us!