Operator Api

OperatorGroups

createOperatorGroup

Create a operator group

Creates a operator group using the definition in the body.

/operator/groups

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/operator/groups?api-version=apiVersion_example" \
 -d '{
  "groupType" : "groupType",
  "permissions" : [ "permissions", "permissions" ],
  "roles" : [ "roles", "roles" ],
  "name" : "name",
  "id" : "id"
}'

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

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

public class OperatorGroupsApiExample {
    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
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String apiVersion = apiVersion_example; // String | 
        OperatorGroup operatorGroup = ; // OperatorGroup | 

        try {
            apiInstance.createOperatorGroup(apiVersion, operatorGroup);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#createOperatorGroup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.OperatorGroupsApi;

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String apiVersion = apiVersion_example; // String | 
        OperatorGroup operatorGroup = ; // OperatorGroup | 

        try {
            apiInstance.createOperatorGroup(apiVersion, operatorGroup);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#createOperatorGroup");
            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
OperatorGroupsApi *apiInstance = [[OperatorGroupsApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)
OperatorGroup *operatorGroup = ; //  (optional)

// Create a operator group
[apiInstance createOperatorGroupWith:apiVersion
    operatorGroup:operatorGroup
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorGroupsApi()
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'operatorGroup':  // {OperatorGroup} 
};

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

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

namespace Example
{
    public class createOperatorGroupExample
    {
        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 OperatorGroupsApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var operatorGroup = new OperatorGroup(); // OperatorGroup |  (optional) 

            try {
                // Create a operator group
                apiInstance.createOperatorGroup(apiVersion, operatorGroup);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorGroupsApi.createOperatorGroup: " + 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\OperatorGroupsApi();
$apiVersion = apiVersion_example; // String | 
$operatorGroup = ; // OperatorGroup | 

try {
    $api_instance->createOperatorGroup($apiVersion, $operatorGroup);
} catch (Exception $e) {
    echo 'Exception when calling OperatorGroupsApi->createOperatorGroup: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorGroupsApi;

# 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::OperatorGroupsApi->new();
my $apiVersion = apiVersion_example; # String | 
my $operatorGroup = WWW::OPenAPIClient::Object::OperatorGroup->new(); # OperatorGroup | 

eval {
    $api_instance->createOperatorGroup(apiVersion => $apiVersion, operatorGroup => $operatorGroup);
};
if ($@) {
    warn "Exception when calling OperatorGroupsApi->createOperatorGroup: $@\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.OperatorGroupsApi()
apiVersion = apiVersion_example # String |  (default to null)
operatorGroup =  # OperatorGroup |  (optional)

try:
    # Create a operator group
    api_instance.create_operator_group(apiVersion, operatorGroup=operatorGroup)
except ApiException as e:
    print("Exception when calling OperatorGroupsApi->createOperatorGroup: %s\n" % e)

extern crate OperatorGroupsApi;

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

    let mut context = OperatorGroupsApi::Context::default();
    let result = client.createOperatorGroup(apiVersion, operatorGroup, &context).wait();

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

Scopes

operator.write

Write access to operator and operator group resources

Parameters

Body parameters

Name	Description
operatorGroup

Query parameters

Name	Description
api-version*	String Required

Responses

Schema

Schema

deleteOperatorGroup

Delete a operator group

Delete a operator group having the given id.

/operator/groups/{id}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "http://localhost/operator/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.OperatorGroupsApi;

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

public class OperatorGroupsApiExample {
    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
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String id = id_example; // String | The unique identifier for the operator group.
        String apiVersion = apiVersion_example; // String | 

        try {
            apiInstance.deleteOperatorGroup(id, apiVersion);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#deleteOperatorGroup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.OperatorGroupsApi;

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

        try {
            apiInstance.deleteOperatorGroup(id, apiVersion);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#deleteOperatorGroup");
            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
OperatorGroupsApi *apiInstance = [[OperatorGroupsApi alloc] init];
String *id = id_example; // The unique identifier for the operator group. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Delete a operator group
[apiInstance deleteOperatorGroupWith:id
    apiVersion:apiVersion
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorGroupsApi()
var id = id_example; // {String} The unique identifier for the operator group.
var apiVersion = apiVersion_example; // {String} 

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

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

namespace Example
{
    public class deleteOperatorGroupExample
    {
        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 OperatorGroupsApi();
            var id = id_example;  // String | The unique identifier for the operator group. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Delete a operator group
                apiInstance.deleteOperatorGroup(id, apiVersion);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorGroupsApi.deleteOperatorGroup: " + 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\OperatorGroupsApi();
$id = id_example; // String | The unique identifier for the operator group.
$apiVersion = apiVersion_example; // String | 

try {
    $api_instance->deleteOperatorGroup($id, $apiVersion);
} catch (Exception $e) {
    echo 'Exception when calling OperatorGroupsApi->deleteOperatorGroup: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorGroupsApi;

# 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::OperatorGroupsApi->new();
my $id = id_example; # String | The unique identifier for the operator group.
my $apiVersion = apiVersion_example; # String | 

eval {
    $api_instance->deleteOperatorGroup(id => $id, apiVersion => $apiVersion);
};
if ($@) {
    warn "Exception when calling OperatorGroupsApi->deleteOperatorGroup: $@\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.OperatorGroupsApi()
id = id_example # String | The unique identifier for the operator group. (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Delete a operator group
    api_instance.delete_operator_group(id, apiVersion)
except ApiException as e:
    print("Exception when calling OperatorGroupsApi->deleteOperatorGroup: %s\n" % e)

extern crate OperatorGroupsApi;

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

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

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

Scopes

operator.write

Write access to operator and operator group resources

Parameters

Path parameters

Name	Description
id*	String The unique identifier for the operator group. Required

Query parameters

Name	Description
api-version*	String Required

Responses

Schema

Schema

getOperatorGroup

Get the single operator group

Returns a single operator group having the given id.

/operator/groups/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "http://localhost/operator/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.OperatorGroupsApi;

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

public class OperatorGroupsApiExample {
    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
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String id = id_example; // String | The unique identifier for the operator group.
        String apiVersion = apiVersion_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.OperatorGroupsApi;

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

        try {
            OperatorGroup result = apiInstance.getOperatorGroup(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#getOperatorGroup");
            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
OperatorGroupsApi *apiInstance = [[OperatorGroupsApi alloc] init];
String *id = id_example; // The unique identifier for the operator group. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Get the single operator group
[apiInstance getOperatorGroupWith:id
    apiVersion:apiVersion
              completionHandler: ^(OperatorGroup output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorGroupsApi()
var id = id_example; // {String} The unique identifier for the operator 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.getOperatorGroup(id, apiVersion, callback);

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

namespace Example
{
    public class getOperatorGroupExample
    {
        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 OperatorGroupsApi();
            var id = id_example;  // String | The unique identifier for the operator group. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Get the single operator group
                OperatorGroup result = apiInstance.getOperatorGroup(id, apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorGroupsApi.getOperatorGroup: " + 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\OperatorGroupsApi();
$id = id_example; // String | The unique identifier for the operator group.
$apiVersion = apiVersion_example; // String | 

try {
    $result = $api_instance->getOperatorGroup($id, $apiVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorGroupsApi->getOperatorGroup: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorGroupsApi;

# 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::OperatorGroupsApi->new();
my $id = id_example; # String | The unique identifier for the operator group.
my $apiVersion = apiVersion_example; # String | 

eval {
    my $result = $api_instance->getOperatorGroup(id => $id, apiVersion => $apiVersion);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorGroupsApi->getOperatorGroup: $@\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.OperatorGroupsApi()
id = id_example # String | The unique identifier for the operator group. (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Get the single operator group
    api_response = api_instance.get_operator_group(id, apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorGroupsApi->getOperatorGroup: %s\n" % e)

extern crate OperatorGroupsApi;

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

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

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

Scopes

operator.read

Read access to operator and operator group resources

Parameters

Path parameters

Name	Description
id*	String The unique identifier for the operator group. Required

Query parameters

Name	Description
api-version*	String Required

Responses

Schema

Schema

Schema

getOperatorGroups

Get the list of operator groups

Returns the list of operator groups.

/operator/groups

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "http://localhost/operator/groups?PageNumber=56&PageSize=56&Sort=sort_example&SortOrder=sortOrder_example&Fields=&Filters=&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.OperatorGroupsApi;

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

public class OperatorGroupsApiExample {
    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
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        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] | 
        map[String, String] filters = ; // map[String, String] | 
        Boolean retrieveTotal = true; // Boolean | 

        try {
            OperatorGroupPagedResponse result = apiInstance.getOperatorGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, filters, retrieveTotal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#getOperatorGroups");
            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 map[String, String] filters = new map[String, String](); // map[String, String] | 
final Boolean retrieveTotal = new Boolean(); // Boolean | 

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

import org.openapitools.client.api.OperatorGroupsApi;

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        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] | 
        map[String, String] filters = ; // map[String, String] | 
        Boolean retrieveTotal = true; // Boolean | 

        try {
            OperatorGroupPagedResponse result = apiInstance.getOperatorGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, filters, retrieveTotal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#getOperatorGroups");
            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
OperatorGroupsApi *apiInstance = [[OperatorGroupsApi 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)
map[String, String] *filters = ; //  (optional) (default to null)
Boolean *retrieveTotal = true; //  (optional) (default to null)

// Get the list of operator groups
[apiInstance getOperatorGroupsWith:apiVersion
    pageNumber:pageNumber
    pageSize:pageSize
    sort:sort
    sortOrder:sortOrder
    fields:fields
    filters:filters
    retrieveTotal:retrieveTotal
              completionHandler: ^(OperatorGroupPagedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorGroupsApi()
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'pageNumber': 56, // {Integer} 
  'pageSize': 56, // {Integer} 
  'sort': sort_example, // {String} 
  'sortOrder': sortOrder_example, // {String} 
  'fields': , // {array[String]} 
  'filters': , // {map[String, 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.getOperatorGroups(apiVersion, opts, callback);

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

namespace Example
{
    public class getOperatorGroupsExample
    {
        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 OperatorGroupsApi();
            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 filters = new map[String, String](); // map[String, String] |  (optional)  (default to null)
            var retrieveTotal = true;  // Boolean |  (optional)  (default to null)

            try {
                // Get the list of operator groups
                OperatorGroupPagedResponse result = apiInstance.getOperatorGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, filters, retrieveTotal);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorGroupsApi.getOperatorGroups: " + 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\OperatorGroupsApi();
$apiVersion = apiVersion_example; // String | 
$pageNumber = 56; // Integer | 
$pageSize = 56; // Integer | 
$sort = sort_example; // String | 
$sortOrder = sortOrder_example; // String | 
$fields = ; // array[String] | 
$filters = ; // map[String, String] | 
$retrieveTotal = true; // Boolean | 

try {
    $result = $api_instance->getOperatorGroups($apiVersion, $pageNumber, $pageSize, $sort, $sortOrder, $fields, $filters, $retrieveTotal);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorGroupsApi->getOperatorGroups: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorGroupsApi;

# 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::OperatorGroupsApi->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 $filters = ; # map[String, String] | 
my $retrieveTotal = true; # Boolean | 

eval {
    my $result = $api_instance->getOperatorGroups(apiVersion => $apiVersion, pageNumber => $pageNumber, pageSize => $pageSize, sort => $sort, sortOrder => $sortOrder, fields => $fields, filters => $filters, retrieveTotal => $retrieveTotal);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorGroupsApi->getOperatorGroups: $@\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.OperatorGroupsApi()
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)
filters =  # map[String, String] |  (optional) (default to null)
retrieveTotal = true # Boolean |  (optional) (default to null)

try:
    # Get the list of operator groups
    api_response = api_instance.get_operator_groups(apiVersion, pageNumber=pageNumber, pageSize=pageSize, sort=sort, sortOrder=sortOrder, fields=fields, filters=filters, retrieveTotal=retrieveTotal)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorGroupsApi->getOperatorGroups: %s\n" % e)

extern crate OperatorGroupsApi;

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 filters = ; // map[String, String]
    let retrieveTotal = true; // Boolean

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

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

Scopes

operator.read

Read access to operator and operator group resources

Parameters

Query parameters

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

Responses

Schema

Schema

Schema

getRolesAndPermissionsForGroup

Gets roles and permissions assigned to an operator group of a virtual tenant

Gets all tenant wide roles and permission assigned to an operator group.

/operator/groups/{groupId}/roles-and-permissions

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "http://localhost/operator/groups/{groupId}/roles-and-permissions?api-version=apiVersion_example"

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

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

public class OperatorGroupsApiExample {
    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
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String groupId = groupId_example; // String | The unique identifier for the operator group.
        String apiVersion = apiVersion_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String groupId = new String(); // String | The unique identifier for the operator group.
final String apiVersion = new String(); // String | 

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

import org.openapitools.client.api.OperatorGroupsApi;

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String groupId = groupId_example; // String | The unique identifier for the operator group.
        String apiVersion = apiVersion_example; // String | 

        try {
            OkResult result = apiInstance.getRolesAndPermissionsForGroup(groupId, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#getRolesAndPermissionsForGroup");
            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
OperatorGroupsApi *apiInstance = [[OperatorGroupsApi alloc] init];
String *groupId = groupId_example; // The unique identifier for the operator group. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Gets roles and permissions assigned to an operator group of a virtual tenant
[apiInstance getRolesAndPermissionsForGroupWith:groupId
    apiVersion:apiVersion
              completionHandler: ^(OkResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorGroupsApi()
var groupId = groupId_example; // {String} The unique identifier for the operator 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.getRolesAndPermissionsForGroup(groupId, apiVersion, callback);

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

namespace Example
{
    public class getRolesAndPermissionsForGroupExample
    {
        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 OperatorGroupsApi();
            var groupId = groupId_example;  // String | The unique identifier for the operator group. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Gets roles and permissions assigned to an operator group of a virtual tenant
                OkResult result = apiInstance.getRolesAndPermissionsForGroup(groupId, apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorGroupsApi.getRolesAndPermissionsForGroup: " + 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\OperatorGroupsApi();
$groupId = groupId_example; // String | The unique identifier for the operator group.
$apiVersion = apiVersion_example; // String | 

try {
    $result = $api_instance->getRolesAndPermissionsForGroup($groupId, $apiVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorGroupsApi->getRolesAndPermissionsForGroup: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorGroupsApi;

# 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::OperatorGroupsApi->new();
my $groupId = groupId_example; # String | The unique identifier for the operator group.
my $apiVersion = apiVersion_example; # String | 

eval {
    my $result = $api_instance->getRolesAndPermissionsForGroup(groupId => $groupId, apiVersion => $apiVersion);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorGroupsApi->getRolesAndPermissionsForGroup: $@\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.OperatorGroupsApi()
groupId = groupId_example # String | The unique identifier for the operator group. (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Gets roles and permissions assigned to an operator group of a virtual tenant
    api_response = api_instance.get_roles_and_permissions_for_group(groupId, apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorGroupsApi->getRolesAndPermissionsForGroup: %s\n" % e)

extern crate OperatorGroupsApi;

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

    let mut context = OperatorGroupsApi::Context::default();
    let result = client.getRolesAndPermissionsForGroup(groupId, apiVersion, &context).wait();

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

Scopes

operator.read

Read access to operator and operator group resources

Parameters

Path parameters

Name	Description
groupId*	String The unique identifier for the operator group. Required

Query parameters

Name	Description
api-version*	String Required

Responses

Schema

Schema

Schema

getRolesAndPermissionsForGroupInVirtualTenant

Gets roles and permissions assigned to an operator group of a virtual tenant

Gets all tenant wide roles and permission assigned to an operator group and whether they are applied to a virtual tenant.

/operator/groups/{groupId}/roles-and-permissions/virtual-tenants/{virtualTenantId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/operator/groups/{groupId}/roles-and-permissions/virtual-tenants/{virtualTenantId}?api-version=apiVersion_example"

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

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

public class OperatorGroupsApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String groupId = groupId_example; // String | The unique identifier for the operator group.
        String virtualTenantId = virtualTenantId_example; // String | The unique identifier for the virtual tenant.
        String apiVersion = apiVersion_example; // String | 

        try {
            OkResult result = apiInstance.getRolesAndPermissionsForGroupInVirtualTenant(groupId, virtualTenantId, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#getRolesAndPermissionsForGroupInVirtualTenant");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String groupId = new String(); // String | The unique identifier for the operator group.
final String virtualTenantId = new String(); // String | The unique identifier for the virtual tenant.
final String apiVersion = new String(); // String | 

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

import org.openapitools.client.api.OperatorGroupsApi;

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String groupId = groupId_example; // String | The unique identifier for the operator group.
        String virtualTenantId = virtualTenantId_example; // String | The unique identifier for the virtual tenant.
        String apiVersion = apiVersion_example; // String | 

        try {
            OkResult result = apiInstance.getRolesAndPermissionsForGroupInVirtualTenant(groupId, virtualTenantId, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#getRolesAndPermissionsForGroupInVirtualTenant");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
OperatorGroupsApi *apiInstance = [[OperatorGroupsApi alloc] init];
String *groupId = groupId_example; // The unique identifier for the operator group. (default to null)
String *virtualTenantId = virtualTenantId_example; // The unique identifier for the virtual tenant. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Gets roles and permissions assigned to an operator group of a virtual tenant
[apiInstance getRolesAndPermissionsForGroupInVirtualTenantWith:groupId
    virtualTenantId:virtualTenantId
    apiVersion:apiVersion
              completionHandler: ^(OkResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');

// Create an instance of the API class
var api = new OperatorApi.OperatorGroupsApi()
var groupId = groupId_example; // {String} The unique identifier for the operator group.
var virtualTenantId = virtualTenantId_example; // {String} The unique identifier for the virtual tenant.
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.getRolesAndPermissionsForGroupInVirtualTenant(groupId, virtualTenantId, apiVersion, callback);

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

namespace Example
{
    public class getRolesAndPermissionsForGroupInVirtualTenantExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new OperatorGroupsApi();
            var groupId = groupId_example;  // String | The unique identifier for the operator group. (default to null)
            var virtualTenantId = virtualTenantId_example;  // String | The unique identifier for the virtual tenant. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Gets roles and permissions assigned to an operator group of a virtual tenant
                OkResult result = apiInstance.getRolesAndPermissionsForGroupInVirtualTenant(groupId, virtualTenantId, apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorGroupsApi.getRolesAndPermissionsForGroupInVirtualTenant: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperatorGroupsApi();
$groupId = groupId_example; // String | The unique identifier for the operator group.
$virtualTenantId = virtualTenantId_example; // String | The unique identifier for the virtual tenant.
$apiVersion = apiVersion_example; // String | 

try {
    $result = $api_instance->getRolesAndPermissionsForGroupInVirtualTenant($groupId, $virtualTenantId, $apiVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorGroupsApi->getRolesAndPermissionsForGroupInVirtualTenant: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorGroupsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperatorGroupsApi->new();
my $groupId = groupId_example; # String | The unique identifier for the operator group.
my $virtualTenantId = virtualTenantId_example; # String | The unique identifier for the virtual tenant.
my $apiVersion = apiVersion_example; # String | 

eval {
    my $result = $api_instance->getRolesAndPermissionsForGroupInVirtualTenant(groupId => $groupId, virtualTenantId => $virtualTenantId, apiVersion => $apiVersion);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorGroupsApi->getRolesAndPermissionsForGroupInVirtualTenant: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.OperatorGroupsApi()
groupId = groupId_example # String | The unique identifier for the operator group. (default to null)
virtualTenantId = virtualTenantId_example # String | The unique identifier for the virtual tenant. (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Gets roles and permissions assigned to an operator group of a virtual tenant
    api_response = api_instance.get_roles_and_permissions_for_group_in_virtual_tenant(groupId, virtualTenantId, apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorGroupsApi->getRolesAndPermissionsForGroupInVirtualTenant: %s\n" % e)

extern crate OperatorGroupsApi;

pub fn main() {
    let groupId = groupId_example; // String
    let virtualTenantId = virtualTenantId_example; // String
    let apiVersion = apiVersion_example; // String

    let mut context = OperatorGroupsApi::Context::default();
    let result = client.getRolesAndPermissionsForGroupInVirtualTenant(groupId, virtualTenantId, apiVersion, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
groupId*	String The unique identifier for the operator group. Required
virtualTenantId*	String The unique identifier for the virtual tenant. Required

Query parameters

Name	Description
api-version*	String Required

Responses

Schema

Schema

Schema

updateOperatorGroup

Update a operator group

Updates a operator group using the definition in the body.

/operator/groups/{id}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/operator/groups/{id}?api-version=apiVersion_example" \
 -d '{
  "groupType" : "groupType",
  "permissions" : [ "permissions", "permissions" ],
  "roles" : [ "roles", "roles" ],
  "name" : "name"
}'

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

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

public class OperatorGroupsApiExample {
    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
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String id = id_example; // String | The unique identifier for the operator group.
        String apiVersion = apiVersion_example; // String | 
        OperatorGroupUpdateRequest operatorGroupUpdateRequest = ; // OperatorGroupUpdateRequest | 

        try {
            OperatorGroup result = apiInstance.updateOperatorGroup(id, apiVersion, operatorGroupUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#updateOperatorGroup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The unique identifier for the operator group.
final String apiVersion = new String(); // String | 
final OperatorGroupUpdateRequest operatorGroupUpdateRequest = new OperatorGroupUpdateRequest(); // OperatorGroupUpdateRequest | 

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

import org.openapitools.client.api.OperatorGroupsApi;

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String id = id_example; // String | The unique identifier for the operator group.
        String apiVersion = apiVersion_example; // String | 
        OperatorGroupUpdateRequest operatorGroupUpdateRequest = ; // OperatorGroupUpdateRequest | 

        try {
            OperatorGroup result = apiInstance.updateOperatorGroup(id, apiVersion, operatorGroupUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#updateOperatorGroup");
            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
OperatorGroupsApi *apiInstance = [[OperatorGroupsApi alloc] init];
String *id = id_example; // The unique identifier for the operator group. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)
OperatorGroupUpdateRequest *operatorGroupUpdateRequest = ; //  (optional)

// Update a operator group
[apiInstance updateOperatorGroupWith:id
    apiVersion:apiVersion
    operatorGroupUpdateRequest:operatorGroupUpdateRequest
              completionHandler: ^(OperatorGroup output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorGroupsApi()
var id = id_example; // {String} The unique identifier for the operator group.
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'operatorGroupUpdateRequest':  // {OperatorGroupUpdateRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateOperatorGroup(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 updateOperatorGroupExample
    {
        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 OperatorGroupsApi();
            var id = id_example;  // String | The unique identifier for the operator group. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var operatorGroupUpdateRequest = new OperatorGroupUpdateRequest(); // OperatorGroupUpdateRequest |  (optional) 

            try {
                // Update a operator group
                OperatorGroup result = apiInstance.updateOperatorGroup(id, apiVersion, operatorGroupUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorGroupsApi.updateOperatorGroup: " + 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\OperatorGroupsApi();
$id = id_example; // String | The unique identifier for the operator group.
$apiVersion = apiVersion_example; // String | 
$operatorGroupUpdateRequest = ; // OperatorGroupUpdateRequest | 

try {
    $result = $api_instance->updateOperatorGroup($id, $apiVersion, $operatorGroupUpdateRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorGroupsApi->updateOperatorGroup: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorGroupsApi;

# 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::OperatorGroupsApi->new();
my $id = id_example; # String | The unique identifier for the operator group.
my $apiVersion = apiVersion_example; # String | 
my $operatorGroupUpdateRequest = WWW::OPenAPIClient::Object::OperatorGroupUpdateRequest->new(); # OperatorGroupUpdateRequest | 

eval {
    my $result = $api_instance->updateOperatorGroup(id => $id, apiVersion => $apiVersion, operatorGroupUpdateRequest => $operatorGroupUpdateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorGroupsApi->updateOperatorGroup: $@\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.OperatorGroupsApi()
id = id_example # String | The unique identifier for the operator group. (default to null)
apiVersion = apiVersion_example # String |  (default to null)
operatorGroupUpdateRequest =  # OperatorGroupUpdateRequest |  (optional)

try:
    # Update a operator group
    api_response = api_instance.update_operator_group(id, apiVersion, operatorGroupUpdateRequest=operatorGroupUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorGroupsApi->updateOperatorGroup: %s\n" % e)

extern crate OperatorGroupsApi;

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

    let mut context = OperatorGroupsApi::Context::default();
    let result = client.updateOperatorGroup(id, apiVersion, operatorGroupUpdateRequest, &context).wait();

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

Scopes

operator.write

Write access to operator and operator group resources

Parameters

Path parameters

Name	Description
id*	String The unique identifier for the operator group. Required

Body parameters

Name	Description
operatorGroupUpdateRequest

Query parameters

Name	Description
api-version*	String Required

Responses

Schema

Schema

Schema

OperatorUsers

createOperatorUser

Create an operator user

Creates an operator user using the values in the body. The role User will be automatically added

/operator/users

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/operator/users?api-version=apiVersion_example" \
 -d '{
  "firstName" : "firstName",
  "lastName" : "lastName",
  "permissions" : [ "permissions", "permissions" ],
  "roles" : [ "roles", "roles" ],
  "userName" : "userName",
  "email" : "email"
}'

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

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

public class OperatorUsersApiExample {
    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
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String apiVersion = apiVersion_example; // String | 
        OperatorUserCreationRequest operatorUserCreationRequest = ; // OperatorUserCreationRequest | 

        try {
            apiInstance.createOperatorUser(apiVersion, operatorUserCreationRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#createOperatorUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.OperatorUsersApi;

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String apiVersion = apiVersion_example; // String | 
        OperatorUserCreationRequest operatorUserCreationRequest = ; // OperatorUserCreationRequest | 

        try {
            apiInstance.createOperatorUser(apiVersion, operatorUserCreationRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#createOperatorUser");
            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
OperatorUsersApi *apiInstance = [[OperatorUsersApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)
OperatorUserCreationRequest *operatorUserCreationRequest = ; //  (optional)

// Create an operator user
[apiInstance createOperatorUserWith:apiVersion
    operatorUserCreationRequest:operatorUserCreationRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorUsersApi()
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'operatorUserCreationRequest':  // {OperatorUserCreationRequest} 
};

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

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

namespace Example
{
    public class createOperatorUserExample
    {
        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 OperatorUsersApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var operatorUserCreationRequest = new OperatorUserCreationRequest(); // OperatorUserCreationRequest |  (optional) 

            try {
                // Create an operator user
                apiInstance.createOperatorUser(apiVersion, operatorUserCreationRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorUsersApi.createOperatorUser: " + 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\OperatorUsersApi();
$apiVersion = apiVersion_example; // String | 
$operatorUserCreationRequest = ; // OperatorUserCreationRequest | 

try {
    $api_instance->createOperatorUser($apiVersion, $operatorUserCreationRequest);
} catch (Exception $e) {
    echo 'Exception when calling OperatorUsersApi->createOperatorUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorUsersApi;

# 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::OperatorUsersApi->new();
my $apiVersion = apiVersion_example; # String | 
my $operatorUserCreationRequest = WWW::OPenAPIClient::Object::OperatorUserCreationRequest->new(); # OperatorUserCreationRequest | 

eval {
    $api_instance->createOperatorUser(apiVersion => $apiVersion, operatorUserCreationRequest => $operatorUserCreationRequest);
};
if ($@) {
    warn "Exception when calling OperatorUsersApi->createOperatorUser: $@\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.OperatorUsersApi()
apiVersion = apiVersion_example # String |  (default to null)
operatorUserCreationRequest =  # OperatorUserCreationRequest |  (optional)

try:
    # Create an operator user
    api_instance.create_operator_user(apiVersion, operatorUserCreationRequest=operatorUserCreationRequest)
except ApiException as e:
    print("Exception when calling OperatorUsersApi->createOperatorUser: %s\n" % e)

extern crate OperatorUsersApi;

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

    let mut context = OperatorUsersApi::Context::default();
    let result = client.createOperatorUser(apiVersion, operatorUserCreationRequest, &context).wait();

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

Scopes

operator.write

Write access to operator and operator group resources

Parameters

Body parameters

Name	Description
operatorUserCreationRequest

Query parameters

Name	Description
api-version*	String Required

Responses

Schema

Schema

Schema

deleteOperatorUser

Delete an operator user

Delete an operator user having the given id.

/operator/users/{id}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "http://localhost/operator/users/{id}?api-version=apiVersion_example"

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

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

public class OperatorUsersApiExample {
    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
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String id = id_example; // String | The unique identifier for the operator user.
        String apiVersion = apiVersion_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.OperatorUsersApi;

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

        try {
            OperatorUser result = apiInstance.deleteOperatorUser(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#deleteOperatorUser");
            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
OperatorUsersApi *apiInstance = [[OperatorUsersApi alloc] init];
String *id = id_example; // The unique identifier for the operator user. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Delete an operator user
[apiInstance deleteOperatorUserWith:id
    apiVersion:apiVersion
              completionHandler: ^(OperatorUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorUsersApi()
var id = id_example; // {String} The unique identifier for the operator user.
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.deleteOperatorUser(id, apiVersion, callback);

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

namespace Example
{
    public class deleteOperatorUserExample
    {
        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 OperatorUsersApi();
            var id = id_example;  // String | The unique identifier for the operator user. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Delete an operator user
                OperatorUser result = apiInstance.deleteOperatorUser(id, apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorUsersApi.deleteOperatorUser: " + 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\OperatorUsersApi();
$id = id_example; // String | The unique identifier for the operator user.
$apiVersion = apiVersion_example; // String | 

try {
    $result = $api_instance->deleteOperatorUser($id, $apiVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorUsersApi->deleteOperatorUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorUsersApi;

# 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::OperatorUsersApi->new();
my $id = id_example; # String | The unique identifier for the operator user.
my $apiVersion = apiVersion_example; # String | 

eval {
    my $result = $api_instance->deleteOperatorUser(id => $id, apiVersion => $apiVersion);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorUsersApi->deleteOperatorUser: $@\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.OperatorUsersApi()
id = id_example # String | The unique identifier for the operator user. (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Delete an operator user
    api_response = api_instance.delete_operator_user(id, apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorUsersApi->deleteOperatorUser: %s\n" % e)

extern crate OperatorUsersApi;

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

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

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

Scopes

operator.write

Write access to operator and operator group resources

Parameters

Path parameters

Name	Description
id*	String The unique identifier for the operator user. Required

Query parameters

Name	Description
api-version*	String Required

Responses

Schema

Schema

Schema

getOperatorUser

Get the single operator user

Returns a single operator user having the given id.

/operator/users/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "http://localhost/operator/users/{id}?api-version=apiVersion_example"

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

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

public class OperatorUsersApiExample {
    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
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String id = id_example; // String | The unique identifier for the operator user
        String apiVersion = apiVersion_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.OperatorUsersApi;

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String id = id_example; // String | The unique identifier for the operator user
        String apiVersion = apiVersion_example; // String | 

        try {
            OperatorUser result = apiInstance.getOperatorUser(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#getOperatorUser");
            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
OperatorUsersApi *apiInstance = [[OperatorUsersApi alloc] init];
String *id = id_example; // The unique identifier for the operator user (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Get the single operator user
[apiInstance getOperatorUserWith:id
    apiVersion:apiVersion
              completionHandler: ^(OperatorUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorUsersApi()
var id = id_example; // {String} The unique identifier for the operator user
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.getOperatorUser(id, apiVersion, callback);

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

namespace Example
{
    public class getOperatorUserExample
    {
        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 OperatorUsersApi();
            var id = id_example;  // String | The unique identifier for the operator user (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Get the single operator user
                OperatorUser result = apiInstance.getOperatorUser(id, apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorUsersApi.getOperatorUser: " + 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\OperatorUsersApi();
$id = id_example; // String | The unique identifier for the operator user
$apiVersion = apiVersion_example; // String | 

try {
    $result = $api_instance->getOperatorUser($id, $apiVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorUsersApi->getOperatorUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorUsersApi;

# 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::OperatorUsersApi->new();
my $id = id_example; # String | The unique identifier for the operator user
my $apiVersion = apiVersion_example; # String | 

eval {
    my $result = $api_instance->getOperatorUser(id => $id, apiVersion => $apiVersion);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorUsersApi->getOperatorUser: $@\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.OperatorUsersApi()
id = id_example # String | The unique identifier for the operator user (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Get the single operator user
    api_response = api_instance.get_operator_user(id, apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorUsersApi->getOperatorUser: %s\n" % e)

extern crate OperatorUsersApi;

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

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

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

Scopes

operator.read

Read access to operator and operator group resources

Parameters

Path parameters

Name	Description
id*	String The unique identifier for the operator user Required

Query parameters

Name	Description
api-version*	String Required

Responses

Schema

Schema

Schema

Schema

getOperatorUsers

Get the list of operator users

Returns the list of operator users.

/operator/users

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "http://localhost/operator/users?PageNumber=56&PageSize=56&Sort=sort_example&SortOrder=sortOrder_example&Fields=&Filters=&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.OperatorUsersApi;

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

public class OperatorUsersApiExample {
    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
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        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] | 
        map[String, String] filters = ; // map[String, String] | 
        Boolean retrieveTotal = true; // Boolean | 

        try {
            OperatorUserPagedResponse result = apiInstance.getOperatorUsers(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, filters, retrieveTotal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#getOperatorUsers");
            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 map[String, String] filters = new map[String, String](); // map[String, String] | 
final Boolean retrieveTotal = new Boolean(); // Boolean | 

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

import org.openapitools.client.api.OperatorUsersApi;

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        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] | 
        map[String, String] filters = ; // map[String, String] | 
        Boolean retrieveTotal = true; // Boolean | 

        try {
            OperatorUserPagedResponse result = apiInstance.getOperatorUsers(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, filters, retrieveTotal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#getOperatorUsers");
            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
OperatorUsersApi *apiInstance = [[OperatorUsersApi 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)
map[String, String] *filters = ; //  (optional) (default to null)
Boolean *retrieveTotal = true; //  (optional) (default to null)

// Get the list of operator users
[apiInstance getOperatorUsersWith:apiVersion
    pageNumber:pageNumber
    pageSize:pageSize
    sort:sort
    sortOrder:sortOrder
    fields:fields
    filters:filters
    retrieveTotal:retrieveTotal
              completionHandler: ^(OperatorUserPagedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorUsersApi()
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'pageNumber': 56, // {Integer} 
  'pageSize': 56, // {Integer} 
  'sort': sort_example, // {String} 
  'sortOrder': sortOrder_example, // {String} 
  'fields': , // {array[String]} 
  'filters': , // {map[String, 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.getOperatorUsers(apiVersion, opts, callback);

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

namespace Example
{
    public class getOperatorUsersExample
    {
        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 OperatorUsersApi();
            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 filters = new map[String, String](); // map[String, String] |  (optional)  (default to null)
            var retrieveTotal = true;  // Boolean |  (optional)  (default to null)

            try {
                // Get the list of operator users
                OperatorUserPagedResponse result = apiInstance.getOperatorUsers(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, filters, retrieveTotal);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorUsersApi.getOperatorUsers: " + 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\OperatorUsersApi();
$apiVersion = apiVersion_example; // String | 
$pageNumber = 56; // Integer | 
$pageSize = 56; // Integer | 
$sort = sort_example; // String | 
$sortOrder = sortOrder_example; // String | 
$fields = ; // array[String] | 
$filters = ; // map[String, String] | 
$retrieveTotal = true; // Boolean | 

try {
    $result = $api_instance->getOperatorUsers($apiVersion, $pageNumber, $pageSize, $sort, $sortOrder, $fields, $filters, $retrieveTotal);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorUsersApi->getOperatorUsers: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorUsersApi;

# 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::OperatorUsersApi->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 $filters = ; # map[String, String] | 
my $retrieveTotal = true; # Boolean | 

eval {
    my $result = $api_instance->getOperatorUsers(apiVersion => $apiVersion, pageNumber => $pageNumber, pageSize => $pageSize, sort => $sort, sortOrder => $sortOrder, fields => $fields, filters => $filters, retrieveTotal => $retrieveTotal);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorUsersApi->getOperatorUsers: $@\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.OperatorUsersApi()
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)
filters =  # map[String, String] |  (optional) (default to null)
retrieveTotal = true # Boolean |  (optional) (default to null)

try:
    # Get the list of operator users
    api_response = api_instance.get_operator_users(apiVersion, pageNumber=pageNumber, pageSize=pageSize, sort=sort, sortOrder=sortOrder, fields=fields, filters=filters, retrieveTotal=retrieveTotal)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorUsersApi->getOperatorUsers: %s\n" % e)

extern crate OperatorUsersApi;

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 filters = ; // map[String, String]
    let retrieveTotal = true; // Boolean

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

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

Scopes

operator.read

Read access to operator and operator group resources

Parameters

Query parameters

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

Responses

Schema

Schema

Schema

getRolesAndPermissionsForUser

Gets roles and permissions assigned to an operator of a virtual tenant

Gets all tenant wide roles and permission assigned to an operator.

/operator/users/{upn}/roles-and-permissions

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "http://localhost/operator/users/{upn}/roles-and-permissions?api-version=apiVersion_example"

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

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

public class OperatorUsersApiExample {
    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
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String upn = upn_example; // String | The unique identifier for the operator user.
        String apiVersion = apiVersion_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String upn = new String(); // String | The unique identifier for the operator user.
final String apiVersion = new String(); // String | 

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

import org.openapitools.client.api.OperatorUsersApi;

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String upn = upn_example; // String | The unique identifier for the operator user.
        String apiVersion = apiVersion_example; // String | 

        try {
            OkResult result = apiInstance.getRolesAndPermissionsForUser(upn, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#getRolesAndPermissionsForUser");
            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
OperatorUsersApi *apiInstance = [[OperatorUsersApi alloc] init];
String *upn = upn_example; // The unique identifier for the operator user. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Gets roles and permissions assigned to an operator of a virtual tenant
[apiInstance getRolesAndPermissionsForUserWith:upn
    apiVersion:apiVersion
              completionHandler: ^(OkResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorUsersApi()
var upn = upn_example; // {String} The unique identifier for the operator user.
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.getRolesAndPermissionsForUser(upn, apiVersion, callback);

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

namespace Example
{
    public class getRolesAndPermissionsForUserExample
    {
        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 OperatorUsersApi();
            var upn = upn_example;  // String | The unique identifier for the operator user. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Gets roles and permissions assigned to an operator of a virtual tenant
                OkResult result = apiInstance.getRolesAndPermissionsForUser(upn, apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorUsersApi.getRolesAndPermissionsForUser: " + 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\OperatorUsersApi();
$upn = upn_example; // String | The unique identifier for the operator user.
$apiVersion = apiVersion_example; // String | 

try {
    $result = $api_instance->getRolesAndPermissionsForUser($upn, $apiVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorUsersApi->getRolesAndPermissionsForUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorUsersApi;

# 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::OperatorUsersApi->new();
my $upn = upn_example; # String | The unique identifier for the operator user.
my $apiVersion = apiVersion_example; # String | 

eval {
    my $result = $api_instance->getRolesAndPermissionsForUser(upn => $upn, apiVersion => $apiVersion);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorUsersApi->getRolesAndPermissionsForUser: $@\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.OperatorUsersApi()
upn = upn_example # String | The unique identifier for the operator user. (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Gets roles and permissions assigned to an operator of a virtual tenant
    api_response = api_instance.get_roles_and_permissions_for_user(upn, apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorUsersApi->getRolesAndPermissionsForUser: %s\n" % e)

extern crate OperatorUsersApi;

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

    let mut context = OperatorUsersApi::Context::default();
    let result = client.getRolesAndPermissionsForUser(upn, apiVersion, &context).wait();

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

Scopes

operator.write

Write access to operator and operator group resources

Parameters

Path parameters

Name	Description
upn*	String The unique identifier for the operator user. Required

Query parameters

Name	Description
api-version*	String Required

Responses

Schema

Schema

Schema

getRolesAndPermissionsForUserInVirtualTenant

Gets roles and permissions assigned to an operator of a virtual tenant

Gets all tenant wide roles and permission assigned to an operator ad whether they are applied to a virtual tenant.

/operator/users/{upn}/roles-and-permissions/virtual-tenants/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "http://localhost/operator/users/{upn}/roles-and-permissions/virtual-tenants/{id}?api-version=apiVersion_example"

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

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

public class OperatorUsersApiExample {
    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
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String upn = upn_example; // String | The unique identifier for the operator user.
        String id = id_example; // String | The unique identifier for the virtual tenant.
        String apiVersion = apiVersion_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String upn = new String(); // String | The unique identifier for the operator user.
final String id = new String(); // String | The unique identifier for the virtual tenant.
final String apiVersion = new String(); // String | 

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

import org.openapitools.client.api.OperatorUsersApi;

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String upn = upn_example; // String | The unique identifier for the operator user.
        String id = id_example; // String | The unique identifier for the virtual tenant.
        String apiVersion = apiVersion_example; // String | 

        try {
            OkResult result = apiInstance.getRolesAndPermissionsForUserInVirtualTenant(upn, id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#getRolesAndPermissionsForUserInVirtualTenant");
            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
OperatorUsersApi *apiInstance = [[OperatorUsersApi alloc] init];
String *upn = upn_example; // The unique identifier for the operator user. (default to null)
String *id = id_example; // The unique identifier for the virtual tenant. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Gets roles and permissions assigned to an operator of a virtual tenant
[apiInstance getRolesAndPermissionsForUserInVirtualTenantWith:upn
    id:id
    apiVersion:apiVersion
              completionHandler: ^(OkResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorUsersApi()
var upn = upn_example; // {String} The unique identifier for the operator user.
var id = id_example; // {String} The unique identifier for the virtual tenant.
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.getRolesAndPermissionsForUserInVirtualTenant(upn, id, apiVersion, callback);

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

namespace Example
{
    public class getRolesAndPermissionsForUserInVirtualTenantExample
    {
        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 OperatorUsersApi();
            var upn = upn_example;  // String | The unique identifier for the operator user. (default to null)
            var id = id_example;  // String | The unique identifier for the virtual tenant. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Gets roles and permissions assigned to an operator of a virtual tenant
                OkResult result = apiInstance.getRolesAndPermissionsForUserInVirtualTenant(upn, id, apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorUsersApi.getRolesAndPermissionsForUserInVirtualTenant: " + 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\OperatorUsersApi();
$upn = upn_example; // String | The unique identifier for the operator user.
$id = id_example; // String | The unique identifier for the virtual tenant.
$apiVersion = apiVersion_example; // String | 

try {
    $result = $api_instance->getRolesAndPermissionsForUserInVirtualTenant($upn, $id, $apiVersion);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorUsersApi->getRolesAndPermissionsForUserInVirtualTenant: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorUsersApi;

# 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::OperatorUsersApi->new();
my $upn = upn_example; # String | The unique identifier for the operator user.
my $id = id_example; # String | The unique identifier for the virtual tenant.
my $apiVersion = apiVersion_example; # String | 

eval {
    my $result = $api_instance->getRolesAndPermissionsForUserInVirtualTenant(upn => $upn, id => $id, apiVersion => $apiVersion);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorUsersApi->getRolesAndPermissionsForUserInVirtualTenant: $@\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.OperatorUsersApi()
upn = upn_example # String | The unique identifier for the operator user. (default to null)
id = id_example # String | The unique identifier for the virtual tenant. (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Gets roles and permissions assigned to an operator of a virtual tenant
    api_response = api_instance.get_roles_and_permissions_for_user_in_virtual_tenant(upn, id, apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorUsersApi->getRolesAndPermissionsForUserInVirtualTenant: %s\n" % e)

extern crate OperatorUsersApi;

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

    let mut context = OperatorUsersApi::Context::default();
    let result = client.getRolesAndPermissionsForUserInVirtualTenant(upn, id, apiVersion, &context).wait();

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

Scopes

operator.read

Read access to operator and operator group resources

Parameters

Path parameters

Name	Description
upn*	String The unique identifier for the operator user. Required
id*	String The unique identifier for the virtual tenant. Required

Query parameters

Name	Description
api-version*	String Required

Responses

Schema

Schema

Schema

updateOperatorUser

Update the given operator user

Updates the single operator user having the given id. The role User will be automatically added

/operator/users/{username}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/operator/users/{username}?api-version=apiVersion_example" \
 -d '{
  "firstName" : "firstName",
  "lastName" : "lastName",
  "permissions" : [ "permissions", "permissions" ],
  "roles" : [ "roles", "roles" ],
  "email" : "email"
}'

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

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

public class OperatorUsersApiExample {
    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
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String username = username_example; // String | The username of the operator user
        String apiVersion = apiVersion_example; // String | 
        OperatorUserUpdateRequest operatorUserUpdateRequest = ; // OperatorUserUpdateRequest | 

        try {
            OperatorUser result = apiInstance.updateOperatorUser(username, apiVersion, operatorUserUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#updateOperatorUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String username = new String(); // String | The username of the operator user
final String apiVersion = new String(); // String | 
final OperatorUserUpdateRequest operatorUserUpdateRequest = new OperatorUserUpdateRequest(); // OperatorUserUpdateRequest | 

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

import org.openapitools.client.api.OperatorUsersApi;

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String username = username_example; // String | The username of the operator user
        String apiVersion = apiVersion_example; // String | 
        OperatorUserUpdateRequest operatorUserUpdateRequest = ; // OperatorUserUpdateRequest | 

        try {
            OperatorUser result = apiInstance.updateOperatorUser(username, apiVersion, operatorUserUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#updateOperatorUser");
            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
OperatorUsersApi *apiInstance = [[OperatorUsersApi alloc] init];
String *username = username_example; // The username of the operator user (default to null)
String *apiVersion = apiVersion_example; //  (default to null)
OperatorUserUpdateRequest *operatorUserUpdateRequest = ; //  (optional)

// Update the given operator user
[apiInstance updateOperatorUserWith:username
    apiVersion:apiVersion
    operatorUserUpdateRequest:operatorUserUpdateRequest
              completionHandler: ^(OperatorUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.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 OperatorApi.OperatorUsersApi()
var username = username_example; // {String} The username of the operator user
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'operatorUserUpdateRequest':  // {OperatorUserUpdateRequest} 
};

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

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

namespace Example
{
    public class updateOperatorUserExample
    {
        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 OperatorUsersApi();
            var username = username_example;  // String | The username of the operator user (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var operatorUserUpdateRequest = new OperatorUserUpdateRequest(); // OperatorUserUpdateRequest |  (optional) 

            try {
                // Update the given operator user
                OperatorUser result = apiInstance.updateOperatorUser(username, apiVersion, operatorUserUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorUsersApi.updateOperatorUser: " + 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\OperatorUsersApi();
$username = username_example; // String | The username of the operator user
$apiVersion = apiVersion_example; // String | 
$operatorUserUpdateRequest = ; // OperatorUserUpdateRequest | 

try {
    $result = $api_instance->updateOperatorUser($username, $apiVersion, $operatorUserUpdateRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorUsersApi->updateOperatorUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorUsersApi;

# 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::OperatorUsersApi->new();
my $username = username_example; # String | The username of the operator user
my $apiVersion = apiVersion_example; # String | 
my $operatorUserUpdateRequest = WWW::OPenAPIClient::Object::OperatorUserUpdateRequest->new(); # OperatorUserUpdateRequest | 

eval {
    my $result = $api_instance->updateOperatorUser(username => $username, apiVersion => $apiVersion, operatorUserUpdateRequest => $operatorUserUpdateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorUsersApi->updateOperatorUser: $@\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.OperatorUsersApi()
username = username_example # String | The username of the operator user (default to null)
apiVersion = apiVersion_example # String |  (default to null)
operatorUserUpdateRequest =  # OperatorUserUpdateRequest |  (optional)

try:
    # Update the given operator user
    api_response = api_instance.update_operator_user(username, apiVersion, operatorUserUpdateRequest=operatorUserUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorUsersApi->updateOperatorUser: %s\n" % e)

extern crate OperatorUsersApi;

pub fn main() {
    let username = username_example; // String
    let apiVersion = apiVersion_example; // String
    let operatorUserUpdateRequest = ; // OperatorUserUpdateRequest

    let mut context = OperatorUsersApi::Context::default();
    let result = client.updateOperatorUser(username, apiVersion, operatorUserUpdateRequest, &context).wait();

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

Scopes

operator.write

Write access to operator and operator group resources

Parameters

Path parameters

Name	Description
username*	String The username of the operator user Required

Body parameters

Name	Description
operatorUserUpdateRequest

Query parameters

Name	Description
api-version*	String Required

Responses

Schema

Schema

Schema

Operator Api

API and SDK Documentation

OperatorGroups

createOperatorGroup

Usage and SDK Samples

Scopes

Parameters

Responses

deleteOperatorGroup

Usage and SDK Samples

Scopes

Parameters

Responses

getOperatorGroup

Usage and SDK Samples

Scopes

Parameters

Responses

getOperatorGroups

Usage and SDK Samples

Scopes

Parameters

Responses

getRolesAndPermissionsForGroup

Usage and SDK Samples

Scopes

Parameters

Responses

getRolesAndPermissionsForGroupInVirtualTenant

Usage and SDK Samples

Scopes

Parameters

Responses

updateOperatorGroup

Usage and SDK Samples

Scopes

Parameters

Responses

OperatorUsers

createOperatorUser

Usage and SDK Samples

Scopes

Parameters

Responses

deleteOperatorUser

Usage and SDK Samples

Scopes

Parameters

Responses

getOperatorUser

Usage and SDK Samples

Scopes

Parameters

Responses

getOperatorUsers

Usage and SDK Samples

Scopes

Parameters

Responses

getRolesAndPermissionsForUser

Usage and SDK Samples

Scopes

Parameters

Responses

getRolesAndPermissionsForUserInVirtualTenant

Usage and SDK Samples

Scopes

Parameters

Responses

updateOperatorUser

Usage and SDK Samples

Scopes

Parameters

Responses