Gleanview API

Accounts

Account Model

Create Account

Create a new account


/accounts

Usage and SDK Samples

curl -X POST "https://api-beta.gleanview.com/v1/accounts"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AccountsApi;

import java.io.File;
import java.util.*;

public class AccountsApiExample {

    public static void main(String[] args) {
        
        AccountsApi apiInstance = new AccountsApi();
        String apiToken = apiToken_example; // String | 
        Body body = ; // Body | Formatted json object
        try {
            apiInstance.createAccount(apiToken, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#createAccount");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AccountsApi;

public class AccountsApiExample {

    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String apiToken = apiToken_example; // String | 
        Body body = ; // Body | Formatted json object
        try {
            apiInstance.createAccount(apiToken, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#createAccount");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
Body *body = ; // Formatted json object

AccountsApi *apiInstance = [[AccountsApi alloc] init];

// Create a new account
[apiInstance createAccountWith:apiToken
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.AccountsApi()

var apiToken = apiToken_example; // {String} 

var body = ; // {Body} Formatted json object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createAccount(apiToken, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createAccountExample
    {
        public void main()
        {
            
            var apiInstance = new AccountsApi();
            var apiToken = apiToken_example;  // String | 
            var body = new Body(); // Body | Formatted json object

            try
            {
                // Create a new account
                apiInstance.createAccount(apiToken, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountsApi.createAccount: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AccountsApi();
$apiToken = apiToken_example; // String | 
$body = ; // Body | Formatted json object

try {
    $api_instance->createAccount($apiToken, $body);
} catch (Exception $e) {
    echo 'Exception when calling AccountsApi->createAccount: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountsApi;

my $api_instance = WWW::SwaggerClient::AccountsApi->new();
my $apiToken = apiToken_example; # String | 
my $body = WWW::SwaggerClient::Object::Body->new(); # Body | Formatted json object

eval { 
    $api_instance->createAccount(apiToken => $apiToken, body => $body);
};
if ($@) {
    warn "Exception when calling AccountsApi->createAccount: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AccountsApi()
apiToken = apiToken_example # String | 
body =  # Body | Formatted json object

try: 
    # Create a new account
    api_instance.create_account(apiToken, body)
except ApiException as e:
    print("Exception when calling AccountsApi->createAccount: %s\n" % e)

Parameters

Header parameters
Name Description
Api-Token*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Successful creation

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Delete Account

Delete an existing account


/accounts/{account_id}

Usage and SDK Samples

curl -X DELETE "https://api-beta.gleanview.com/v1/accounts/{account_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AccountsApi;

import java.io.File;
import java.util.*;

public class AccountsApiExample {

    public static void main(String[] args) {
        
        AccountsApi apiInstance = new AccountsApi();
        String apiToken = apiToken_example; // String | 
        UUID accountId = accountId_example; // UUID | Account id to delete
        try {
            apiInstance.deleteAccount(apiToken, accountId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#deleteAccount");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AccountsApi;

public class AccountsApiExample {

    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String apiToken = apiToken_example; // String | 
        UUID accountId = accountId_example; // UUID | Account id to delete
        try {
            apiInstance.deleteAccount(apiToken, accountId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#deleteAccount");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *accountId = accountId_example; // Account id to delete

AccountsApi *apiInstance = [[AccountsApi alloc] init];

// Delete an existing account
[apiInstance deleteAccountWith:apiToken
    accountId:accountId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.AccountsApi()

var apiToken = apiToken_example; // {String} 

var accountId = accountId_example; // {UUID} Account id to delete


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteAccount(apiToken, accountId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteAccountExample
    {
        public void main()
        {
            
            var apiInstance = new AccountsApi();
            var apiToken = apiToken_example;  // String | 
            var accountId = accountId_example;  // UUID | Account id to delete

            try
            {
                // Delete an existing account
                apiInstance.deleteAccount(apiToken, accountId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountsApi.deleteAccount: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AccountsApi();
$apiToken = apiToken_example; // String | 
$accountId = accountId_example; // UUID | Account id to delete

try {
    $api_instance->deleteAccount($apiToken, $accountId);
} catch (Exception $e) {
    echo 'Exception when calling AccountsApi->deleteAccount: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountsApi;

my $api_instance = WWW::SwaggerClient::AccountsApi->new();
my $apiToken = apiToken_example; # String | 
my $accountId = accountId_example; # UUID | Account id to delete

eval { 
    $api_instance->deleteAccount(apiToken => $apiToken, accountId => $accountId);
};
if ($@) {
    warn "Exception when calling AccountsApi->deleteAccount: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AccountsApi()
apiToken = apiToken_example # String | 
accountId = accountId_example # UUID | Account id to delete

try: 
    # Delete an existing account
    api_instance.delete_account(apiToken, accountId)
except ApiException as e:
    print("Exception when calling AccountsApi->deleteAccount: %s\n" % e)

Parameters

Path parameters
Name Description
account_id*
UUID (uuid)
Account id to delete
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful deletion

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


List Accounts

List all client accounts


/accounts

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/accounts"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AccountsApi;

import java.io.File;
import java.util.*;

public class AccountsApiExample {

    public static void main(String[] args) {
        
        AccountsApi apiInstance = new AccountsApi();
        String apiToken = apiToken_example; // String | 
        try {
            inline_response_200 result = apiInstance.listAccounts(apiToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#listAccounts");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AccountsApi;

public class AccountsApiExample {

    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String apiToken = apiToken_example; // String | 
        try {
            inline_response_200 result = apiInstance.listAccounts(apiToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#listAccounts");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 

AccountsApi *apiInstance = [[AccountsApi alloc] init];

// List all client accounts
[apiInstance listAccountsWith:apiToken
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.AccountsApi()

var apiToken = apiToken_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listAccounts(apiToken, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listAccountsExample
    {
        public void main()
        {
            
            var apiInstance = new AccountsApi();
            var apiToken = apiToken_example;  // String | 

            try
            {
                // List all client accounts
                inline_response_200 result = apiInstance.listAccounts(apiToken);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountsApi.listAccounts: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AccountsApi();
$apiToken = apiToken_example; // String | 

try {
    $result = $api_instance->listAccounts($apiToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountsApi->listAccounts: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountsApi;

my $api_instance = WWW::SwaggerClient::AccountsApi->new();
my $apiToken = apiToken_example; # String | 

eval { 
    my $result = $api_instance->listAccounts(apiToken => $apiToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->listAccounts: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AccountsApi()
apiToken = apiToken_example # String | 

try: 
    # List all client accounts
    api_response = api_instance.list_accounts(apiToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->listAccounts: %s\n" % e)

Parameters

Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Show Account

Show a single account


/accounts/{account_id}

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/accounts/{account_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AccountsApi;

import java.io.File;
import java.util.*;

public class AccountsApiExample {

    public static void main(String[] args) {
        
        AccountsApi apiInstance = new AccountsApi();
        String apiToken = apiToken_example; // String | 
        UUID accountId = accountId_example; // UUID | Account id to fetch
        try {
            inline_response_200 result = apiInstance.showAccount(apiToken, accountId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#showAccount");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AccountsApi;

public class AccountsApiExample {

    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String apiToken = apiToken_example; // String | 
        UUID accountId = accountId_example; // UUID | Account id to fetch
        try {
            inline_response_200 result = apiInstance.showAccount(apiToken, accountId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#showAccount");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *accountId = accountId_example; // Account id to fetch

AccountsApi *apiInstance = [[AccountsApi alloc] init];

// Show a single account
[apiInstance showAccountWith:apiToken
    accountId:accountId
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.AccountsApi()

var apiToken = apiToken_example; // {String} 

var accountId = accountId_example; // {UUID} Account id to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.showAccount(apiToken, accountId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class showAccountExample
    {
        public void main()
        {
            
            var apiInstance = new AccountsApi();
            var apiToken = apiToken_example;  // String | 
            var accountId = accountId_example;  // UUID | Account id to fetch

            try
            {
                // Show a single account
                inline_response_200 result = apiInstance.showAccount(apiToken, accountId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountsApi.showAccount: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AccountsApi();
$apiToken = apiToken_example; // String | 
$accountId = accountId_example; // UUID | Account id to fetch

try {
    $result = $api_instance->showAccount($apiToken, $accountId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountsApi->showAccount: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountsApi;

my $api_instance = WWW::SwaggerClient::AccountsApi->new();
my $apiToken = apiToken_example; # String | 
my $accountId = accountId_example; # UUID | Account id to fetch

eval { 
    my $result = $api_instance->showAccount(apiToken => $apiToken, accountId => $accountId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsApi->showAccount: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AccountsApi()
apiToken = apiToken_example # String | 
accountId = accountId_example # UUID | Account id to fetch

try: 
    # Show a single account
    api_response = api_instance.show_account(apiToken, accountId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsApi->showAccount: %s\n" % e)

Parameters

Path parameters
Name Description
account_id*
UUID (uuid)
Account id to fetch
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Update Account

Update an existing account


/accounts/{account_id}

Usage and SDK Samples

curl -X PUT "https://api-beta.gleanview.com/v1/accounts/{account_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AccountsApi;

import java.io.File;
import java.util.*;

public class AccountsApiExample {

    public static void main(String[] args) {
        
        AccountsApi apiInstance = new AccountsApi();
        String apiToken = apiToken_example; // String | 
        UUID accountId = accountId_example; // UUID | Account id to update
        Body_1 body = ; // Body_1 | Formatted json object
        try {
            apiInstance.updateAccount(apiToken, accountId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#updateAccount");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AccountsApi;

public class AccountsApiExample {

    public static void main(String[] args) {
        AccountsApi apiInstance = new AccountsApi();
        String apiToken = apiToken_example; // String | 
        UUID accountId = accountId_example; // UUID | Account id to update
        Body_1 body = ; // Body_1 | Formatted json object
        try {
            apiInstance.updateAccount(apiToken, accountId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsApi#updateAccount");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *accountId = accountId_example; // Account id to update
Body_1 *body = ; // Formatted json object

AccountsApi *apiInstance = [[AccountsApi alloc] init];

// Update an existing account
[apiInstance updateAccountWith:apiToken
    accountId:accountId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.AccountsApi()

var apiToken = apiToken_example; // {String} 

var accountId = accountId_example; // {UUID} Account id to update

var body = ; // {Body_1} Formatted json object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateAccount(apiToken, accountId, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateAccountExample
    {
        public void main()
        {
            
            var apiInstance = new AccountsApi();
            var apiToken = apiToken_example;  // String | 
            var accountId = accountId_example;  // UUID | Account id to update
            var body = new Body_1(); // Body_1 | Formatted json object

            try
            {
                // Update an existing account
                apiInstance.updateAccount(apiToken, accountId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountsApi.updateAccount: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AccountsApi();
$apiToken = apiToken_example; // String | 
$accountId = accountId_example; // UUID | Account id to update
$body = ; // Body_1 | Formatted json object

try {
    $api_instance->updateAccount($apiToken, $accountId, $body);
} catch (Exception $e) {
    echo 'Exception when calling AccountsApi->updateAccount: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AccountsApi;

my $api_instance = WWW::SwaggerClient::AccountsApi->new();
my $apiToken = apiToken_example; # String | 
my $accountId = accountId_example; # UUID | Account id to update
my $body = WWW::SwaggerClient::Object::Body_1->new(); # Body_1 | Formatted json object

eval { 
    $api_instance->updateAccount(apiToken => $apiToken, accountId => $accountId, body => $body);
};
if ($@) {
    warn "Exception when calling AccountsApi->updateAccount: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AccountsApi()
apiToken = apiToken_example # String | 
accountId = accountId_example # UUID | Account id to update
body =  # Body_1 | Formatted json object

try: 
    # Update an existing account
    api_instance.update_account(apiToken, accountId, body)
except ApiException as e:
    print("Exception when calling AccountsApi->updateAccount: %s\n" % e)

Parameters

Path parameters
Name Description
account_id*
UUID (uuid)
Account id to update
Required
Header parameters
Name Description
Api-Token*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Successful update

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Calls

Call Model

Create Call

Create a new call


/calls

Usage and SDK Samples

curl -X POST "https://api-beta.gleanview.com/v1/calls"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CallsApi;

import java.io.File;
import java.util.*;

public class CallsApiExample {

    public static void main(String[] args) {
        
        CallsApi apiInstance = new CallsApi();
        String apiToken = apiToken_example; // String | 
        Body_2 body = ; // Body_2 | Formatted json object
        try {
            apiInstance.createCall(apiToken, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallsApi#createCall");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CallsApi;

public class CallsApiExample {

    public static void main(String[] args) {
        CallsApi apiInstance = new CallsApi();
        String apiToken = apiToken_example; // String | 
        Body_2 body = ; // Body_2 | Formatted json object
        try {
            apiInstance.createCall(apiToken, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallsApi#createCall");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
Body_2 *body = ; // Formatted json object

CallsApi *apiInstance = [[CallsApi alloc] init];

// Create a new call
[apiInstance createCallWith:apiToken
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.CallsApi()

var apiToken = apiToken_example; // {String} 

var body = ; // {Body_2} Formatted json object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createCall(apiToken, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createCallExample
    {
        public void main()
        {
            
            var apiInstance = new CallsApi();
            var apiToken = apiToken_example;  // String | 
            var body = new Body_2(); // Body_2 | Formatted json object

            try
            {
                // Create a new call
                apiInstance.createCall(apiToken, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CallsApi.createCall: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CallsApi();
$apiToken = apiToken_example; // String | 
$body = ; // Body_2 | Formatted json object

try {
    $api_instance->createCall($apiToken, $body);
} catch (Exception $e) {
    echo 'Exception when calling CallsApi->createCall: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CallsApi;

my $api_instance = WWW::SwaggerClient::CallsApi->new();
my $apiToken = apiToken_example; # String | 
my $body = WWW::SwaggerClient::Object::Body_2->new(); # Body_2 | Formatted json object

eval { 
    $api_instance->createCall(apiToken => $apiToken, body => $body);
};
if ($@) {
    warn "Exception when calling CallsApi->createCall: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CallsApi()
apiToken = apiToken_example # String | 
body =  # Body_2 | Formatted json object

try: 
    # Create a new call
    api_instance.create_call(apiToken, body)
except ApiException as e:
    print("Exception when calling CallsApi->createCall: %s\n" % e)

Parameters

Header parameters
Name Description
Api-Token*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Successful creation

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Delete Call

Delete an existing call


/calls/{call_id}

Usage and SDK Samples

curl -X DELETE "https://api-beta.gleanview.com/v1/calls/{call_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CallsApi;

import java.io.File;
import java.util.*;

public class CallsApiExample {

    public static void main(String[] args) {
        
        CallsApi apiInstance = new CallsApi();
        String apiToken = apiToken_example; // String | 
        UUID callId = callId_example; // UUID | Call id to delete
        try {
            apiInstance.deleteCall(apiToken, callId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallsApi#deleteCall");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CallsApi;

public class CallsApiExample {

    public static void main(String[] args) {
        CallsApi apiInstance = new CallsApi();
        String apiToken = apiToken_example; // String | 
        UUID callId = callId_example; // UUID | Call id to delete
        try {
            apiInstance.deleteCall(apiToken, callId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallsApi#deleteCall");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *callId = callId_example; // Call id to delete

CallsApi *apiInstance = [[CallsApi alloc] init];

// Delete an existing call
[apiInstance deleteCallWith:apiToken
    callId:callId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.CallsApi()

var apiToken = apiToken_example; // {String} 

var callId = callId_example; // {UUID} Call id to delete


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteCall(apiToken, callId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteCallExample
    {
        public void main()
        {
            
            var apiInstance = new CallsApi();
            var apiToken = apiToken_example;  // String | 
            var callId = callId_example;  // UUID | Call id to delete

            try
            {
                // Delete an existing call
                apiInstance.deleteCall(apiToken, callId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CallsApi.deleteCall: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CallsApi();
$apiToken = apiToken_example; // String | 
$callId = callId_example; // UUID | Call id to delete

try {
    $api_instance->deleteCall($apiToken, $callId);
} catch (Exception $e) {
    echo 'Exception when calling CallsApi->deleteCall: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CallsApi;

my $api_instance = WWW::SwaggerClient::CallsApi->new();
my $apiToken = apiToken_example; # String | 
my $callId = callId_example; # UUID | Call id to delete

eval { 
    $api_instance->deleteCall(apiToken => $apiToken, callId => $callId);
};
if ($@) {
    warn "Exception when calling CallsApi->deleteCall: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CallsApi()
apiToken = apiToken_example # String | 
callId = callId_example # UUID | Call id to delete

try: 
    # Delete an existing call
    api_instance.delete_call(apiToken, callId)
except ApiException as e:
    print("Exception when calling CallsApi->deleteCall: %s\n" % e)

Parameters

Path parameters
Name Description
call_id*
UUID (uuid)
Call id to delete
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful deletion

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


List Calls

List all client calls


/calls

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/calls"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CallsApi;

import java.io.File;
import java.util.*;

public class CallsApiExample {

    public static void main(String[] args) {
        
        CallsApi apiInstance = new CallsApi();
        String apiToken = apiToken_example; // String | 
        try {
            inline_response_200 result = apiInstance.listCalls(apiToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallsApi#listCalls");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CallsApi;

public class CallsApiExample {

    public static void main(String[] args) {
        CallsApi apiInstance = new CallsApi();
        String apiToken = apiToken_example; // String | 
        try {
            inline_response_200 result = apiInstance.listCalls(apiToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallsApi#listCalls");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 

CallsApi *apiInstance = [[CallsApi alloc] init];

// List all client calls
[apiInstance listCallsWith:apiToken
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.CallsApi()

var apiToken = apiToken_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listCalls(apiToken, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listCallsExample
    {
        public void main()
        {
            
            var apiInstance = new CallsApi();
            var apiToken = apiToken_example;  // String | 

            try
            {
                // List all client calls
                inline_response_200 result = apiInstance.listCalls(apiToken);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CallsApi.listCalls: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CallsApi();
$apiToken = apiToken_example; // String | 

try {
    $result = $api_instance->listCalls($apiToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CallsApi->listCalls: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CallsApi;

my $api_instance = WWW::SwaggerClient::CallsApi->new();
my $apiToken = apiToken_example; # String | 

eval { 
    my $result = $api_instance->listCalls(apiToken => $apiToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CallsApi->listCalls: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CallsApi()
apiToken = apiToken_example # String | 

try: 
    # List all client calls
    api_response = api_instance.list_calls(apiToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CallsApi->listCalls: %s\n" % e)

Parameters

Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Show Call

Show a single call


/calls/{call_id}

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/calls/{call_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CallsApi;

import java.io.File;
import java.util.*;

public class CallsApiExample {

    public static void main(String[] args) {
        
        CallsApi apiInstance = new CallsApi();
        String apiToken = apiToken_example; // String | 
        UUID callId = callId_example; // UUID | Call id to fetch
        try {
            inline_response_200 result = apiInstance.showCall(apiToken, callId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallsApi#showCall");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CallsApi;

public class CallsApiExample {

    public static void main(String[] args) {
        CallsApi apiInstance = new CallsApi();
        String apiToken = apiToken_example; // String | 
        UUID callId = callId_example; // UUID | Call id to fetch
        try {
            inline_response_200 result = apiInstance.showCall(apiToken, callId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallsApi#showCall");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *callId = callId_example; // Call id to fetch

CallsApi *apiInstance = [[CallsApi alloc] init];

// Show a single call
[apiInstance showCallWith:apiToken
    callId:callId
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.CallsApi()

var apiToken = apiToken_example; // {String} 

var callId = callId_example; // {UUID} Call id to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.showCall(apiToken, callId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class showCallExample
    {
        public void main()
        {
            
            var apiInstance = new CallsApi();
            var apiToken = apiToken_example;  // String | 
            var callId = callId_example;  // UUID | Call id to fetch

            try
            {
                // Show a single call
                inline_response_200 result = apiInstance.showCall(apiToken, callId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CallsApi.showCall: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CallsApi();
$apiToken = apiToken_example; // String | 
$callId = callId_example; // UUID | Call id to fetch

try {
    $result = $api_instance->showCall($apiToken, $callId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CallsApi->showCall: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CallsApi;

my $api_instance = WWW::SwaggerClient::CallsApi->new();
my $apiToken = apiToken_example; # String | 
my $callId = callId_example; # UUID | Call id to fetch

eval { 
    my $result = $api_instance->showCall(apiToken => $apiToken, callId => $callId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CallsApi->showCall: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CallsApi()
apiToken = apiToken_example # String | 
callId = callId_example # UUID | Call id to fetch

try: 
    # Show a single call
    api_response = api_instance.show_call(apiToken, callId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CallsApi->showCall: %s\n" % e)

Parameters

Path parameters
Name Description
call_id*
UUID (uuid)
Call id to fetch
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Show User Calls

Show a single user's calls


/calls/users/{user_id}

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/calls/users/{user_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CallsApi;

import java.io.File;
import java.util.*;

public class CallsApiExample {

    public static void main(String[] args) {
        
        CallsApi apiInstance = new CallsApi();
        String apiToken = apiToken_example; // String | 
        UUID userId = userId_example; // UUID | User id of calls to fetch
        try {
            inline_response_200 result = apiInstance.showUserCalls(apiToken, userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallsApi#showUserCalls");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CallsApi;

public class CallsApiExample {

    public static void main(String[] args) {
        CallsApi apiInstance = new CallsApi();
        String apiToken = apiToken_example; // String | 
        UUID userId = userId_example; // UUID | User id of calls to fetch
        try {
            inline_response_200 result = apiInstance.showUserCalls(apiToken, userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallsApi#showUserCalls");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *userId = userId_example; // User id of calls to fetch

CallsApi *apiInstance = [[CallsApi alloc] init];

// Show a single user's calls
[apiInstance showUserCallsWith:apiToken
    userId:userId
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.CallsApi()

var apiToken = apiToken_example; // {String} 

var userId = userId_example; // {UUID} User id of calls to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.showUserCalls(apiToken, userId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class showUserCallsExample
    {
        public void main()
        {
            
            var apiInstance = new CallsApi();
            var apiToken = apiToken_example;  // String | 
            var userId = userId_example;  // UUID | User id of calls to fetch

            try
            {
                // Show a single user's calls
                inline_response_200 result = apiInstance.showUserCalls(apiToken, userId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CallsApi.showUserCalls: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CallsApi();
$apiToken = apiToken_example; // String | 
$userId = userId_example; // UUID | User id of calls to fetch

try {
    $result = $api_instance->showUserCalls($apiToken, $userId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CallsApi->showUserCalls: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CallsApi;

my $api_instance = WWW::SwaggerClient::CallsApi->new();
my $apiToken = apiToken_example; # String | 
my $userId = userId_example; # UUID | User id of calls to fetch

eval { 
    my $result = $api_instance->showUserCalls(apiToken => $apiToken, userId => $userId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CallsApi->showUserCalls: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CallsApi()
apiToken = apiToken_example # String | 
userId = userId_example # UUID | User id of calls to fetch

try: 
    # Show a single user's calls
    api_response = api_instance.show_user_calls(apiToken, userId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CallsApi->showUserCalls: %s\n" % e)

Parameters

Path parameters
Name Description
user_id*
UUID (uuid)
User id of calls to fetch
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Update Call

Update an existing call


/calls/{call_id}

Usage and SDK Samples

curl -X PUT "https://api-beta.gleanview.com/v1/calls/{call_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CallsApi;

import java.io.File;
import java.util.*;

public class CallsApiExample {

    public static void main(String[] args) {
        
        CallsApi apiInstance = new CallsApi();
        String apiToken = apiToken_example; // String | 
        UUID callId = callId_example; // UUID | Call id to update
        Body_3 body = ; // Body_3 | Formatted json object
        try {
            apiInstance.updateCall(apiToken, callId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallsApi#updateCall");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CallsApi;

public class CallsApiExample {

    public static void main(String[] args) {
        CallsApi apiInstance = new CallsApi();
        String apiToken = apiToken_example; // String | 
        UUID callId = callId_example; // UUID | Call id to update
        Body_3 body = ; // Body_3 | Formatted json object
        try {
            apiInstance.updateCall(apiToken, callId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CallsApi#updateCall");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *callId = callId_example; // Call id to update
Body_3 *body = ; // Formatted json object

CallsApi *apiInstance = [[CallsApi alloc] init];

// Update an existing call
[apiInstance updateCallWith:apiToken
    callId:callId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.CallsApi()

var apiToken = apiToken_example; // {String} 

var callId = callId_example; // {UUID} Call id to update

var body = ; // {Body_3} Formatted json object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateCall(apiToken, callId, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateCallExample
    {
        public void main()
        {
            
            var apiInstance = new CallsApi();
            var apiToken = apiToken_example;  // String | 
            var callId = callId_example;  // UUID | Call id to update
            var body = new Body_3(); // Body_3 | Formatted json object

            try
            {
                // Update an existing call
                apiInstance.updateCall(apiToken, callId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CallsApi.updateCall: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CallsApi();
$apiToken = apiToken_example; // String | 
$callId = callId_example; // UUID | Call id to update
$body = ; // Body_3 | Formatted json object

try {
    $api_instance->updateCall($apiToken, $callId, $body);
} catch (Exception $e) {
    echo 'Exception when calling CallsApi->updateCall: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CallsApi;

my $api_instance = WWW::SwaggerClient::CallsApi->new();
my $apiToken = apiToken_example; # String | 
my $callId = callId_example; # UUID | Call id to update
my $body = WWW::SwaggerClient::Object::Body_3->new(); # Body_3 | Formatted json object

eval { 
    $api_instance->updateCall(apiToken => $apiToken, callId => $callId, body => $body);
};
if ($@) {
    warn "Exception when calling CallsApi->updateCall: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CallsApi()
apiToken = apiToken_example # String | 
callId = callId_example # UUID | Call id to update
body =  # Body_3 | Formatted json object

try: 
    # Update an existing call
    api_instance.update_call(apiToken, callId, body)
except ApiException as e:
    print("Exception when calling CallsApi->updateCall: %s\n" % e)

Parameters

Path parameters
Name Description
call_id*
UUID (uuid)
Call id to update
Required
Header parameters
Name Description
Api-Token*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Successful update

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Contacts

Contact Model

Create Contact

Create a new contact


/contacts

Usage and SDK Samples

curl -X POST "https://api-beta.gleanview.com/v1/contacts"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContactsApi;

import java.io.File;
import java.util.*;

public class ContactsApiExample {

    public static void main(String[] args) {
        
        ContactsApi apiInstance = new ContactsApi();
        String apiToken = apiToken_example; // String | 
        Body_4 body = ; // Body_4 | Formatted json object
        try {
            apiInstance.createContact(apiToken, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactsApi#createContact");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ContactsApi;

public class ContactsApiExample {

    public static void main(String[] args) {
        ContactsApi apiInstance = new ContactsApi();
        String apiToken = apiToken_example; // String | 
        Body_4 body = ; // Body_4 | Formatted json object
        try {
            apiInstance.createContact(apiToken, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactsApi#createContact");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
Body_4 *body = ; // Formatted json object

ContactsApi *apiInstance = [[ContactsApi alloc] init];

// Create a new contact
[apiInstance createContactWith:apiToken
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.ContactsApi()

var apiToken = apiToken_example; // {String} 

var body = ; // {Body_4} Formatted json object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createContact(apiToken, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createContactExample
    {
        public void main()
        {
            
            var apiInstance = new ContactsApi();
            var apiToken = apiToken_example;  // String | 
            var body = new Body_4(); // Body_4 | Formatted json object

            try
            {
                // Create a new contact
                apiInstance.createContact(apiToken, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactsApi.createContact: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ContactsApi();
$apiToken = apiToken_example; // String | 
$body = ; // Body_4 | Formatted json object

try {
    $api_instance->createContact($apiToken, $body);
} catch (Exception $e) {
    echo 'Exception when calling ContactsApi->createContact: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContactsApi;

my $api_instance = WWW::SwaggerClient::ContactsApi->new();
my $apiToken = apiToken_example; # String | 
my $body = WWW::SwaggerClient::Object::Body_4->new(); # Body_4 | Formatted json object

eval { 
    $api_instance->createContact(apiToken => $apiToken, body => $body);
};
if ($@) {
    warn "Exception when calling ContactsApi->createContact: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ContactsApi()
apiToken = apiToken_example # String | 
body =  # Body_4 | Formatted json object

try: 
    # Create a new contact
    api_instance.create_contact(apiToken, body)
except ApiException as e:
    print("Exception when calling ContactsApi->createContact: %s\n" % e)

Parameters

Header parameters
Name Description
Api-Token*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Successful creation

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Delete Contact

Delete an existing contact


/contacts/{contact_id}

Usage and SDK Samples

curl -X DELETE "https://api-beta.gleanview.com/v1/contacts/{contact_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContactsApi;

import java.io.File;
import java.util.*;

public class ContactsApiExample {

    public static void main(String[] args) {
        
        ContactsApi apiInstance = new ContactsApi();
        String apiToken = apiToken_example; // String | 
        UUID contactId = contactId_example; // UUID | Contact id to delete
        try {
            apiInstance.deleteContact(apiToken, contactId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactsApi#deleteContact");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ContactsApi;

public class ContactsApiExample {

    public static void main(String[] args) {
        ContactsApi apiInstance = new ContactsApi();
        String apiToken = apiToken_example; // String | 
        UUID contactId = contactId_example; // UUID | Contact id to delete
        try {
            apiInstance.deleteContact(apiToken, contactId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactsApi#deleteContact");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *contactId = contactId_example; // Contact id to delete

ContactsApi *apiInstance = [[ContactsApi alloc] init];

// Delete an existing contact
[apiInstance deleteContactWith:apiToken
    contactId:contactId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.ContactsApi()

var apiToken = apiToken_example; // {String} 

var contactId = contactId_example; // {UUID} Contact id to delete


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteContact(apiToken, contactId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteContactExample
    {
        public void main()
        {
            
            var apiInstance = new ContactsApi();
            var apiToken = apiToken_example;  // String | 
            var contactId = contactId_example;  // UUID | Contact id to delete

            try
            {
                // Delete an existing contact
                apiInstance.deleteContact(apiToken, contactId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactsApi.deleteContact: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ContactsApi();
$apiToken = apiToken_example; // String | 
$contactId = contactId_example; // UUID | Contact id to delete

try {
    $api_instance->deleteContact($apiToken, $contactId);
} catch (Exception $e) {
    echo 'Exception when calling ContactsApi->deleteContact: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContactsApi;

my $api_instance = WWW::SwaggerClient::ContactsApi->new();
my $apiToken = apiToken_example; # String | 
my $contactId = contactId_example; # UUID | Contact id to delete

eval { 
    $api_instance->deleteContact(apiToken => $apiToken, contactId => $contactId);
};
if ($@) {
    warn "Exception when calling ContactsApi->deleteContact: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ContactsApi()
apiToken = apiToken_example # String | 
contactId = contactId_example # UUID | Contact id to delete

try: 
    # Delete an existing contact
    api_instance.delete_contact(apiToken, contactId)
except ApiException as e:
    print("Exception when calling ContactsApi->deleteContact: %s\n" % e)

Parameters

Path parameters
Name Description
contact_id*
UUID (uuid)
Contact id to delete
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful deletion

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


List Contacts

List all client contacts


/contacts

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/contacts"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContactsApi;

import java.io.File;
import java.util.*;

public class ContactsApiExample {

    public static void main(String[] args) {
        
        ContactsApi apiInstance = new ContactsApi();
        String apiToken = apiToken_example; // String | 
        try {
            inline_response_200 result = apiInstance.listContacts(apiToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactsApi#listContacts");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ContactsApi;

public class ContactsApiExample {

    public static void main(String[] args) {
        ContactsApi apiInstance = new ContactsApi();
        String apiToken = apiToken_example; // String | 
        try {
            inline_response_200 result = apiInstance.listContacts(apiToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactsApi#listContacts");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 

ContactsApi *apiInstance = [[ContactsApi alloc] init];

// List all client contacts
[apiInstance listContactsWith:apiToken
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.ContactsApi()

var apiToken = apiToken_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listContacts(apiToken, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listContactsExample
    {
        public void main()
        {
            
            var apiInstance = new ContactsApi();
            var apiToken = apiToken_example;  // String | 

            try
            {
                // List all client contacts
                inline_response_200 result = apiInstance.listContacts(apiToken);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactsApi.listContacts: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ContactsApi();
$apiToken = apiToken_example; // String | 

try {
    $result = $api_instance->listContacts($apiToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContactsApi->listContacts: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContactsApi;

my $api_instance = WWW::SwaggerClient::ContactsApi->new();
my $apiToken = apiToken_example; # String | 

eval { 
    my $result = $api_instance->listContacts(apiToken => $apiToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContactsApi->listContacts: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ContactsApi()
apiToken = apiToken_example # String | 

try: 
    # List all client contacts
    api_response = api_instance.list_contacts(apiToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactsApi->listContacts: %s\n" % e)

Parameters

Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Show Contact

Show a single contact


/contacts/{contact_id}

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/contacts/{contact_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContactsApi;

import java.io.File;
import java.util.*;

public class ContactsApiExample {

    public static void main(String[] args) {
        
        ContactsApi apiInstance = new ContactsApi();
        String apiToken = apiToken_example; // String | 
        UUID contactId = contactId_example; // UUID | Contact id to fetch
        try {
            inline_response_200 result = apiInstance.showContact(apiToken, contactId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactsApi#showContact");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ContactsApi;

public class ContactsApiExample {

    public static void main(String[] args) {
        ContactsApi apiInstance = new ContactsApi();
        String apiToken = apiToken_example; // String | 
        UUID contactId = contactId_example; // UUID | Contact id to fetch
        try {
            inline_response_200 result = apiInstance.showContact(apiToken, contactId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactsApi#showContact");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *contactId = contactId_example; // Contact id to fetch

ContactsApi *apiInstance = [[ContactsApi alloc] init];

// Show a single contact
[apiInstance showContactWith:apiToken
    contactId:contactId
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.ContactsApi()

var apiToken = apiToken_example; // {String} 

var contactId = contactId_example; // {UUID} Contact id to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.showContact(apiToken, contactId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class showContactExample
    {
        public void main()
        {
            
            var apiInstance = new ContactsApi();
            var apiToken = apiToken_example;  // String | 
            var contactId = contactId_example;  // UUID | Contact id to fetch

            try
            {
                // Show a single contact
                inline_response_200 result = apiInstance.showContact(apiToken, contactId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactsApi.showContact: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ContactsApi();
$apiToken = apiToken_example; // String | 
$contactId = contactId_example; // UUID | Contact id to fetch

try {
    $result = $api_instance->showContact($apiToken, $contactId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ContactsApi->showContact: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContactsApi;

my $api_instance = WWW::SwaggerClient::ContactsApi->new();
my $apiToken = apiToken_example; # String | 
my $contactId = contactId_example; # UUID | Contact id to fetch

eval { 
    my $result = $api_instance->showContact(apiToken => $apiToken, contactId => $contactId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ContactsApi->showContact: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ContactsApi()
apiToken = apiToken_example # String | 
contactId = contactId_example # UUID | Contact id to fetch

try: 
    # Show a single contact
    api_response = api_instance.show_contact(apiToken, contactId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ContactsApi->showContact: %s\n" % e)

Parameters

Path parameters
Name Description
contact_id*
UUID (uuid)
Contact id to fetch
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Update Contact

Update an existing contact


/contacts/{contact_id}

Usage and SDK Samples

curl -X PUT "https://api-beta.gleanview.com/v1/contacts/{contact_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ContactsApi;

import java.io.File;
import java.util.*;

public class ContactsApiExample {

    public static void main(String[] args) {
        
        ContactsApi apiInstance = new ContactsApi();
        String apiToken = apiToken_example; // String | 
        UUID contactId = contactId_example; // UUID | Contact id to update
        Body_5 body = ; // Body_5 | Formatted json object
        try {
            apiInstance.updateContact(apiToken, contactId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactsApi#updateContact");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ContactsApi;

public class ContactsApiExample {

    public static void main(String[] args) {
        ContactsApi apiInstance = new ContactsApi();
        String apiToken = apiToken_example; // String | 
        UUID contactId = contactId_example; // UUID | Contact id to update
        Body_5 body = ; // Body_5 | Formatted json object
        try {
            apiInstance.updateContact(apiToken, contactId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ContactsApi#updateContact");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *contactId = contactId_example; // Contact id to update
Body_5 *body = ; // Formatted json object

ContactsApi *apiInstance = [[ContactsApi alloc] init];

// Update an existing contact
[apiInstance updateContactWith:apiToken
    contactId:contactId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.ContactsApi()

var apiToken = apiToken_example; // {String} 

var contactId = contactId_example; // {UUID} Contact id to update

var body = ; // {Body_5} Formatted json object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateContact(apiToken, contactId, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateContactExample
    {
        public void main()
        {
            
            var apiInstance = new ContactsApi();
            var apiToken = apiToken_example;  // String | 
            var contactId = contactId_example;  // UUID | Contact id to update
            var body = new Body_5(); // Body_5 | Formatted json object

            try
            {
                // Update an existing contact
                apiInstance.updateContact(apiToken, contactId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ContactsApi.updateContact: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ContactsApi();
$apiToken = apiToken_example; // String | 
$contactId = contactId_example; // UUID | Contact id to update
$body = ; // Body_5 | Formatted json object

try {
    $api_instance->updateContact($apiToken, $contactId, $body);
} catch (Exception $e) {
    echo 'Exception when calling ContactsApi->updateContact: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ContactsApi;

my $api_instance = WWW::SwaggerClient::ContactsApi->new();
my $apiToken = apiToken_example; # String | 
my $contactId = contactId_example; # UUID | Contact id to update
my $body = WWW::SwaggerClient::Object::Body_5->new(); # Body_5 | Formatted json object

eval { 
    $api_instance->updateContact(apiToken => $apiToken, contactId => $contactId, body => $body);
};
if ($@) {
    warn "Exception when calling ContactsApi->updateContact: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ContactsApi()
apiToken = apiToken_example # String | 
contactId = contactId_example # UUID | Contact id to update
body =  # Body_5 | Formatted json object

try: 
    # Update an existing contact
    api_instance.update_contact(apiToken, contactId, body)
except ApiException as e:
    print("Exception when calling ContactsApi->updateContact: %s\n" % e)

Parameters

Path parameters
Name Description
contact_id*
UUID (uuid)
Contact id to update
Required
Header parameters
Name Description
Api-Token*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Successful update

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Notes

Note Model

Create Note

Create a new note


/notes

Usage and SDK Samples

curl -X POST "https://api-beta.gleanview.com/v1/notes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotesApi;

import java.io.File;
import java.util.*;

public class NotesApiExample {

    public static void main(String[] args) {
        
        NotesApi apiInstance = new NotesApi();
        String apiToken = apiToken_example; // String | 
        Body_9 body = ; // Body_9 | Formatted json object
        try {
            apiInstance.createNote(apiToken, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#createNote");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NotesApi;

public class NotesApiExample {

    public static void main(String[] args) {
        NotesApi apiInstance = new NotesApi();
        String apiToken = apiToken_example; // String | 
        Body_9 body = ; // Body_9 | Formatted json object
        try {
            apiInstance.createNote(apiToken, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#createNote");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
Body_9 *body = ; // Formatted json object

NotesApi *apiInstance = [[NotesApi alloc] init];

// Create a new note
[apiInstance createNoteWith:apiToken
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.NotesApi()

var apiToken = apiToken_example; // {String} 

var body = ; // {Body_9} Formatted json object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createNote(apiToken, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createNoteExample
    {
        public void main()
        {
            
            var apiInstance = new NotesApi();
            var apiToken = apiToken_example;  // String | 
            var body = new Body_9(); // Body_9 | Formatted json object

            try
            {
                // Create a new note
                apiInstance.createNote(apiToken, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotesApi.createNote: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NotesApi();
$apiToken = apiToken_example; // String | 
$body = ; // Body_9 | Formatted json object

try {
    $api_instance->createNote($apiToken, $body);
} catch (Exception $e) {
    echo 'Exception when calling NotesApi->createNote: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotesApi;

my $api_instance = WWW::SwaggerClient::NotesApi->new();
my $apiToken = apiToken_example; # String | 
my $body = WWW::SwaggerClient::Object::Body_9->new(); # Body_9 | Formatted json object

eval { 
    $api_instance->createNote(apiToken => $apiToken, body => $body);
};
if ($@) {
    warn "Exception when calling NotesApi->createNote: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.NotesApi()
apiToken = apiToken_example # String | 
body =  # Body_9 | Formatted json object

try: 
    # Create a new note
    api_instance.create_note(apiToken, body)
except ApiException as e:
    print("Exception when calling NotesApi->createNote: %s\n" % e)

Parameters

Header parameters
Name Description
Api-Token*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Successful creation

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Delete Note

Delete an existing note


/notes/{note_id}

Usage and SDK Samples

curl -X DELETE "https://api-beta.gleanview.com/v1/notes/{note_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotesApi;

import java.io.File;
import java.util.*;

public class NotesApiExample {

    public static void main(String[] args) {
        
        NotesApi apiInstance = new NotesApi();
        String apiToken = apiToken_example; // String | 
        UUID noteId = noteId_example; // UUID | Note id to delete
        try {
            apiInstance.deleteNote(apiToken, noteId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#deleteNote");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NotesApi;

public class NotesApiExample {

    public static void main(String[] args) {
        NotesApi apiInstance = new NotesApi();
        String apiToken = apiToken_example; // String | 
        UUID noteId = noteId_example; // UUID | Note id to delete
        try {
            apiInstance.deleteNote(apiToken, noteId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#deleteNote");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *noteId = noteId_example; // Note id to delete

NotesApi *apiInstance = [[NotesApi alloc] init];

// Delete an existing note
[apiInstance deleteNoteWith:apiToken
    noteId:noteId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.NotesApi()

var apiToken = apiToken_example; // {String} 

var noteId = noteId_example; // {UUID} Note id to delete


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteNote(apiToken, noteId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteNoteExample
    {
        public void main()
        {
            
            var apiInstance = new NotesApi();
            var apiToken = apiToken_example;  // String | 
            var noteId = noteId_example;  // UUID | Note id to delete

            try
            {
                // Delete an existing note
                apiInstance.deleteNote(apiToken, noteId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotesApi.deleteNote: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NotesApi();
$apiToken = apiToken_example; // String | 
$noteId = noteId_example; // UUID | Note id to delete

try {
    $api_instance->deleteNote($apiToken, $noteId);
} catch (Exception $e) {
    echo 'Exception when calling NotesApi->deleteNote: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotesApi;

my $api_instance = WWW::SwaggerClient::NotesApi->new();
my $apiToken = apiToken_example; # String | 
my $noteId = noteId_example; # UUID | Note id to delete

eval { 
    $api_instance->deleteNote(apiToken => $apiToken, noteId => $noteId);
};
if ($@) {
    warn "Exception when calling NotesApi->deleteNote: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.NotesApi()
apiToken = apiToken_example # String | 
noteId = noteId_example # UUID | Note id to delete

try: 
    # Delete an existing note
    api_instance.delete_note(apiToken, noteId)
except ApiException as e:
    print("Exception when calling NotesApi->deleteNote: %s\n" % e)

Parameters

Path parameters
Name Description
note_id*
UUID (uuid)
Note id to delete
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful deletion

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


List Notes

List all client notes


/notes

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/notes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotesApi;

import java.io.File;
import java.util.*;

public class NotesApiExample {

    public static void main(String[] args) {
        
        NotesApi apiInstance = new NotesApi();
        String apiToken = apiToken_example; // String | 
        try {
            inline_response_200 result = apiInstance.listNotes(apiToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#listNotes");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NotesApi;

public class NotesApiExample {

    public static void main(String[] args) {
        NotesApi apiInstance = new NotesApi();
        String apiToken = apiToken_example; // String | 
        try {
            inline_response_200 result = apiInstance.listNotes(apiToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#listNotes");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 

NotesApi *apiInstance = [[NotesApi alloc] init];

// List all client notes
[apiInstance listNotesWith:apiToken
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.NotesApi()

var apiToken = apiToken_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listNotes(apiToken, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listNotesExample
    {
        public void main()
        {
            
            var apiInstance = new NotesApi();
            var apiToken = apiToken_example;  // String | 

            try
            {
                // List all client notes
                inline_response_200 result = apiInstance.listNotes(apiToken);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotesApi.listNotes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NotesApi();
$apiToken = apiToken_example; // String | 

try {
    $result = $api_instance->listNotes($apiToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NotesApi->listNotes: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotesApi;

my $api_instance = WWW::SwaggerClient::NotesApi->new();
my $apiToken = apiToken_example; # String | 

eval { 
    my $result = $api_instance->listNotes(apiToken => $apiToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NotesApi->listNotes: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.NotesApi()
apiToken = apiToken_example # String | 

try: 
    # List all client notes
    api_response = api_instance.list_notes(apiToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NotesApi->listNotes: %s\n" % e)

Parameters

Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Show Note

Show a single note


/notes/{note_id}

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/notes/{note_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotesApi;

import java.io.File;
import java.util.*;

public class NotesApiExample {

    public static void main(String[] args) {
        
        NotesApi apiInstance = new NotesApi();
        String apiToken = apiToken_example; // String | 
        UUID noteId = noteId_example; // UUID | Note id to fetch
        try {
            inline_response_200 result = apiInstance.showNote(apiToken, noteId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#showNote");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NotesApi;

public class NotesApiExample {

    public static void main(String[] args) {
        NotesApi apiInstance = new NotesApi();
        String apiToken = apiToken_example; // String | 
        UUID noteId = noteId_example; // UUID | Note id to fetch
        try {
            inline_response_200 result = apiInstance.showNote(apiToken, noteId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#showNote");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *noteId = noteId_example; // Note id to fetch

NotesApi *apiInstance = [[NotesApi alloc] init];

// Show a single note
[apiInstance showNoteWith:apiToken
    noteId:noteId
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.NotesApi()

var apiToken = apiToken_example; // {String} 

var noteId = noteId_example; // {UUID} Note id to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.showNote(apiToken, noteId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class showNoteExample
    {
        public void main()
        {
            
            var apiInstance = new NotesApi();
            var apiToken = apiToken_example;  // String | 
            var noteId = noteId_example;  // UUID | Note id to fetch

            try
            {
                // Show a single note
                inline_response_200 result = apiInstance.showNote(apiToken, noteId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotesApi.showNote: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NotesApi();
$apiToken = apiToken_example; // String | 
$noteId = noteId_example; // UUID | Note id to fetch

try {
    $result = $api_instance->showNote($apiToken, $noteId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NotesApi->showNote: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotesApi;

my $api_instance = WWW::SwaggerClient::NotesApi->new();
my $apiToken = apiToken_example; # String | 
my $noteId = noteId_example; # UUID | Note id to fetch

eval { 
    my $result = $api_instance->showNote(apiToken => $apiToken, noteId => $noteId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NotesApi->showNote: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.NotesApi()
apiToken = apiToken_example # String | 
noteId = noteId_example # UUID | Note id to fetch

try: 
    # Show a single note
    api_response = api_instance.show_note(apiToken, noteId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NotesApi->showNote: %s\n" % e)

Parameters

Path parameters
Name Description
note_id*
UUID (uuid)
Note id to fetch
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Update Note

Update an existing note


/notes/{note_id}

Usage and SDK Samples

curl -X PUT "https://api-beta.gleanview.com/v1/notes/{note_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotesApi;

import java.io.File;
import java.util.*;

public class NotesApiExample {

    public static void main(String[] args) {
        
        NotesApi apiInstance = new NotesApi();
        String apiToken = apiToken_example; // String | 
        UUID noteId = noteId_example; // UUID | Note id to update
        Body_10 body = ; // Body_10 | Formatted json object
        try {
            apiInstance.updateNote(apiToken, noteId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#updateNote");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.NotesApi;

public class NotesApiExample {

    public static void main(String[] args) {
        NotesApi apiInstance = new NotesApi();
        String apiToken = apiToken_example; // String | 
        UUID noteId = noteId_example; // UUID | Note id to update
        Body_10 body = ; // Body_10 | Formatted json object
        try {
            apiInstance.updateNote(apiToken, noteId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotesApi#updateNote");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *noteId = noteId_example; // Note id to update
Body_10 *body = ; // Formatted json object

NotesApi *apiInstance = [[NotesApi alloc] init];

// Update an existing note
[apiInstance updateNoteWith:apiToken
    noteId:noteId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.NotesApi()

var apiToken = apiToken_example; // {String} 

var noteId = noteId_example; // {UUID} Note id to update

var body = ; // {Body_10} Formatted json object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateNote(apiToken, noteId, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateNoteExample
    {
        public void main()
        {
            
            var apiInstance = new NotesApi();
            var apiToken = apiToken_example;  // String | 
            var noteId = noteId_example;  // UUID | Note id to update
            var body = new Body_10(); // Body_10 | Formatted json object

            try
            {
                // Update an existing note
                apiInstance.updateNote(apiToken, noteId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotesApi.updateNote: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\NotesApi();
$apiToken = apiToken_example; // String | 
$noteId = noteId_example; // UUID | Note id to update
$body = ; // Body_10 | Formatted json object

try {
    $api_instance->updateNote($apiToken, $noteId, $body);
} catch (Exception $e) {
    echo 'Exception when calling NotesApi->updateNote: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotesApi;

my $api_instance = WWW::SwaggerClient::NotesApi->new();
my $apiToken = apiToken_example; # String | 
my $noteId = noteId_example; # UUID | Note id to update
my $body = WWW::SwaggerClient::Object::Body_10->new(); # Body_10 | Formatted json object

eval { 
    $api_instance->updateNote(apiToken => $apiToken, noteId => $noteId, body => $body);
};
if ($@) {
    warn "Exception when calling NotesApi->updateNote: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.NotesApi()
apiToken = apiToken_example # String | 
noteId = noteId_example # UUID | Note id to update
body =  # Body_10 | Formatted json object

try: 
    # Update an existing note
    api_instance.update_note(apiToken, noteId, body)
except ApiException as e:
    print("Exception when calling NotesApi->updateNote: %s\n" % e)

Parameters

Path parameters
Name Description
note_id*
UUID (uuid)
Note id to update
Required
Header parameters
Name Description
Api-Token*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Successful update

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Opportunities

Opportunity Model

Create Opportunity

Create a new opportunity


/opportunities

Usage and SDK Samples

curl -X POST "https://api-beta.gleanview.com/v1/opportunities"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpportunitiesApi;

import java.io.File;
import java.util.*;

public class OpportunitiesApiExample {

    public static void main(String[] args) {
        
        OpportunitiesApi apiInstance = new OpportunitiesApi();
        String apiToken = apiToken_example; // String | 
        Body_11 body = ; // Body_11 | Formatted json object
        try {
            apiInstance.createOpportunity(apiToken, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpportunitiesApi#createOpportunity");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OpportunitiesApi;

public class OpportunitiesApiExample {

    public static void main(String[] args) {
        OpportunitiesApi apiInstance = new OpportunitiesApi();
        String apiToken = apiToken_example; // String | 
        Body_11 body = ; // Body_11 | Formatted json object
        try {
            apiInstance.createOpportunity(apiToken, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpportunitiesApi#createOpportunity");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
Body_11 *body = ; // Formatted json object

OpportunitiesApi *apiInstance = [[OpportunitiesApi alloc] init];

// Create a new opportunity
[apiInstance createOpportunityWith:apiToken
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.OpportunitiesApi()

var apiToken = apiToken_example; // {String} 

var body = ; // {Body_11} Formatted json object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createOpportunity(apiToken, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createOpportunityExample
    {
        public void main()
        {
            
            var apiInstance = new OpportunitiesApi();
            var apiToken = apiToken_example;  // String | 
            var body = new Body_11(); // Body_11 | Formatted json object

            try
            {
                // Create a new opportunity
                apiInstance.createOpportunity(apiToken, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OpportunitiesApi.createOpportunity: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OpportunitiesApi();
$apiToken = apiToken_example; // String | 
$body = ; // Body_11 | Formatted json object

try {
    $api_instance->createOpportunity($apiToken, $body);
} catch (Exception $e) {
    echo 'Exception when calling OpportunitiesApi->createOpportunity: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpportunitiesApi;

my $api_instance = WWW::SwaggerClient::OpportunitiesApi->new();
my $apiToken = apiToken_example; # String | 
my $body = WWW::SwaggerClient::Object::Body_11->new(); # Body_11 | Formatted json object

eval { 
    $api_instance->createOpportunity(apiToken => $apiToken, body => $body);
};
if ($@) {
    warn "Exception when calling OpportunitiesApi->createOpportunity: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OpportunitiesApi()
apiToken = apiToken_example # String | 
body =  # Body_11 | Formatted json object

try: 
    # Create a new opportunity
    api_instance.create_opportunity(apiToken, body)
except ApiException as e:
    print("Exception when calling OpportunitiesApi->createOpportunity: %s\n" % e)

Parameters

Header parameters
Name Description
Api-Token*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Successful creation

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Delete Opportunity

Delete an existing opportunity


/opportunities/{opportunity_id}

Usage and SDK Samples

curl -X DELETE "https://api-beta.gleanview.com/v1/opportunities/{opportunity_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpportunitiesApi;

import java.io.File;
import java.util.*;

public class OpportunitiesApiExample {

    public static void main(String[] args) {
        
        OpportunitiesApi apiInstance = new OpportunitiesApi();
        String apiToken = apiToken_example; // String | 
        UUID opportunityId = opportunityId_example; // UUID | Opportunity id to delete
        try {
            apiInstance.deleteOpportunity(apiToken, opportunityId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpportunitiesApi#deleteOpportunity");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OpportunitiesApi;

public class OpportunitiesApiExample {

    public static void main(String[] args) {
        OpportunitiesApi apiInstance = new OpportunitiesApi();
        String apiToken = apiToken_example; // String | 
        UUID opportunityId = opportunityId_example; // UUID | Opportunity id to delete
        try {
            apiInstance.deleteOpportunity(apiToken, opportunityId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpportunitiesApi#deleteOpportunity");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *opportunityId = opportunityId_example; // Opportunity id to delete

OpportunitiesApi *apiInstance = [[OpportunitiesApi alloc] init];

// Delete an existing opportunity
[apiInstance deleteOpportunityWith:apiToken
    opportunityId:opportunityId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.OpportunitiesApi()

var apiToken = apiToken_example; // {String} 

var opportunityId = opportunityId_example; // {UUID} Opportunity id to delete


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteOpportunity(apiToken, opportunityId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteOpportunityExample
    {
        public void main()
        {
            
            var apiInstance = new OpportunitiesApi();
            var apiToken = apiToken_example;  // String | 
            var opportunityId = opportunityId_example;  // UUID | Opportunity id to delete

            try
            {
                // Delete an existing opportunity
                apiInstance.deleteOpportunity(apiToken, opportunityId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OpportunitiesApi.deleteOpportunity: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OpportunitiesApi();
$apiToken = apiToken_example; // String | 
$opportunityId = opportunityId_example; // UUID | Opportunity id to delete

try {
    $api_instance->deleteOpportunity($apiToken, $opportunityId);
} catch (Exception $e) {
    echo 'Exception when calling OpportunitiesApi->deleteOpportunity: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpportunitiesApi;

my $api_instance = WWW::SwaggerClient::OpportunitiesApi->new();
my $apiToken = apiToken_example; # String | 
my $opportunityId = opportunityId_example; # UUID | Opportunity id to delete

eval { 
    $api_instance->deleteOpportunity(apiToken => $apiToken, opportunityId => $opportunityId);
};
if ($@) {
    warn "Exception when calling OpportunitiesApi->deleteOpportunity: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OpportunitiesApi()
apiToken = apiToken_example # String | 
opportunityId = opportunityId_example # UUID | Opportunity id to delete

try: 
    # Delete an existing opportunity
    api_instance.delete_opportunity(apiToken, opportunityId)
except ApiException as e:
    print("Exception when calling OpportunitiesApi->deleteOpportunity: %s\n" % e)

Parameters

Path parameters
Name Description
opportunity_id*
UUID (uuid)
Opportunity id to delete
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful deletion

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


List Opportunities

List all client opportunities


/opportunities

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/opportunities"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpportunitiesApi;

import java.io.File;
import java.util.*;

public class OpportunitiesApiExample {

    public static void main(String[] args) {
        
        OpportunitiesApi apiInstance = new OpportunitiesApi();
        String apiToken = apiToken_example; // String | 
        try {
            inline_response_200 result = apiInstance.listOpportunities(apiToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpportunitiesApi#listOpportunities");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OpportunitiesApi;

public class OpportunitiesApiExample {

    public static void main(String[] args) {
        OpportunitiesApi apiInstance = new OpportunitiesApi();
        String apiToken = apiToken_example; // String | 
        try {
            inline_response_200 result = apiInstance.listOpportunities(apiToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpportunitiesApi#listOpportunities");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 

OpportunitiesApi *apiInstance = [[OpportunitiesApi alloc] init];

// List all client opportunities
[apiInstance listOpportunitiesWith:apiToken
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.OpportunitiesApi()

var apiToken = apiToken_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listOpportunities(apiToken, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class listOpportunitiesExample
    {
        public void main()
        {
            
            var apiInstance = new OpportunitiesApi();
            var apiToken = apiToken_example;  // String | 

            try
            {
                // List all client opportunities
                inline_response_200 result = apiInstance.listOpportunities(apiToken);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OpportunitiesApi.listOpportunities: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OpportunitiesApi();
$apiToken = apiToken_example; // String | 

try {
    $result = $api_instance->listOpportunities($apiToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OpportunitiesApi->listOpportunities: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpportunitiesApi;

my $api_instance = WWW::SwaggerClient::OpportunitiesApi->new();
my $apiToken = apiToken_example; # String | 

eval { 
    my $result = $api_instance->listOpportunities(apiToken => $apiToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OpportunitiesApi->listOpportunities: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OpportunitiesApi()
apiToken = apiToken_example # String | 

try: 
    # List all client opportunities
    api_response = api_instance.list_opportunities(apiToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OpportunitiesApi->listOpportunities: %s\n" % e)

Parameters

Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Show Opportunity

Show a single opportunity


/opportunities/{opportunity_id}

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/opportunities/{opportunity_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpportunitiesApi;

import java.io.File;
import java.util.*;

public class OpportunitiesApiExample {

    public static void main(String[] args) {
        
        OpportunitiesApi apiInstance = new OpportunitiesApi();
        String apiToken = apiToken_example; // String | 
        UUID opportunityId = opportunityId_example; // UUID | Opportunity id to fetch
        try {
            inline_response_200 result = apiInstance.showOpportunity(apiToken, opportunityId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpportunitiesApi#showOpportunity");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OpportunitiesApi;

public class OpportunitiesApiExample {

    public static void main(String[] args) {
        OpportunitiesApi apiInstance = new OpportunitiesApi();
        String apiToken = apiToken_example; // String | 
        UUID opportunityId = opportunityId_example; // UUID | Opportunity id to fetch
        try {
            inline_response_200 result = apiInstance.showOpportunity(apiToken, opportunityId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpportunitiesApi#showOpportunity");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *opportunityId = opportunityId_example; // Opportunity id to fetch

OpportunitiesApi *apiInstance = [[OpportunitiesApi alloc] init];

// Show a single opportunity
[apiInstance showOpportunityWith:apiToken
    opportunityId:opportunityId
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.OpportunitiesApi()

var apiToken = apiToken_example; // {String} 

var opportunityId = opportunityId_example; // {UUID} Opportunity id to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.showOpportunity(apiToken, opportunityId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class showOpportunityExample
    {
        public void main()
        {
            
            var apiInstance = new OpportunitiesApi();
            var apiToken = apiToken_example;  // String | 
            var opportunityId = opportunityId_example;  // UUID | Opportunity id to fetch

            try
            {
                // Show a single opportunity
                inline_response_200 result = apiInstance.showOpportunity(apiToken, opportunityId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OpportunitiesApi.showOpportunity: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OpportunitiesApi();
$apiToken = apiToken_example; // String | 
$opportunityId = opportunityId_example; // UUID | Opportunity id to fetch

try {
    $result = $api_instance->showOpportunity($apiToken, $opportunityId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OpportunitiesApi->showOpportunity: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpportunitiesApi;

my $api_instance = WWW::SwaggerClient::OpportunitiesApi->new();
my $apiToken = apiToken_example; # String | 
my $opportunityId = opportunityId_example; # UUID | Opportunity id to fetch

eval { 
    my $result = $api_instance->showOpportunity(apiToken => $apiToken, opportunityId => $opportunityId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OpportunitiesApi->showOpportunity: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OpportunitiesApi()
apiToken = apiToken_example # String | 
opportunityId = opportunityId_example # UUID | Opportunity id to fetch

try: 
    # Show a single opportunity
    api_response = api_instance.show_opportunity(apiToken, opportunityId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OpportunitiesApi->showOpportunity: %s\n" % e)

Parameters

Path parameters
Name Description
opportunity_id*
UUID (uuid)
Opportunity id to fetch
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Update Opportunity

Update an existing opportunity


/opportunities/{opportunity_id}

Usage and SDK Samples

curl -X PUT "https://api-beta.gleanview.com/v1/opportunities/{opportunity_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OpportunitiesApi;

import java.io.File;
import java.util.*;

public class OpportunitiesApiExample {

    public static void main(String[] args) {
        
        OpportunitiesApi apiInstance = new OpportunitiesApi();
        String apiToken = apiToken_example; // String | 
        UUID opportunityId = opportunityId_example; // UUID | Opportunity id to update
        Body_12 body = ; // Body_12 | Formatted json object
        try {
            apiInstance.updateOpportunity(apiToken, opportunityId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpportunitiesApi#updateOpportunity");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OpportunitiesApi;

public class OpportunitiesApiExample {

    public static void main(String[] args) {
        OpportunitiesApi apiInstance = new OpportunitiesApi();
        String apiToken = apiToken_example; // String | 
        UUID opportunityId = opportunityId_example; // UUID | Opportunity id to update
        Body_12 body = ; // Body_12 | Formatted json object
        try {
            apiInstance.updateOpportunity(apiToken, opportunityId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpportunitiesApi#updateOpportunity");
            e.printStackTrace();
        }
    }
}
String *apiToken = apiToken_example; // 
UUID *opportunityId = opportunityId_example; // Opportunity id to update
Body_12 *body = ; // Formatted json object

OpportunitiesApi *apiInstance = [[OpportunitiesApi alloc] init];

// Update an existing opportunity
[apiInstance updateOpportunityWith:apiToken
    opportunityId:opportunityId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.OpportunitiesApi()

var apiToken = apiToken_example; // {String} 

var opportunityId = opportunityId_example; // {UUID} Opportunity id to update

var body = ; // {Body_12} Formatted json object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateOpportunity(apiToken, opportunityId, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class updateOpportunityExample
    {
        public void main()
        {
            
            var apiInstance = new OpportunitiesApi();
            var apiToken = apiToken_example;  // String | 
            var opportunityId = opportunityId_example;  // UUID | Opportunity id to update
            var body = new Body_12(); // Body_12 | Formatted json object

            try
            {
                // Update an existing opportunity
                apiInstance.updateOpportunity(apiToken, opportunityId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OpportunitiesApi.updateOpportunity: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OpportunitiesApi();
$apiToken = apiToken_example; // String | 
$opportunityId = opportunityId_example; // UUID | Opportunity id to update
$body = ; // Body_12 | Formatted json object

try {
    $api_instance->updateOpportunity($apiToken, $opportunityId, $body);
} catch (Exception $e) {
    echo 'Exception when calling OpportunitiesApi->updateOpportunity: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OpportunitiesApi;

my $api_instance = WWW::SwaggerClient::OpportunitiesApi->new();
my $apiToken = apiToken_example; # String | 
my $opportunityId = opportunityId_example; # UUID | Opportunity id to update
my $body = WWW::SwaggerClient::Object::Body_12->new(); # Body_12 | Formatted json object

eval { 
    $api_instance->updateOpportunity(apiToken => $apiToken, opportunityId => $opportunityId, body => $body);
};
if ($@) {
    warn "Exception when calling OpportunitiesApi->updateOpportunity: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OpportunitiesApi()
apiToken = apiToken_example # String | 
opportunityId = opportunityId_example # UUID | Opportunity id to update
body =  # Body_12 | Formatted json object

try: 
    # Update an existing opportunity
    api_instance.update_opportunity(apiToken, opportunityId, body)
except ApiException as e:
    print("Exception when calling OpportunitiesApi->updateOpportunity: %s\n" % e)

Parameters

Path parameters
Name Description
opportunity_id*
UUID (uuid)
Opportunity id to update
Required
Header parameters
Name Description
Api-Token*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Successful update

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Projects

Project Model

Create Project

Create a new project


/projects

Usage and SDK Samples

curl -X POST "https://api-beta.gleanview.com/v1/projects"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectsApi;

import java.io.File;
import java.util.*;

public class ProjectsApiExample {

    public static void main(String[] args) {
        
        ProjectsApi apiInstance = new ProjectsApi();
        String apiToken = apiToken_example; // String | 
        Post_request_body body = ; // Post_request_body | Formatted json object
        try {
            ApiResponse result = apiInstance.createProject(apiToken, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#createProject");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectsApi;

public class ProjectsApiExample {

    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String apiToken = apiToken_example; // String | 
        Post_request_body body = ; // Post_request_body | Formatted json object
        try {
            ApiResponse result = apiInstance.createProject(apiToken, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#createProject");
            e.printStackTrace();
        }
    }
}
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.ProjectsApi()

var apiToken = apiToken_example; // {String} 

var body = ; // {Post_request_body} Formatted json object


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createProject(apiToken, body, callback);
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProjectsApi();
$apiToken = apiToken_example; // String | 
$body = ; // Post_request_body | Formatted json object

try {
    $result = $api_instance->createProject($apiToken, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProjectsApi->createProject: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectsApi;

my $api_instance = WWW::SwaggerClient::ProjectsApi->new();
my $apiToken = apiToken_example; # String | 
my $body = WWW::SwaggerClient::Object::Post_request_body->new(); # Post_request_body | Formatted json object

eval { 
    my $result = $api_instance->createProject(apiToken => $apiToken, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectsApi->createProject: $@\n";
}

Parameters

Header parameters
Name Description
Api-Token*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Delete Project

Delete an existing project


/projects/{project_id}

Usage and SDK Samples

curl -X DELETE "https://api-beta.gleanview.com/v1/projects/{project_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectsApi;

import java.io.File;
import java.util.*;

public class ProjectsApiExample {

    public static void main(String[] args) {
        
        ProjectsApi apiInstance = new ProjectsApi();
        String apiToken = apiToken_example; // String | 
        UUID projectId = projectId_example; // UUID | Project id to delete
        try {
            ApiResponse result = apiInstance.deleteProjects(apiToken, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#deleteProjects");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectsApi;

public class ProjectsApiExample {

    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String apiToken = apiToken_example; // String | 
        UUID projectId = projectId_example; // UUID | Project id to delete
        try {
            ApiResponse result = apiInstance.deleteProjects(apiToken, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#deleteProjects");
            e.printStackTrace();
        }
    }
}
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.ProjectsApi()

var apiToken = apiToken_example; // {String} 

var projectId = projectId_example; // {UUID} Project id to delete


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteProjects(apiToken, projectId, callback);
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProjectsApi();
$apiToken = apiToken_example; // String | 
$projectId = projectId_example; // UUID | Project id to delete

try {
    $result = $api_instance->deleteProjects($apiToken, $projectId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProjectsApi->deleteProjects: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectsApi;

my $api_instance = WWW::SwaggerClient::ProjectsApi->new();
my $apiToken = apiToken_example; # String | 
my $projectId = projectId_example; # UUID | Project id to delete

eval { 
    my $result = $api_instance->deleteProjects(apiToken => $apiToken, projectId => $projectId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectsApi->deleteProjects: $@\n";
}

Parameters

Path parameters
Name Description
project_id*
UUID (uuid)
Project id to delete
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


List Projects

List all client projects


/projects

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/projects"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectsApi;

import java.io.File;
import java.util.*;

public class ProjectsApiExample {

    public static void main(String[] args) {
        
        ProjectsApi apiInstance = new ProjectsApi();
        String apiToken = apiToken_example; // String | 
        try {
            ApiResponse result = apiInstance.listProjects(apiToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#listProjects");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectsApi;

public class ProjectsApiExample {

    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String apiToken = apiToken_example; // String | 
        try {
            ApiResponse result = apiInstance.listProjects(apiToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#listProjects");
            e.printStackTrace();
        }
    }
}
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.ProjectsApi()

var apiToken = apiToken_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listProjects(apiToken, , callback);
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProjectsApi();
$apiToken = apiToken_example; // String | 

try {
    $result = $api_instance->listProjects($apiToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProjectsApi->listProjects: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectsApi;

my $api_instance = WWW::SwaggerClient::ProjectsApi->new();
my $apiToken = apiToken_example; # String | 

eval { 
    my $result = $api_instance->listProjects(apiToken => $apiToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectsApi->listProjects: $@\n";
}

Parameters

Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Show Project

Show a single project


/projects/{project_id}

Usage and SDK Samples

curl -X GET "https://api-beta.gleanview.com/v1/projects/{project_id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectsApi;

import java.io.File;
import java.util.*;

public class ProjectsApiExample {

    public static void main(String[] args) {
        
        ProjectsApi apiInstance = new ProjectsApi();
        String apiToken = apiToken_example; // String | 
        UUID projectId = projectId_example; // UUID | Project id to fetch
        try {
            ApiResponse result = apiInstance.showProject(apiToken, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#showProject");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectsApi;

public class ProjectsApiExample {

    public static void main(String[] args) {
        ProjectsApi apiInstance = new ProjectsApi();
        String apiToken = apiToken_example; // String | 
        UUID projectId = projectId_example; // UUID | Project id to fetch
        try {
            ApiResponse result = apiInstance.showProject(apiToken, projectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectsApi#showProject");
            e.printStackTrace();
        }
    }
}
var GleanviewRestApi = require('gleanview_rest_api');

var api = new GleanviewRestApi.ProjectsApi()

var apiToken = apiToken_example; // {String} 

var projectId = projectId_example; // {UUID} Project id to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.showProject(apiToken, projectId, callback);
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProjectsApi();
$apiToken = apiToken_example; // String | 
$projectId = projectId_example; // UUID | Project id to fetch

try {
    $result = $api_instance->showProject($apiToken, $projectId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProjectsApi->showProject: ', $e->getMessage(), PHP_EOL;
}
?>

Parameters

Path parameters
Name Description
project_id*
UUID (uuid)
Project id to fetch
Required
Header parameters
Name Description
Api-Token*
String
Required

Responses

Status: 200 - Successful call

Status: 400 - Bad Request

Status: 401 - No Api-Token was provided or an invalid Api-Token was used

Status: 404 - Couldn't find the resource you are requesting

Status: 500 - There was an error trying to complete your request


Update Project

Update an existing project


/projects/{project_id}

Usage and SDK Samples