License Pool Api

LicensePoolConfiguration

createLicensePoolConfiguration

Create the License Pool configuration

Creates the License Pool configuration using the value in the body.


/license-pool/configuration

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://uknapiproxy.coreview.com/public/license-pool/configuration?api-version=apiVersion_example" \
 -d '{
  "skus" : [ {
    "skuId" : "skuId"
  }, {
    "skuId" : "skuId"
  } ],
  "firstLevelCriteria" : "firstLevelCriteria",
  "pricePerUser" : "pricePerUser",
  "pricePerActiveUser" : "pricePerActiveUser",
  "secondLevelCriteria" : "secondLevelCriteria",
  "currency" : "currency",
  "pricePerLicensePool" : "pricePerLicensePool"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LicensePoolConfigurationApi;

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

public class LicensePoolConfigurationApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        LicensePoolConfigurationApi apiInstance = new LicensePoolConfigurationApi();
        String apiVersion = apiVersion_example; // String | 
        LicensePoolConfigurationCreationRequest licensePoolConfigurationCreationRequest = ; // LicensePoolConfigurationCreationRequest | 

        try {
            apiInstance.createLicensePoolConfiguration(apiVersion, licensePoolConfigurationCreationRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolConfigurationApi#createLicensePoolConfiguration");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String apiVersion = new String(); // String | 
final LicensePoolConfigurationCreationRequest licensePoolConfigurationCreationRequest = new LicensePoolConfigurationCreationRequest(); // LicensePoolConfigurationCreationRequest | 

try {
    final result = await api_instance.createLicensePoolConfiguration(apiVersion, licensePoolConfigurationCreationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createLicensePoolConfiguration: $e\n');
}


import org.openapitools.client.api.LicensePoolConfigurationApi;

public class LicensePoolConfigurationApiExample {
    public static void main(String[] args) {
        LicensePoolConfigurationApi apiInstance = new LicensePoolConfigurationApi();
        String apiVersion = apiVersion_example; // String | 
        LicensePoolConfigurationCreationRequest licensePoolConfigurationCreationRequest = ; // LicensePoolConfigurationCreationRequest | 

        try {
            apiInstance.createLicensePoolConfiguration(apiVersion, licensePoolConfigurationCreationRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolConfigurationApi#createLicensePoolConfiguration");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
LicensePoolConfigurationApi *apiInstance = [[LicensePoolConfigurationApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)
LicensePoolConfigurationCreationRequest *licensePoolConfigurationCreationRequest = ; //  (optional)

// Create the License Pool configuration
[apiInstance createLicensePoolConfigurationWith:apiVersion
    licensePoolConfigurationCreationRequest:licensePoolConfigurationCreationRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LicensePoolApi = require('license_pool_api');
var defaultClient = LicensePoolApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new LicensePoolApi.LicensePoolConfigurationApi()
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'licensePoolConfigurationCreationRequest':  // {LicensePoolConfigurationCreationRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.createLicensePoolConfiguration(apiVersion, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class createLicensePoolConfigurationExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new LicensePoolConfigurationApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var licensePoolConfigurationCreationRequest = new LicensePoolConfigurationCreationRequest(); // LicensePoolConfigurationCreationRequest |  (optional) 

            try {
                // Create the License Pool configuration
                apiInstance.createLicensePoolConfiguration(apiVersion, licensePoolConfigurationCreationRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling LicensePoolConfigurationApi.createLicensePoolConfiguration: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LicensePoolConfigurationApi();
$apiVersion = apiVersion_example; // String | 
$licensePoolConfigurationCreationRequest = ; // LicensePoolConfigurationCreationRequest | 

try {
    $api_instance->createLicensePoolConfiguration($apiVersion, $licensePoolConfigurationCreationRequest);
} catch (Exception $e) {
    echo 'Exception when calling LicensePoolConfigurationApi->createLicensePoolConfiguration: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LicensePoolConfigurationApi;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LicensePoolConfigurationApi->new();
my $apiVersion = apiVersion_example; # String | 
my $licensePoolConfigurationCreationRequest = WWW::OPenAPIClient::Object::LicensePoolConfigurationCreationRequest->new(); # LicensePoolConfigurationCreationRequest | 

eval {
    $api_instance->createLicensePoolConfiguration(apiVersion => $apiVersion, licensePoolConfigurationCreationRequest => $licensePoolConfigurationCreationRequest);
};
if ($@) {
    warn "Exception when calling LicensePoolConfigurationApi->createLicensePoolConfiguration: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.LicensePoolConfigurationApi()
apiVersion = apiVersion_example # String |  (default to null)
licensePoolConfigurationCreationRequest =  # LicensePoolConfigurationCreationRequest |  (optional)

try:
    # Create the License Pool configuration
    api_instance.create_license_pool_configuration(apiVersion, licensePoolConfigurationCreationRequest=licensePoolConfigurationCreationRequest)
except ApiException as e:
    print("Exception when calling LicensePoolConfigurationApi->createLicensePoolConfiguration: %s\n" % e)
extern crate LicensePoolConfigurationApi;

pub fn main() {
    let apiVersion = apiVersion_example; // String
    let licensePoolConfigurationCreationRequest = ; // LicensePoolConfigurationCreationRequest

    let mut context = LicensePoolConfigurationApi::Context::default();
    let result = client.createLicensePoolConfiguration(apiVersion, licensePoolConfigurationCreationRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

licensepool.write Write access to license pool resources

Parameters

Body parameters
Name Description
licensePoolConfigurationCreationRequest

Query parameters
Name Description
api-version*
String
Required

Responses

deleteLicensePoolConfiguration

Delete the License Pool configuration

Deletes the License Pool configuration.


/license-pool/configuration

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://uknapiproxy.coreview.com/public/license-pool/configuration?api-version=apiVersion_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LicensePoolConfigurationApi;

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

public class LicensePoolConfigurationApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        LicensePoolConfigurationApi apiInstance = new LicensePoolConfigurationApi();
        String apiVersion = apiVersion_example; // String | 

        try {
            apiInstance.deleteLicensePoolConfiguration(apiVersion);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolConfigurationApi#deleteLicensePoolConfiguration");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String apiVersion = new String(); // String | 

try {
    final result = await api_instance.deleteLicensePoolConfiguration(apiVersion);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteLicensePoolConfiguration: $e\n');
}


import org.openapitools.client.api.LicensePoolConfigurationApi;

public class LicensePoolConfigurationApiExample {
    public static void main(String[] args) {
        LicensePoolConfigurationApi apiInstance = new LicensePoolConfigurationApi();
        String apiVersion = apiVersion_example; // String | 

        try {
            apiInstance.deleteLicensePoolConfiguration(apiVersion);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolConfigurationApi#deleteLicensePoolConfiguration");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
LicensePoolConfigurationApi *apiInstance = [[LicensePoolConfigurationApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)

// Delete the License Pool configuration
[apiInstance deleteLicensePoolConfigurationWith:apiVersion
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LicensePoolApi = require('license_pool_api');
var defaultClient = LicensePoolApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new LicensePoolApi.LicensePoolConfigurationApi()
var apiVersion = apiVersion_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteLicensePoolConfiguration(apiVersion, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteLicensePoolConfigurationExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new LicensePoolConfigurationApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Delete the License Pool configuration
                apiInstance.deleteLicensePoolConfiguration(apiVersion);
            } catch (Exception e) {
                Debug.Print("Exception when calling LicensePoolConfigurationApi.deleteLicensePoolConfiguration: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LicensePoolConfigurationApi();
$apiVersion = apiVersion_example; // String | 

try {
    $api_instance->deleteLicensePoolConfiguration($apiVersion);
} catch (Exception $e) {
    echo 'Exception when calling LicensePoolConfigurationApi->deleteLicensePoolConfiguration: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LicensePoolConfigurationApi;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LicensePoolConfigurationApi->new();
my $apiVersion = apiVersion_example; # String | 

eval {
    $api_instance->deleteLicensePoolConfiguration(apiVersion => $apiVersion);
};
if ($@) {
    warn "Exception when calling LicensePoolConfigurationApi->deleteLicensePoolConfiguration: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.LicensePoolConfigurationApi()
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Delete the License Pool configuration
    api_instance.delete_license_pool_configuration(apiVersion)
except ApiException as e:
    print("Exception when calling LicensePoolConfigurationApi->deleteLicensePoolConfiguration: %s\n" % e)
extern crate LicensePoolConfigurationApi;

pub fn main() {
    let apiVersion = apiVersion_example; // String

    let mut context = LicensePoolConfigurationApi::Context::default();
    let result = client.deleteLicensePoolConfiguration(apiVersion, &context).wait();

    println!("{:?}", result);
}

Scopes

licensepool.write Write access to license pool resources

Parameters

Query parameters
Name Description
api-version*
String
Required

Responses

getLicensePoolConfiguration

Get the License Pool configuration

Returns the License Pool configuration.


/license-pool/configuration

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://uknapiproxy.coreview.com/public/license-pool/configuration?api-version=apiVersion_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LicensePoolConfigurationApi;

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

public class LicensePoolConfigurationApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        LicensePoolConfigurationApi apiInstance = new LicensePoolConfigurationApi();
        String apiVersion = apiVersion_example; // String | 

        try {
            LicensePoolConfiguration result = apiInstance.getLicensePoolConfiguration(apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolConfigurationApi#getLicensePoolConfiguration");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String apiVersion = new String(); // String | 

try {
    final result = await api_instance.getLicensePoolConfiguration(apiVersion);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getLicensePoolConfiguration: $e\n');
}


import org.openapitools.client.api.LicensePoolConfigurationApi;

public class LicensePoolConfigurationApiExample {
    public static void main(String[] args) {
        LicensePoolConfigurationApi apiInstance = new LicensePoolConfigurationApi();
        String apiVersion = apiVersion_example; // String | 

        try {
            LicensePoolConfiguration result = apiInstance.getLicensePoolConfiguration(apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolConfigurationApi#getLicensePoolConfiguration");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
LicensePoolConfigurationApi *apiInstance = [[LicensePoolConfigurationApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)

// Get the License Pool configuration
[apiInstance getLicensePoolConfigurationWith:apiVersion
              completionHandler: ^(LicensePoolConfiguration output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LicensePoolApi = require('license_pool_api');
var defaultClient = LicensePoolApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new LicensePoolApi.LicensePoolConfigurationApi()
var apiVersion = apiVersion_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getLicensePoolConfiguration(apiVersion, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getLicensePoolConfigurationExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new LicensePoolConfigurationApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Get the License Pool configuration
                LicensePoolConfiguration result = apiInstance.getLicensePoolConfiguration(apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LicensePoolConfigurationApi.getLicensePoolConfiguration: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LicensePoolConfigurationApi();
$apiVersion = apiVersion_example; // String | 

try {
    $result = $api_instance->getLicensePoolConfiguration($apiVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LicensePoolConfigurationApi->getLicensePoolConfiguration: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LicensePoolConfigurationApi;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LicensePoolConfigurationApi->new();
my $apiVersion = apiVersion_example; # String | 

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

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.LicensePoolConfigurationApi()
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Get the License Pool configuration
    api_response = api_instance.get_license_pool_configuration(apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LicensePoolConfigurationApi->getLicensePoolConfiguration: %s\n" % e)
extern crate LicensePoolConfigurationApi;

pub fn main() {
    let apiVersion = apiVersion_example; // String

    let mut context = LicensePoolConfigurationApi::Context::default();
    let result = client.getLicensePoolConfiguration(apiVersion, &context).wait();

    println!("{:?}", result);
}

Scopes

licensepool.read Read access to license pool resources

Parameters

Query parameters
Name Description
api-version*
String
Required

Responses

updateLicensePoolConfiguration

Update the License Pool configuration

Updates the License Pool configuration using the value in the body.


/license-pool/configuration

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://uknapiproxy.coreview.com/public/license-pool/configuration?api-version=apiVersion_example" \
 -d '{
  "skus" : [ {
    "skuId" : "skuId"
  }, {
    "skuId" : "skuId"
  } ],
  "firstLevelCriteria" : "firstLevelCriteria",
  "pricePerUser" : "pricePerUser",
  "pricePerActiveUser" : "pricePerActiveUser",
  "secondLevelCriteria" : "secondLevelCriteria",
  "currency" : "currency",
  "pricePerLicensePool" : "pricePerLicensePool"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LicensePoolConfigurationApi;

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

public class LicensePoolConfigurationApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        LicensePoolConfigurationApi apiInstance = new LicensePoolConfigurationApi();
        String apiVersion = apiVersion_example; // String | 
        LicensePoolConfigurationCreationRequest licensePoolConfigurationCreationRequest = ; // LicensePoolConfigurationCreationRequest | 

        try {
            LicensePoolConfiguration result = apiInstance.updateLicensePoolConfiguration(apiVersion, licensePoolConfigurationCreationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolConfigurationApi#updateLicensePoolConfiguration");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String apiVersion = new String(); // String | 
final LicensePoolConfigurationCreationRequest licensePoolConfigurationCreationRequest = new LicensePoolConfigurationCreationRequest(); // LicensePoolConfigurationCreationRequest | 

try {
    final result = await api_instance.updateLicensePoolConfiguration(apiVersion, licensePoolConfigurationCreationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateLicensePoolConfiguration: $e\n');
}


import org.openapitools.client.api.LicensePoolConfigurationApi;

public class LicensePoolConfigurationApiExample {
    public static void main(String[] args) {
        LicensePoolConfigurationApi apiInstance = new LicensePoolConfigurationApi();
        String apiVersion = apiVersion_example; // String | 
        LicensePoolConfigurationCreationRequest licensePoolConfigurationCreationRequest = ; // LicensePoolConfigurationCreationRequest | 

        try {
            LicensePoolConfiguration result = apiInstance.updateLicensePoolConfiguration(apiVersion, licensePoolConfigurationCreationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolConfigurationApi#updateLicensePoolConfiguration");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
LicensePoolConfigurationApi *apiInstance = [[LicensePoolConfigurationApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)
LicensePoolConfigurationCreationRequest *licensePoolConfigurationCreationRequest = ; //  (optional)

// Update the License Pool configuration
[apiInstance updateLicensePoolConfigurationWith:apiVersion
    licensePoolConfigurationCreationRequest:licensePoolConfigurationCreationRequest
              completionHandler: ^(LicensePoolConfiguration output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LicensePoolApi = require('license_pool_api');
var defaultClient = LicensePoolApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new LicensePoolApi.LicensePoolConfigurationApi()
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'licensePoolConfigurationCreationRequest':  // {LicensePoolConfigurationCreationRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateLicensePoolConfiguration(apiVersion, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateLicensePoolConfigurationExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new LicensePoolConfigurationApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var licensePoolConfigurationCreationRequest = new LicensePoolConfigurationCreationRequest(); // LicensePoolConfigurationCreationRequest |  (optional) 

            try {
                // Update the License Pool configuration
                LicensePoolConfiguration result = apiInstance.updateLicensePoolConfiguration(apiVersion, licensePoolConfigurationCreationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LicensePoolConfigurationApi.updateLicensePoolConfiguration: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LicensePoolConfigurationApi();
$apiVersion = apiVersion_example; // String | 
$licensePoolConfigurationCreationRequest = ; // LicensePoolConfigurationCreationRequest | 

try {
    $result = $api_instance->updateLicensePoolConfiguration($apiVersion, $licensePoolConfigurationCreationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LicensePoolConfigurationApi->updateLicensePoolConfiguration: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LicensePoolConfigurationApi;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LicensePoolConfigurationApi->new();
my $apiVersion = apiVersion_example; # String | 
my $licensePoolConfigurationCreationRequest = WWW::OPenAPIClient::Object::LicensePoolConfigurationCreationRequest->new(); # LicensePoolConfigurationCreationRequest | 

eval {
    my $result = $api_instance->updateLicensePoolConfiguration(apiVersion => $apiVersion, licensePoolConfigurationCreationRequest => $licensePoolConfigurationCreationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LicensePoolConfigurationApi->updateLicensePoolConfiguration: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.LicensePoolConfigurationApi()
apiVersion = apiVersion_example # String |  (default to null)
licensePoolConfigurationCreationRequest =  # LicensePoolConfigurationCreationRequest |  (optional)

try:
    # Update the License Pool configuration
    api_response = api_instance.update_license_pool_configuration(apiVersion, licensePoolConfigurationCreationRequest=licensePoolConfigurationCreationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LicensePoolConfigurationApi->updateLicensePoolConfiguration: %s\n" % e)
extern crate LicensePoolConfigurationApi;

pub fn main() {
    let apiVersion = apiVersion_example; // String
    let licensePoolConfigurationCreationRequest = ; // LicensePoolConfigurationCreationRequest

    let mut context = LicensePoolConfigurationApi::Context::default();
    let result = client.updateLicensePoolConfiguration(apiVersion, licensePoolConfigurationCreationRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

licensepool.write Write access to license pool resources

Parameters

Body parameters
Name Description
licensePoolConfigurationCreationRequest

Query parameters
Name Description
api-version*
String
Required

Responses

LicensePoolFilter

getLicensePoolFilters

Get available license pool filters

Returns a list of license pool filters that are not assigned to any license pool group.


/license-pool/filters

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://uknapiproxy.coreview.com/public/license-pool/filters?api-version=apiVersion_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LicensePoolFilterApi;

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

public class LicensePoolFilterApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        LicensePoolFilterApi apiInstance = new LicensePoolFilterApi();
        String apiVersion = apiVersion_example; // String | 

        try {
            array[QueryFilter] result = apiInstance.getLicensePoolFilters(apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolFilterApi#getLicensePoolFilters");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String apiVersion = new String(); // String | 

try {
    final result = await api_instance.getLicensePoolFilters(apiVersion);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getLicensePoolFilters: $e\n');
}


import org.openapitools.client.api.LicensePoolFilterApi;

public class LicensePoolFilterApiExample {
    public static void main(String[] args) {
        LicensePoolFilterApi apiInstance = new LicensePoolFilterApi();
        String apiVersion = apiVersion_example; // String | 

        try {
            array[QueryFilter] result = apiInstance.getLicensePoolFilters(apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolFilterApi#getLicensePoolFilters");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
LicensePoolFilterApi *apiInstance = [[LicensePoolFilterApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)

// Get available license pool filters
[apiInstance getLicensePoolFiltersWith:apiVersion
              completionHandler: ^(array[QueryFilter] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LicensePoolApi = require('license_pool_api');
var defaultClient = LicensePoolApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new LicensePoolApi.LicensePoolFilterApi()
var apiVersion = apiVersion_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getLicensePoolFilters(apiVersion, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getLicensePoolFiltersExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new LicensePoolFilterApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Get available license pool filters
                array[QueryFilter] result = apiInstance.getLicensePoolFilters(apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LicensePoolFilterApi.getLicensePoolFilters: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LicensePoolFilterApi();
$apiVersion = apiVersion_example; // String | 

try {
    $result = $api_instance->getLicensePoolFilters($apiVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LicensePoolFilterApi->getLicensePoolFilters: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LicensePoolFilterApi;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LicensePoolFilterApi->new();
my $apiVersion = apiVersion_example; # String | 

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

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.LicensePoolFilterApi()
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Get available license pool filters
    api_response = api_instance.get_license_pool_filters(apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LicensePoolFilterApi->getLicensePoolFilters: %s\n" % e)
extern crate LicensePoolFilterApi;

pub fn main() {
    let apiVersion = apiVersion_example; // String

    let mut context = LicensePoolFilterApi::Context::default();
    let result = client.getLicensePoolFilters(apiVersion, &context).wait();

    println!("{:?}", result);
}

Scopes

licensepool.read Read access to license pool resources

Parameters

Query parameters
Name Description
api-version*
String
Required

Responses

LicensePoolGroup

createLicensePoolGroup

Create a license pool group

Create a license pool group, using the LicensePoolGroup in the body.


/license-pool/groups

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://uknapiproxy.coreview.com/public/license-pool/groups?api-version=apiVersion_example" \
 -d '{
  "notes" : "notes",
  "pricePerUser" : 2.3021358869347655,
  "pricePerActiveUser" : 7.061401241503109,
  "description" : "description",
  "filters" : [ {
    "condition" : "condition",
    "name" : "name",
    "valueDate" : "valueDate",
    "value" : "value",
    "operation" : "operation"
  }, {
    "condition" : "condition",
    "name" : "name",
    "valueDate" : "valueDate",
    "value" : "value",
    "operation" : "operation"
  } ],
  "operatorsGroups" : [ {
    "name" : "name",
    "id" : "id",
    "type" : "DistributionGroup",
    "parentId" : "parentId"
  }, {
    "name" : "name",
    "id" : "id",
    "type" : "DistributionGroup",
    "parentId" : "parentId"
  } ],
  "licensePoolInfos" : [ {
    "userGroupId" : "userGroupId",
    "skuPartNumber" : "skuPartNumber",
    "consumed" : 5,
    "groupName" : "groupName",
    "total" : 0,
    "available" : 6,
    "assigned" : 1,
    "sku" : "sku",
    "notAssigned" : 5,
    "isActive" : true,
    "skuId" : "skuId"
  }, {
    "userGroupId" : "userGroupId",
    "skuPartNumber" : "skuPartNumber",
    "consumed" : 5,
    "groupName" : "groupName",
    "total" : 0,
    "available" : 6,
    "assigned" : 1,
    "sku" : "sku",
    "notAssigned" : 5,
    "isActive" : true,
    "skuId" : "skuId"
  } ],
  "operators" : [ "operators", "operators" ],
  "valueToAssign" : "valueToAssign",
  "name" : "name",
  "currency" : "currency",
  "id" : "id",
  "pricePerLicensePool" : 9.301444243932576
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LicensePoolGroupApi;

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

public class LicensePoolGroupApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        LicensePoolGroupApi apiInstance = new LicensePoolGroupApi();
        String apiVersion = apiVersion_example; // String | 
        LicensePoolGroup licensePoolGroup = ; // LicensePoolGroup | 

        try {
            CreatedResult result = apiInstance.createLicensePoolGroup(apiVersion, licensePoolGroup);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolGroupApi#createLicensePoolGroup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String apiVersion = new String(); // String | 
final LicensePoolGroup licensePoolGroup = new LicensePoolGroup(); // LicensePoolGroup | 

try {
    final result = await api_instance.createLicensePoolGroup(apiVersion, licensePoolGroup);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createLicensePoolGroup: $e\n');
}


import org.openapitools.client.api.LicensePoolGroupApi;

public class LicensePoolGroupApiExample {
    public static void main(String[] args) {
        LicensePoolGroupApi apiInstance = new LicensePoolGroupApi();
        String apiVersion = apiVersion_example; // String | 
        LicensePoolGroup licensePoolGroup = ; // LicensePoolGroup | 

        try {
            CreatedResult result = apiInstance.createLicensePoolGroup(apiVersion, licensePoolGroup);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolGroupApi#createLicensePoolGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
LicensePoolGroupApi *apiInstance = [[LicensePoolGroupApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)
LicensePoolGroup *licensePoolGroup = ; //  (optional)

// Create a license pool group
[apiInstance createLicensePoolGroupWith:apiVersion
    licensePoolGroup:licensePoolGroup
              completionHandler: ^(CreatedResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LicensePoolApi = require('license_pool_api');
var defaultClient = LicensePoolApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new LicensePoolApi.LicensePoolGroupApi()
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'licensePoolGroup':  // {LicensePoolGroup} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createLicensePoolGroup(apiVersion, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class createLicensePoolGroupExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new LicensePoolGroupApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var licensePoolGroup = new LicensePoolGroup(); // LicensePoolGroup |  (optional) 

            try {
                // Create a license pool group
                CreatedResult result = apiInstance.createLicensePoolGroup(apiVersion, licensePoolGroup);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LicensePoolGroupApi.createLicensePoolGroup: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LicensePoolGroupApi();
$apiVersion = apiVersion_example; // String | 
$licensePoolGroup = ; // LicensePoolGroup | 

try {
    $result = $api_instance->createLicensePoolGroup($apiVersion, $licensePoolGroup);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LicensePoolGroupApi->createLicensePoolGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LicensePoolGroupApi;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LicensePoolGroupApi->new();
my $apiVersion = apiVersion_example; # String | 
my $licensePoolGroup = WWW::OPenAPIClient::Object::LicensePoolGroup->new(); # LicensePoolGroup | 

eval {
    my $result = $api_instance->createLicensePoolGroup(apiVersion => $apiVersion, licensePoolGroup => $licensePoolGroup);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LicensePoolGroupApi->createLicensePoolGroup: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.LicensePoolGroupApi()
apiVersion = apiVersion_example # String |  (default to null)
licensePoolGroup =  # LicensePoolGroup |  (optional)

try:
    # Create a license pool group
    api_response = api_instance.create_license_pool_group(apiVersion, licensePoolGroup=licensePoolGroup)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LicensePoolGroupApi->createLicensePoolGroup: %s\n" % e)
extern crate LicensePoolGroupApi;

pub fn main() {
    let apiVersion = apiVersion_example; // String
    let licensePoolGroup = ; // LicensePoolGroup

    let mut context = LicensePoolGroupApi::Context::default();
    let result = client.createLicensePoolGroup(apiVersion, licensePoolGroup, &context).wait();

    println!("{:?}", result);
}

Scopes

licensepool.write Write access to license pool resources

Parameters

Body parameters
Name Description
licensePoolGroup

Query parameters
Name Description
api-version*
String
Required

Responses

deleteLicensePoolGroup

Delete a specific license pool group

Deletes a license pool group with the given id.


/license-pool/groups/{id}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://uknapiproxy.coreview.com/public/license-pool/groups/{id}?api-version=apiVersion_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LicensePoolGroupApi;

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

public class LicensePoolGroupApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        LicensePoolGroupApi apiInstance = new LicensePoolGroupApi();
        String id = id_example; // String | The unique identifier for the license pool group.
        String apiVersion = apiVersion_example; // String | 

        try {
            OkResult result = apiInstance.deleteLicensePoolGroup(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolGroupApi#deleteLicensePoolGroup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The unique identifier for the license pool group.
final String apiVersion = new String(); // String | 

try {
    final result = await api_instance.deleteLicensePoolGroup(id, apiVersion);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteLicensePoolGroup: $e\n');
}


import org.openapitools.client.api.LicensePoolGroupApi;

public class LicensePoolGroupApiExample {
    public static void main(String[] args) {
        LicensePoolGroupApi apiInstance = new LicensePoolGroupApi();
        String id = id_example; // String | The unique identifier for the license pool group.
        String apiVersion = apiVersion_example; // String | 

        try {
            OkResult result = apiInstance.deleteLicensePoolGroup(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolGroupApi#deleteLicensePoolGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
LicensePoolGroupApi *apiInstance = [[LicensePoolGroupApi alloc] init];
String *id = id_example; // The unique identifier for the license pool group. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Delete a specific license pool group
[apiInstance deleteLicensePoolGroupWith:id
    apiVersion:apiVersion
              completionHandler: ^(OkResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LicensePoolApi = require('license_pool_api');
var defaultClient = LicensePoolApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new LicensePoolApi.LicensePoolGroupApi()
var id = id_example; // {String} The unique identifier for the license pool group.
var apiVersion = apiVersion_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteLicensePoolGroup(id, apiVersion, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteLicensePoolGroupExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new LicensePoolGroupApi();
            var id = id_example;  // String | The unique identifier for the license pool group. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Delete a specific license pool group
                OkResult result = apiInstance.deleteLicensePoolGroup(id, apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LicensePoolGroupApi.deleteLicensePoolGroup: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LicensePoolGroupApi();
$id = id_example; // String | The unique identifier for the license pool group.
$apiVersion = apiVersion_example; // String | 

try {
    $result = $api_instance->deleteLicensePoolGroup($id, $apiVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LicensePoolGroupApi->deleteLicensePoolGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LicensePoolGroupApi;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LicensePoolGroupApi->new();
my $id = id_example; # String | The unique identifier for the license pool group.
my $apiVersion = apiVersion_example; # String | 

eval {
    my $result = $api_instance->deleteLicensePoolGroup(id => $id, apiVersion => $apiVersion);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LicensePoolGroupApi->deleteLicensePoolGroup: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.LicensePoolGroupApi()
id = id_example # String | The unique identifier for the license pool group. (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Delete a specific license pool group
    api_response = api_instance.delete_license_pool_group(id, apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LicensePoolGroupApi->deleteLicensePoolGroup: %s\n" % e)
extern crate LicensePoolGroupApi;

pub fn main() {
    let id = id_example; // String
    let apiVersion = apiVersion_example; // String

    let mut context = LicensePoolGroupApi::Context::default();
    let result = client.deleteLicensePoolGroup(id, apiVersion, &context).wait();

    println!("{:?}", result);
}

Scopes

licensepool.write Write access to license pool resources

Parameters

Path parameters
Name Description
id*
String
The unique identifier for the license pool group.
Required
Query parameters
Name Description
api-version*
String
Required

Responses

getLicensePoolGroup

Get a single license pool group

Returns a single license pool group having the given id.


/license-pool/groups/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://uknapiproxy.coreview.com/public/license-pool/groups/{id}?api-version=apiVersion_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LicensePoolGroupApi;

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

public class LicensePoolGroupApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        LicensePoolGroupApi apiInstance = new LicensePoolGroupApi();
        String id = id_example; // String | The unique identifier for the LicensePoolGroup.
        String apiVersion = apiVersion_example; // String | 

        try {
            LicensePoolGroup result = apiInstance.getLicensePoolGroup(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolGroupApi#getLicensePoolGroup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The unique identifier for the LicensePoolGroup.
final String apiVersion = new String(); // String | 

try {
    final result = await api_instance.getLicensePoolGroup(id, apiVersion);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getLicensePoolGroup: $e\n');
}


import org.openapitools.client.api.LicensePoolGroupApi;

public class LicensePoolGroupApiExample {
    public static void main(String[] args) {
        LicensePoolGroupApi apiInstance = new LicensePoolGroupApi();
        String id = id_example; // String | The unique identifier for the LicensePoolGroup.
        String apiVersion = apiVersion_example; // String | 

        try {
            LicensePoolGroup result = apiInstance.getLicensePoolGroup(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolGroupApi#getLicensePoolGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
LicensePoolGroupApi *apiInstance = [[LicensePoolGroupApi alloc] init];
String *id = id_example; // The unique identifier for the LicensePoolGroup. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Get a single license pool group
[apiInstance getLicensePoolGroupWith:id
    apiVersion:apiVersion
              completionHandler: ^(LicensePoolGroup output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LicensePoolApi = require('license_pool_api');
var defaultClient = LicensePoolApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new LicensePoolApi.LicensePoolGroupApi()
var id = id_example; // {String} The unique identifier for the LicensePoolGroup.
var apiVersion = apiVersion_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getLicensePoolGroup(id, apiVersion, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getLicensePoolGroupExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new LicensePoolGroupApi();
            var id = id_example;  // String | The unique identifier for the LicensePoolGroup. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Get a single license pool group
                LicensePoolGroup result = apiInstance.getLicensePoolGroup(id, apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LicensePoolGroupApi.getLicensePoolGroup: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LicensePoolGroupApi();
$id = id_example; // String | The unique identifier for the LicensePoolGroup.
$apiVersion = apiVersion_example; // String | 

try {
    $result = $api_instance->getLicensePoolGroup($id, $apiVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LicensePoolGroupApi->getLicensePoolGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LicensePoolGroupApi;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LicensePoolGroupApi->new();
my $id = id_example; # String | The unique identifier for the LicensePoolGroup.
my $apiVersion = apiVersion_example; # String | 

eval {
    my $result = $api_instance->getLicensePoolGroup(id => $id, apiVersion => $apiVersion);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LicensePoolGroupApi->getLicensePoolGroup: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.LicensePoolGroupApi()
id = id_example # String | The unique identifier for the LicensePoolGroup. (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Get a single license pool group
    api_response = api_instance.get_license_pool_group(id, apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LicensePoolGroupApi->getLicensePoolGroup: %s\n" % e)
extern crate LicensePoolGroupApi;

pub fn main() {
    let id = id_example; // String
    let apiVersion = apiVersion_example; // String

    let mut context = LicensePoolGroupApi::Context::default();
    let result = client.getLicensePoolGroup(id, apiVersion, &context).wait();

    println!("{:?}", result);
}

Scopes

licensepool.read Read access to license pool resources

Parameters

Path parameters
Name Description
id*
String
The unique identifier for the LicensePoolGroup.
Required
Query parameters
Name Description
api-version*
String
Required

Responses

getLicensePoolGroups

Get the License Pool group

Returns the License Pool group.


/license-pool/groups

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://uknapiproxy.coreview.com/public/license-pool/groups?PageNumber=56&PageSize=56&Sort=sort_example&SortOrder=sortOrder_example&Fields=&RetrieveTotal=true&api-version=apiVersion_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LicensePoolGroupApi;

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

public class LicensePoolGroupApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        LicensePoolGroupApi apiInstance = new LicensePoolGroupApi();
        String apiVersion = apiVersion_example; // String | 
        Integer pageNumber = 56; // Integer | 
        Integer pageSize = 56; // Integer | 
        String sort = sort_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        array[String] fields = ; // array[String] | 
        Boolean retrieveTotal = true; // Boolean | 

        try {
            LicensePoolGroupPagedResponse result = apiInstance.getLicensePoolGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolGroupApi#getLicensePoolGroups");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String apiVersion = new String(); // String | 
final Integer pageNumber = new Integer(); // Integer | 
final Integer pageSize = new Integer(); // Integer | 
final String sort = new String(); // String | 
final String sortOrder = new String(); // String | 
final array[String] fields = new array[String](); // array[String] | 
final Boolean retrieveTotal = new Boolean(); // Boolean | 

try {
    final result = await api_instance.getLicensePoolGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getLicensePoolGroups: $e\n');
}


import org.openapitools.client.api.LicensePoolGroupApi;

public class LicensePoolGroupApiExample {
    public static void main(String[] args) {
        LicensePoolGroupApi apiInstance = new LicensePoolGroupApi();
        String apiVersion = apiVersion_example; // String | 
        Integer pageNumber = 56; // Integer | 
        Integer pageSize = 56; // Integer | 
        String sort = sort_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        array[String] fields = ; // array[String] | 
        Boolean retrieveTotal = true; // Boolean | 

        try {
            LicensePoolGroupPagedResponse result = apiInstance.getLicensePoolGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolGroupApi#getLicensePoolGroups");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
LicensePoolGroupApi *apiInstance = [[LicensePoolGroupApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)
Integer *pageNumber = 56; //  (optional) (default to null)
Integer *pageSize = 56; //  (optional) (default to null)
String *sort = sort_example; //  (optional) (default to null)
String *sortOrder = sortOrder_example; //  (optional) (default to null)
array[String] *fields = ; //  (optional) (default to null)
Boolean *retrieveTotal = true; //  (optional) (default to null)

// Get the License Pool group
[apiInstance getLicensePoolGroupsWith:apiVersion
    pageNumber:pageNumber
    pageSize:pageSize
    sort:sort
    sortOrder:sortOrder
    fields:fields
    retrieveTotal:retrieveTotal
              completionHandler: ^(LicensePoolGroupPagedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LicensePoolApi = require('license_pool_api');
var defaultClient = LicensePoolApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new LicensePoolApi.LicensePoolGroupApi()
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'pageNumber': 56, // {Integer} 
  'pageSize': 56, // {Integer} 
  'sort': sort_example, // {String} 
  'sortOrder': sortOrder_example, // {String} 
  'fields': , // {array[String]} 
  'retrieveTotal': true // {Boolean} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getLicensePoolGroups(apiVersion, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getLicensePoolGroupsExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new LicensePoolGroupApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var pageNumber = 56;  // Integer |  (optional)  (default to null)
            var pageSize = 56;  // Integer |  (optional)  (default to null)
            var sort = sort_example;  // String |  (optional)  (default to null)
            var sortOrder = sortOrder_example;  // String |  (optional)  (default to null)
            var fields = new array[String](); // array[String] |  (optional)  (default to null)
            var retrieveTotal = true;  // Boolean |  (optional)  (default to null)

            try {
                // Get the License Pool group
                LicensePoolGroupPagedResponse result = apiInstance.getLicensePoolGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LicensePoolGroupApi.getLicensePoolGroups: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LicensePoolGroupApi();
$apiVersion = apiVersion_example; // String | 
$pageNumber = 56; // Integer | 
$pageSize = 56; // Integer | 
$sort = sort_example; // String | 
$sortOrder = sortOrder_example; // String | 
$fields = ; // array[String] | 
$retrieveTotal = true; // Boolean | 

try {
    $result = $api_instance->getLicensePoolGroups($apiVersion, $pageNumber, $pageSize, $sort, $sortOrder, $fields, $retrieveTotal);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LicensePoolGroupApi->getLicensePoolGroups: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LicensePoolGroupApi;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LicensePoolGroupApi->new();
my $apiVersion = apiVersion_example; # String | 
my $pageNumber = 56; # Integer | 
my $pageSize = 56; # Integer | 
my $sort = sort_example; # String | 
my $sortOrder = sortOrder_example; # String | 
my $fields = []; # array[String] | 
my $retrieveTotal = true; # Boolean | 

eval {
    my $result = $api_instance->getLicensePoolGroups(apiVersion => $apiVersion, pageNumber => $pageNumber, pageSize => $pageSize, sort => $sort, sortOrder => $sortOrder, fields => $fields, retrieveTotal => $retrieveTotal);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LicensePoolGroupApi->getLicensePoolGroups: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.LicensePoolGroupApi()
apiVersion = apiVersion_example # String |  (default to null)
pageNumber = 56 # Integer |  (optional) (default to null)
pageSize = 56 # Integer |  (optional) (default to null)
sort = sort_example # String |  (optional) (default to null)
sortOrder = sortOrder_example # String |  (optional) (default to null)
fields =  # array[String] |  (optional) (default to null)
retrieveTotal = true # Boolean |  (optional) (default to null)

try:
    # Get the License Pool group
    api_response = api_instance.get_license_pool_groups(apiVersion, pageNumber=pageNumber, pageSize=pageSize, sort=sort, sortOrder=sortOrder, fields=fields, retrieveTotal=retrieveTotal)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LicensePoolGroupApi->getLicensePoolGroups: %s\n" % e)
extern crate LicensePoolGroupApi;

pub fn main() {
    let apiVersion = apiVersion_example; // String
    let pageNumber = 56; // Integer
    let pageSize = 56; // Integer
    let sort = sort_example; // String
    let sortOrder = sortOrder_example; // String
    let fields = ; // array[String]
    let retrieveTotal = true; // Boolean

    let mut context = LicensePoolGroupApi::Context::default();
    let result = client.getLicensePoolGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal, &context).wait();

    println!("{:?}", result);
}

Scopes

licensepool.read Read access to license pool resources

Parameters

Query parameters
Name Description
PageNumber
Integer (int32)
PageSize
Integer (int32)
Sort
String
SortOrder
String
Fields
array[String]
RetrieveTotal
Boolean
api-version*
String
Required

Responses

updateLicensePoolGroup

Update a license pool group

Update a license pool group, using the LicensePoolGroup in the body.


/license-pool/groups/{id}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://uknapiproxy.coreview.com/public/license-pool/groups/{id}?api-version=apiVersion_example" \
 -d '{
  "notes" : "notes",
  "pricePerUser" : 2.3021358869347655,
  "pricePerActiveUser" : 7.061401241503109,
  "description" : "description",
  "filters" : [ {
    "condition" : "condition",
    "name" : "name",
    "valueDate" : "valueDate",
    "value" : "value",
    "operation" : "operation"
  }, {
    "condition" : "condition",
    "name" : "name",
    "valueDate" : "valueDate",
    "value" : "value",
    "operation" : "operation"
  } ],
  "operatorsGroups" : [ {
    "name" : "name",
    "id" : "id",
    "type" : "DistributionGroup",
    "parentId" : "parentId"
  }, {
    "name" : "name",
    "id" : "id",
    "type" : "DistributionGroup",
    "parentId" : "parentId"
  } ],
  "licensePoolInfos" : [ {
    "userGroupId" : "userGroupId",
    "skuPartNumber" : "skuPartNumber",
    "consumed" : 5,
    "groupName" : "groupName",
    "total" : 0,
    "available" : 6,
    "assigned" : 1,
    "sku" : "sku",
    "notAssigned" : 5,
    "isActive" : true,
    "skuId" : "skuId"
  }, {
    "userGroupId" : "userGroupId",
    "skuPartNumber" : "skuPartNumber",
    "consumed" : 5,
    "groupName" : "groupName",
    "total" : 0,
    "available" : 6,
    "assigned" : 1,
    "sku" : "sku",
    "notAssigned" : 5,
    "isActive" : true,
    "skuId" : "skuId"
  } ],
  "operators" : [ "operators", "operators" ],
  "valueToAssign" : "valueToAssign",
  "name" : "name",
  "currency" : "currency",
  "id" : "id",
  "pricePerLicensePool" : 9.301444243932576
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LicensePoolGroupApi;

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

public class LicensePoolGroupApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        LicensePoolGroupApi apiInstance = new LicensePoolGroupApi();
        String id = id_example; // String | The unique identifier for the LicensePoolGroup.
        String apiVersion = apiVersion_example; // String | 
        LicensePoolGroup licensePoolGroup = ; // LicensePoolGroup | 

        try {
            LicensePoolGroup result = apiInstance.updateLicensePoolGroup(id, apiVersion, licensePoolGroup);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolGroupApi#updateLicensePoolGroup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The unique identifier for the LicensePoolGroup.
final String apiVersion = new String(); // String | 
final LicensePoolGroup licensePoolGroup = new LicensePoolGroup(); // LicensePoolGroup | 

try {
    final result = await api_instance.updateLicensePoolGroup(id, apiVersion, licensePoolGroup);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateLicensePoolGroup: $e\n');
}


import org.openapitools.client.api.LicensePoolGroupApi;

public class LicensePoolGroupApiExample {
    public static void main(String[] args) {
        LicensePoolGroupApi apiInstance = new LicensePoolGroupApi();
        String id = id_example; // String | The unique identifier for the LicensePoolGroup.
        String apiVersion = apiVersion_example; // String | 
        LicensePoolGroup licensePoolGroup = ; // LicensePoolGroup | 

        try {
            LicensePoolGroup result = apiInstance.updateLicensePoolGroup(id, apiVersion, licensePoolGroup);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LicensePoolGroupApi#updateLicensePoolGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
LicensePoolGroupApi *apiInstance = [[LicensePoolGroupApi alloc] init];
String *id = id_example; // The unique identifier for the LicensePoolGroup. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)
LicensePoolGroup *licensePoolGroup = ; //  (optional)

// Update a license pool group
[apiInstance updateLicensePoolGroupWith:id
    apiVersion:apiVersion
    licensePoolGroup:licensePoolGroup
              completionHandler: ^(LicensePoolGroup output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LicensePoolApi = require('license_pool_api');
var defaultClient = LicensePoolApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: oauth2
var oauth2 = defaultClient.authentications['oauth2'];
oauth2.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new LicensePoolApi.LicensePoolGroupApi()
var id = id_example; // {String} The unique identifier for the LicensePoolGroup.
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'licensePoolGroup':  // {LicensePoolGroup} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateLicensePoolGroup(id, apiVersion, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateLicensePoolGroupExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new LicensePoolGroupApi();
            var id = id_example;  // String | The unique identifier for the LicensePoolGroup. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var licensePoolGroup = new LicensePoolGroup(); // LicensePoolGroup |  (optional) 

            try {
                // Update a license pool group
                LicensePoolGroup result = apiInstance.updateLicensePoolGroup(id, apiVersion, licensePoolGroup);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LicensePoolGroupApi.updateLicensePoolGroup: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: oauth2
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LicensePoolGroupApi();
$id = id_example; // String | The unique identifier for the LicensePoolGroup.
$apiVersion = apiVersion_example; // String | 
$licensePoolGroup = ; // LicensePoolGroup | 

try {
    $result = $api_instance->updateLicensePoolGroup($id, $apiVersion, $licensePoolGroup);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LicensePoolGroupApi->updateLicensePoolGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LicensePoolGroupApi;

# Configure OAuth2 access token for authorization: oauth2
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LicensePoolGroupApi->new();
my $id = id_example; # String | The unique identifier for the LicensePoolGroup.
my $apiVersion = apiVersion_example; # String | 
my $licensePoolGroup = WWW::OPenAPIClient::Object::LicensePoolGroup->new(); # LicensePoolGroup | 

eval {
    my $result = $api_instance->updateLicensePoolGroup(id => $id, apiVersion => $apiVersion, licensePoolGroup => $licensePoolGroup);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LicensePoolGroupApi->updateLicensePoolGroup: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: oauth2
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.LicensePoolGroupApi()
id = id_example # String | The unique identifier for the LicensePoolGroup. (default to null)
apiVersion = apiVersion_example # String |  (default to null)
licensePoolGroup =  # LicensePoolGroup |  (optional)

try:
    # Update a license pool group
    api_response = api_instance.update_license_pool_group(id, apiVersion, licensePoolGroup=licensePoolGroup)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LicensePoolGroupApi->updateLicensePoolGroup: %s\n" % e)
extern crate LicensePoolGroupApi;

pub fn main() {
    let id = id_example; // String
    let apiVersion = apiVersion_example; // String
    let licensePoolGroup = ; // LicensePoolGroup

    let mut context = LicensePoolGroupApi::Context::default();
    let result = client.updateLicensePoolGroup(id, apiVersion, licensePoolGroup, &context).wait();

    println!("{:?}", result);
}

Scopes

licensepool.write Write access to license pool resources

Parameters

Path parameters
Name Description
id*
String
The unique identifier for the LicensePoolGroup.
Required
Body parameters
Name Description
licensePoolGroup

Query parameters
Name Description
api-version*
String
Required

Responses