LemonLDAP::NG Manager API

Casapp

addcasapp

Create a new CAS Application


/api/v1/providers/cas/app

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/providers/cas/app"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CasappApi;

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        CasApp body = ; // CasApp | CAS Application to add
        try {
            apiInstance.addcasapp(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#addcasapp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        CasApp body = ; // CasApp | CAS Application to add
        try {
            apiInstance.addcasapp(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#addcasapp");
            e.printStackTrace();
        }
    }
}
CasApp *body = ; // CAS Application to add

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

// Create a new CAS Application
[apiInstance addcasappWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var body = ; // {{CasApp}} CAS Application to add

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

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

            var apiInstance = new CasappApi();
            var body = new CasApp(); // CasApp | CAS Application to add

            try
            {
                // Create a new CAS Application
                apiInstance.addcasapp(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.addcasapp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiCasappApi();
$body = ; // CasApp | CAS Application to add

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $body = WWW::SwaggerClient::Object::CasApp->new(); # CasApp | CAS Application to add

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
body =  # CasApp | CAS Application to add

try: 
    # Create a new CAS Application
    api_instance.addcasapp(body)
except ApiException as e:
    print("Exception when calling CasappApi->addcasapp: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Successful creation

Status: 400 - An error was encountered when processing the request

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


deleteCasApp

Deletes a CAS Application


/api/v1/providers/cas/app/{confKey}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/providers/cas/app/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CasappApi;

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application to delete
        try {
            apiInstance.deleteCasApp(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#deleteCasApp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application to delete
        try {
            apiInstance.deleteCasApp(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#deleteCasApp");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of CAS Application to delete

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

// Deletes a CAS Application
[apiInstance deleteCasAppWith:confKey
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var confKey = ; // {{confKey}} Configuration key of CAS Application to delete

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

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

            var apiInstance = new CasappApi();
            var confKey = new confKey(); // confKey | Configuration key of CAS Application to delete

            try
            {
                // Deletes a CAS Application
                apiInstance.deleteCasApp(confKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.deleteCasApp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiCasappApi();
$confKey = ; // confKey | Configuration key of CAS Application to delete

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $confKey = ; # confKey | Configuration key of CAS Application to delete

eval { 
    $api_instance->deleteCasApp(confKey => $confKey);
};
if ($@) {
    warn "Exception when calling CasappApi->deleteCasApp: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CasappApi()
confKey =  # confKey | Configuration key of CAS Application to delete

try: 
    # Deletes a CAS Application
    api_instance.delete_cas_app(confKey)
except ApiException as e:
    print("Exception when calling CasappApi->deleteCasApp: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of CAS Application to delete
Required

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


findCasAppByConfKey

Finds CAS applications by configuration key

Takes a search pattern to be tested against existing applications


/api/v1/providers/cas/app/findByConfKey

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/providers/cas/app/findByConfKey?pattern="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CasappApi;

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        String pattern = pattern_example; // String | Search pattern
        try {
            array[CasApp] result = apiInstance.findCasAppByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#findCasAppByConfKey");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        String pattern = pattern_example; // String | Search pattern
        try {
            array[CasApp] result = apiInstance.findCasAppByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#findCasAppByConfKey");
            e.printStackTrace();
        }
    }
}
String *pattern = pattern_example; // Search pattern

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

// Finds CAS applications by configuration key
[apiInstance findCasAppByConfKeyWith:pattern
              completionHandler: ^(array[CasApp] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var pattern = pattern_example; // {{String}} Search pattern

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

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

            var apiInstance = new CasappApi();
            var pattern = pattern_example;  // String | Search pattern

            try
            {
                // Finds CAS applications by configuration key
                array[CasApp] result = apiInstance.findCasAppByConfKey(pattern);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.findCasAppByConfKey: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiCasappApi();
$pattern = pattern_example; // String | Search pattern

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $pattern = pattern_example; # String | Search pattern

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
pattern = pattern_example # String | Search pattern

try: 
    # Finds CAS applications by configuration key
    api_response = api_instance.find_cas_app_by_conf_key(pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CasappApi->findCasAppByConfKey: %s\n" % e)

Parameters

Query parameters
Name Description
pattern*
String
Search pattern
Required

Responses

Status: 200 - Return a list of CAS Providers

Status: 400 - An error was encountered when processing the request


findCasAppByServiceUrl

Get CAS Application by Service URL


/api/v1/providers/cas/app/findByServiceUrl

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/providers/cas/app/findByServiceUrl?serviceUrl="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CasappApi;

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        String serviceUrl = serviceUrl_example; // String | Service URL to search
        try {
            CasApp result = apiInstance.findCasAppByServiceUrl(serviceUrl);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#findCasAppByServiceUrl");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        String serviceUrl = serviceUrl_example; // String | Service URL to search
        try {
            CasApp result = apiInstance.findCasAppByServiceUrl(serviceUrl);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#findCasAppByServiceUrl");
            e.printStackTrace();
        }
    }
}
String *serviceUrl = serviceUrl_example; // Service URL to search

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

// Get CAS Application by Service URL
[apiInstance findCasAppByServiceUrlWith:serviceUrl
              completionHandler: ^(CasApp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var serviceUrl = serviceUrl_example; // {{String}} Service URL to search

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

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

            var apiInstance = new CasappApi();
            var serviceUrl = serviceUrl_example;  // String | Service URL to search

            try
            {
                // Get CAS Application by Service URL
                CasApp result = apiInstance.findCasAppByServiceUrl(serviceUrl);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.findCasAppByServiceUrl: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiCasappApi();
$serviceUrl = serviceUrl_example; // String | Service URL to search

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $serviceUrl = serviceUrl_example; # String | Service URL to search

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
serviceUrl = serviceUrl_example # String | Service URL to search

try: 
    # Get CAS Application by Service URL
    api_response = api_instance.find_cas_app_by_service_url(serviceUrl)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CasappApi->findCasAppByServiceUrl: %s\n" % e)

Parameters

Query parameters
Name Description
serviceUrl*
String
Service URL to search
Required

Responses

Status: 200 - Return a CAS Provider

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


getCasAppByConfKey

Get CAS Application by configuration key

Returns a single Application


/api/v1/providers/cas/app/{confKey}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/providers/cas/app/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CasappApi;

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application
        try {
            CasApp result = apiInstance.getCasAppByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#getCasAppByConfKey");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application
        try {
            CasApp result = apiInstance.getCasAppByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#getCasAppByConfKey");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of CAS Application

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

// Get CAS Application by configuration key
[apiInstance getCasAppByConfKeyWith:confKey
              completionHandler: ^(CasApp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var confKey = ; // {{confKey}} Configuration key of CAS Application

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

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

            var apiInstance = new CasappApi();
            var confKey = new confKey(); // confKey | Configuration key of CAS Application

            try
            {
                // Get CAS Application by configuration key
                CasApp result = apiInstance.getCasAppByConfKey(confKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.getCasAppByConfKey: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiCasappApi();
$confKey = ; // confKey | Configuration key of CAS Application

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $confKey = ; # confKey | Configuration key of CAS Application

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
confKey =  # confKey | Configuration key of CAS Application

try: 
    # Get CAS Application by configuration key
    api_response = api_instance.get_cas_app_by_conf_key(confKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CasappApi->getCasAppByConfKey: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of CAS Application
Required

Responses

Status: 200 - Return a CAS Provider

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


replaceCasApp

Replaces a CAS Application


/api/v1/providers/cas/app/{confKey}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/providers/cas/app/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CasappApi;

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application that needs to be replaced
        CasAppReplace body = ; // CasAppReplace | 
        try {
            apiInstance.replaceCasApp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#replaceCasApp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application that needs to be replaced
        CasAppReplace body = ; // CasAppReplace | 
        try {
            apiInstance.replaceCasApp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#replaceCasApp");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of CAS Application that needs to be replaced
CasAppReplace *body = ; //  (optional)

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

// Replaces a CAS Application
[apiInstance replaceCasAppWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var confKey = ; // {{confKey}} Configuration key of CAS Application that needs to be replaced
var opts = { 
  'body':  // {{CasAppReplace}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.replaceCasApp(confKey, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CasappApi();
            var confKey = new confKey(); // confKey | Configuration key of CAS Application that needs to be replaced
            var body = new CasAppReplace(); // CasAppReplace |  (optional) 

            try
            {
                // Replaces a CAS Application
                apiInstance.replaceCasApp(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.replaceCasApp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiCasappApi();
$confKey = ; // confKey | Configuration key of CAS Application that needs to be replaced
$body = ; // CasAppReplace | 

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $confKey = ; # confKey | Configuration key of CAS Application that needs to be replaced
my $body = WWW::SwaggerClient::Object::CasAppReplace->new(); # CasAppReplace | 

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
confKey =  # confKey | Configuration key of CAS Application that needs to be replaced
body =  # CasAppReplace |  (optional)

try: 
    # Replaces a CAS Application
    api_instance.replace_cas_app(confKey, body=body)
except ApiException as e:
    print("Exception when calling CasappApi->replaceCasApp: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of CAS Application that needs to be replaced
Required
Body parameters
Name Description
body

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


updateCasApp

Updates a CAS Application.


/api/v1/providers/cas/app/{confKey}

Usage and SDK Samples

curl -X PATCH\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/providers/cas/app/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CasappApi;

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

public class CasappApiExample {

    public static void main(String[] args) {
        
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application that needs to be updated
        CasAppUpdate body = ; // CasAppUpdate | 
        try {
            apiInstance.updateCasApp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#updateCasApp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CasappApi;

public class CasappApiExample {

    public static void main(String[] args) {
        CasappApi apiInstance = new CasappApi();
        confKey confKey = ; // confKey | Configuration key of CAS Application that needs to be updated
        CasAppUpdate body = ; // CasAppUpdate | 
        try {
            apiInstance.updateCasApp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CasappApi#updateCasApp");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of CAS Application that needs to be updated
CasAppUpdate *body = ; //  (optional)

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

// Updates a CAS Application.
[apiInstance updateCasAppWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.CasappApi()
var confKey = ; // {{confKey}} Configuration key of CAS Application that needs to be updated
var opts = { 
  'body':  // {{CasAppUpdate}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateCasApp(confKey, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new CasappApi();
            var confKey = new confKey(); // confKey | Configuration key of CAS Application that needs to be updated
            var body = new CasAppUpdate(); // CasAppUpdate |  (optional) 

            try
            {
                // Updates a CAS Application.
                apiInstance.updateCasApp(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CasappApi.updateCasApp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiCasappApi();
$confKey = ; // confKey | Configuration key of CAS Application that needs to be updated
$body = ; // CasAppUpdate | 

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

my $api_instance = WWW::SwaggerClient::CasappApi->new();
my $confKey = ; # confKey | Configuration key of CAS Application that needs to be updated
my $body = WWW::SwaggerClient::Object::CasAppUpdate->new(); # CasAppUpdate | 

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

# create an instance of the API class
api_instance = swagger_client.CasappApi()
confKey =  # confKey | Configuration key of CAS Application that needs to be updated
body =  # CasAppUpdate |  (optional)

try: 
    # Updates a CAS Application.
    api_instance.update_cas_app(confKey, body=body)
except ApiException as e:
    print("Exception when calling CasappApi->updateCasApp: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of CAS Application that needs to be updated
Required
Body parameters
Name Description
body

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


Class2fa

addSecondFactor

Register a new second factor for a user


/api/v1/secondFactor/{uid}

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/secondFactor/{uid}?create="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2faApi;

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        map[String, String] body = ; // map[String, String] | Second factor to add, additional properties depend on the 2FA type
        String uid = uid_example; // String | 
        bool create = ; // bool | Should the persistent session be created if it does not exist yet
        try {
            apiInstance.addSecondFactor(body, uid, create);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#addSecondFactor");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        map[String, String] body = ; // map[String, String] | Second factor to add, additional properties depend on the 2FA type
        String uid = uid_example; // String | 
        bool create = ; // bool | Should the persistent session be created if it does not exist yet
        try {
            apiInstance.addSecondFactor(body, uid, create);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#addSecondFactor");
            e.printStackTrace();
        }
    }
}
map[String, String] *body = ; // Second factor to add, additional properties depend on the 2FA type
String *uid = uid_example; // 
bool *create = ; // Should the persistent session be created if it does not exist yet (optional)

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

// Register a new second factor for a user
[apiInstance addSecondFactorWith:body
    uid:uid
    create:create
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var body = ; // {{map[String, String]}} Second factor to add, additional properties depend on the 2FA type
var uid = uid_example; // {{String}} 
var opts = { 
  'create':  // {{bool}} Should the persistent session be created if it does not exist yet
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.addSecondFactor(bodyuid, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class2faApi();
            var body = new map[String, String](); // map[String, String] | Second factor to add, additional properties depend on the 2FA type
            var uid = uid_example;  // String | 
            var create = new bool(); // bool | Should the persistent session be created if it does not exist yet (optional) 

            try
            {
                // Register a new second factor for a user
                apiInstance.addSecondFactor(body, uid, create);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.addSecondFactor: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass2faApi();
$body = ; // map[String, String] | Second factor to add, additional properties depend on the 2FA type
$uid = uid_example; // String | 
$create = ; // bool | Should the persistent session be created if it does not exist yet

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $body = WWW::SwaggerClient::Object::map[String, String]->new(); # map[String, String] | Second factor to add, additional properties depend on the 2FA type
my $uid = uid_example; # String | 
my $create = ; # bool | Should the persistent session be created if it does not exist yet

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
body =  # map[String, String] | Second factor to add, additional properties depend on the 2FA type
uid = uid_example # String | 
create =  # bool | Should the persistent session be created if it does not exist yet (optional)

try: 
    # Register a new second factor for a user
    api_instance.add_second_factor(body, uid, create=create)
except ApiException as e:
    print("Exception when calling Class2faApi->addSecondFactor: %s\n" % e)

Parameters

Path parameters
Name Description
uid*
String
Required
Body parameters
Name Description
body *
Query parameters
Name Description
create
bool
Should the persistent session be created if it does not exist yet

Responses

Status: 201 - Successful creation

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


addSecondFactorTotp

Register a new TOTP device factor for a user

The secret must be passed as cleartext and will be encrypted by the server if needed


/api/v1/secondFactor/{uid}/type/TOTP

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/secondFactor/{uid}/type/TOTP?create="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2faApi;

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        NewSecondFactorTotp body = ; // NewSecondFactorTotp | Second factor to add
        String uid = uid_example; // String | 
        bool create = ; // bool | Should the persistent session be created if it does not exist yet
        try {
            apiInstance.addSecondFactorTotp(body, uid, create);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#addSecondFactorTotp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        NewSecondFactorTotp body = ; // NewSecondFactorTotp | Second factor to add
        String uid = uid_example; // String | 
        bool create = ; // bool | Should the persistent session be created if it does not exist yet
        try {
            apiInstance.addSecondFactorTotp(body, uid, create);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#addSecondFactorTotp");
            e.printStackTrace();
        }
    }
}
NewSecondFactorTotp *body = ; // Second factor to add
String *uid = uid_example; // 
bool *create = ; // Should the persistent session be created if it does not exist yet (optional)

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

// Register a new TOTP device factor for a user
[apiInstance addSecondFactorTotpWith:body
    uid:uid
    create:create
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var body = ; // {{NewSecondFactorTotp}} Second factor to add
var uid = uid_example; // {{String}} 
var opts = { 
  'create':  // {{bool}} Should the persistent session be created if it does not exist yet
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.addSecondFactorTotp(bodyuid, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class2faApi();
            var body = new NewSecondFactorTotp(); // NewSecondFactorTotp | Second factor to add
            var uid = uid_example;  // String | 
            var create = new bool(); // bool | Should the persistent session be created if it does not exist yet (optional) 

            try
            {
                // Register a new TOTP device factor for a user
                apiInstance.addSecondFactorTotp(body, uid, create);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.addSecondFactorTotp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass2faApi();
$body = ; // NewSecondFactorTotp | Second factor to add
$uid = uid_example; // String | 
$create = ; // bool | Should the persistent session be created if it does not exist yet

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $body = WWW::SwaggerClient::Object::NewSecondFactorTotp->new(); # NewSecondFactorTotp | Second factor to add
my $uid = uid_example; # String | 
my $create = ; # bool | Should the persistent session be created if it does not exist yet

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
body =  # NewSecondFactorTotp | Second factor to add
uid = uid_example # String | 
create =  # bool | Should the persistent session be created if it does not exist yet (optional)

try: 
    # Register a new TOTP device factor for a user
    api_instance.add_second_factor_totp(body, uid, create=create)
except ApiException as e:
    print("Exception when calling Class2faApi->addSecondFactorTotp: %s\n" % e)

Parameters

Path parameters
Name Description
uid*
String
Required
Body parameters
Name Description
body *
Query parameters
Name Description
create
bool
Should the persistent session be created if it does not exist yet

Responses

Status: 201 - Successful creation

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


deleteSecondFactors

Delete all second factors for a user


/api/v1/secondFactor/{uid}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/secondFactor/{uid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2faApi;

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        try {
            apiInstance.deleteSecondFactors(uid);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#deleteSecondFactors");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        try {
            apiInstance.deleteSecondFactors(uid);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#deleteSecondFactors");
            e.printStackTrace();
        }
    }
}
String *uid = uid_example; // 

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

// Delete all second factors for a user
[apiInstance deleteSecondFactorsWith:uid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var uid = uid_example; // {{String}} 

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

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | 

            try
            {
                // Delete all second factors for a user
                apiInstance.deleteSecondFactors(uid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.deleteSecondFactors: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | 

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | 

eval { 
    $api_instance->deleteSecondFactors(uid => $uid);
};
if ($@) {
    warn "Exception when calling Class2faApi->deleteSecondFactors: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | 

try: 
    # Delete all second factors for a user
    api_instance.delete_second_factors(uid)
except ApiException as e:
    print("Exception when calling Class2faApi->deleteSecondFactors: %s\n" % e)

Parameters

Path parameters
Name Description
uid*
String
Required

Responses

Status: 204 - Successful modification

Status: 404 - The specified resource was not found


deleteSecondFactorsById

Delete a second factors for a user


/api/v1/secondFactor/{uid}/id/{id}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/secondFactor/{uid}/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2faApi;

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String id = id_example; // String | 
        try {
            apiInstance.deleteSecondFactorsById(uid, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#deleteSecondFactorsById");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String id = id_example; // String | 
        try {
            apiInstance.deleteSecondFactorsById(uid, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#deleteSecondFactorsById");
            e.printStackTrace();
        }
    }
}
String *uid = uid_example; // 
String *id = id_example; // 

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

// Delete a second factors for a user
[apiInstance deleteSecondFactorsByIdWith:uid
    id:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var uid = uid_example; // {{String}} 
var id = id_example; // {{String}} 

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

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | 
            var id = id_example;  // String | 

            try
            {
                // Delete a second factors for a user
                apiInstance.deleteSecondFactorsById(uid, id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.deleteSecondFactorsById: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | 
$id = id_example; // String | 

try {
    $api_instance->deleteSecondFactorsById($uid, $id);
} catch (Exception $e) {
    echo 'Exception when calling Class2faApi->deleteSecondFactorsById: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class2faApi;

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | 
my $id = id_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | 
id = id_example # String | 

try: 
    # Delete a second factors for a user
    api_instance.delete_second_factors_by_id(uid, id)
except ApiException as e:
    print("Exception when calling Class2faApi->deleteSecondFactorsById: %s\n" % e)

Parameters

Path parameters
Name Description
uid*
String
Required
id*
String
Required

Responses

Status: 204 - Successful modification

Status: 404 - The specified resource was not found


deleteSecondFactorsByType

Delete all second factors of a given type for a user


/api/v1/secondFactor/{uid}/type/{type}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/secondFactor/{uid}/type/{type}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2faApi;

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String type = type_example; // String | 
        try {
            apiInstance.deleteSecondFactorsByType(uid, type);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#deleteSecondFactorsByType");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String type = type_example; // String | 
        try {
            apiInstance.deleteSecondFactorsByType(uid, type);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#deleteSecondFactorsByType");
            e.printStackTrace();
        }
    }
}
String *uid = uid_example; // 
String *type = type_example; // 

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

// Delete all second factors of a given type for a user
[apiInstance deleteSecondFactorsByTypeWith:uid
    type:type
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var uid = uid_example; // {{String}} 
var type = type_example; // {{String}} 

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

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | 
            var type = type_example;  // String | 

            try
            {
                // Delete all second factors of a given type for a user
                apiInstance.deleteSecondFactorsByType(uid, type);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.deleteSecondFactorsByType: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | 
$type = type_example; // String | 

try {
    $api_instance->deleteSecondFactorsByType($uid, $type);
} catch (Exception $e) {
    echo 'Exception when calling Class2faApi->deleteSecondFactorsByType: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class2faApi;

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | 
my $type = type_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | 
type = type_example # String | 

try: 
    # Delete all second factors of a given type for a user
    api_instance.delete_second_factors_by_type(uid, type)
except ApiException as e:
    print("Exception when calling Class2faApi->deleteSecondFactorsByType: %s\n" % e)

Parameters

Path parameters
Name Description
uid*
String
Required
type*
String
Required

Responses

Status: 204 - Successful modification

Status: 404 - The specified resource was not found


getSecondFactors

List second factors for a user


/api/v1/secondFactor/{uid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/secondFactor/{uid}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2faApi;

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        try {
            SecondFactors result = apiInstance.getSecondFactors(uid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#getSecondFactors");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        try {
            SecondFactors result = apiInstance.getSecondFactors(uid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#getSecondFactors");
            e.printStackTrace();
        }
    }
}
String *uid = uid_example; // 

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

// List second factors for a user
[apiInstance getSecondFactorsWith:uid
              completionHandler: ^(SecondFactors output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var uid = uid_example; // {{String}} 

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

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | 

            try
            {
                // List second factors for a user
                SecondFactors result = apiInstance.getSecondFactors(uid);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.getSecondFactors: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | 

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | 

try: 
    # List second factors for a user
    api_response = api_instance.get_second_factors(uid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class2faApi->getSecondFactors: %s\n" % e)

Parameters

Path parameters
Name Description
uid*
String
Required

Responses

Status: 200 - Return a list of second factors

Status: 404 - The specified resource was not found


getSecondFactorsById

Get second factors for a user given its ID


/api/v1/secondFactor/{uid}/id/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/secondFactor/{uid}/id/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2faApi;

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String id = id_example; // String | 
        try {
            SecondFactors result = apiInstance.getSecondFactorsById(uid, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#getSecondFactorsById");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String id = id_example; // String | 
        try {
            SecondFactors result = apiInstance.getSecondFactorsById(uid, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#getSecondFactorsById");
            e.printStackTrace();
        }
    }
}
String *uid = uid_example; // 
String *id = id_example; // 

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

// Get second factors for a user given its ID
[apiInstance getSecondFactorsByIdWith:uid
    id:id
              completionHandler: ^(SecondFactors output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var uid = uid_example; // {{String}} 
var id = id_example; // {{String}} 

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

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | 
            var id = id_example;  // String | 

            try
            {
                // Get second factors for a user given its ID
                SecondFactors result = apiInstance.getSecondFactorsById(uid, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.getSecondFactorsById: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | 
$id = id_example; // String | 

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | 
my $id = id_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | 
id = id_example # String | 

try: 
    # Get second factors for a user given its ID
    api_response = api_instance.get_second_factors_by_id(uid, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class2faApi->getSecondFactorsById: %s\n" % e)

Parameters

Path parameters
Name Description
uid*
String
Required
id*
String
Required

Responses

Status: 200 - Return a list of second factors

Status: 404 - The specified resource was not found


getSecondFactorsByType

List second factors for a user given its type


/api/v1/secondFactor/{uid}/type/{type}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/secondFactor/{uid}/type/{type}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2faApi;

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String type = type_example; // String | 
        try {
            SecondFactors result = apiInstance.getSecondFactorsByType(uid, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#getSecondFactorsByType");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | 
        String type = type_example; // String | 
        try {
            SecondFactors result = apiInstance.getSecondFactorsByType(uid, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#getSecondFactorsByType");
            e.printStackTrace();
        }
    }
}
String *uid = uid_example; // 
String *type = type_example; // 

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

// List second factors for a user given its type
[apiInstance getSecondFactorsByTypeWith:uid
    type:type
              completionHandler: ^(SecondFactors output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var uid = uid_example; // {{String}} 
var type = type_example; // {{String}} 

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

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | 
            var type = type_example;  // String | 

            try
            {
                // List second factors for a user given its type
                SecondFactors result = apiInstance.getSecondFactorsByType(uid, type);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.getSecondFactorsByType: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | 
$type = type_example; // String | 

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | 
my $type = type_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | 
type = type_example # String | 

try: 
    # List second factors for a user given its type
    api_response = api_instance.get_second_factors_by_type(uid, type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class2faApi->getSecondFactorsByType: %s\n" % e)

Parameters

Path parameters
Name Description
uid*
String
Required
type*
String
Required

Responses

Status: 200 - Return a list of second factors

Status: 404 - The specified resource was not found


searchSecondFactors

Search for second factors


/api/v1/secondFactor/

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/secondFactor/?uid=&type="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2faApi;

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

public class Class2faApiExample {

    public static void main(String[] args) {
        
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | The user id to filter on. Can contain wildcards.
        String type = type_example; // String | The second factor type to filter on. Can be specified multiple times.
        try {
            array[SecondFactorSearchResult] result = apiInstance.searchSecondFactors(uid, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#searchSecondFactors");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class2faApi;

public class Class2faApiExample {

    public static void main(String[] args) {
        Class2faApi apiInstance = new Class2faApi();
        String uid = uid_example; // String | The user id to filter on. Can contain wildcards.
        String type = type_example; // String | The second factor type to filter on. Can be specified multiple times.
        try {
            array[SecondFactorSearchResult] result = apiInstance.searchSecondFactors(uid, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2faApi#searchSecondFactors");
            e.printStackTrace();
        }
    }
}
String *uid = uid_example; // The user id to filter on. Can contain wildcards. (optional)
String *type = type_example; // The second factor type to filter on. Can be specified multiple times. (optional)

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

// Search for second factors
[apiInstance searchSecondFactorsWith:uid
    type:type
              completionHandler: ^(array[SecondFactorSearchResult] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.Class2faApi()
var opts = { 
  'uid': uid_example, // {{String}} The user id to filter on. Can contain wildcards.
  'type': type_example // {{String}} The second factor type to filter on. Can be specified multiple times.
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.searchSecondFactors(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class2faApi();
            var uid = uid_example;  // String | The user id to filter on. Can contain wildcards. (optional) 
            var type = type_example;  // String | The second factor type to filter on. Can be specified multiple times. (optional) 

            try
            {
                // Search for second factors
                array[SecondFactorSearchResult] result = apiInstance.searchSecondFactors(uid, type);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2faApi.searchSecondFactors: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass2faApi();
$uid = uid_example; // String | The user id to filter on. Can contain wildcards.
$type = type_example; // String | The second factor type to filter on. Can be specified multiple times.

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

my $api_instance = WWW::SwaggerClient::Class2faApi->new();
my $uid = uid_example; # String | The user id to filter on. Can contain wildcards.
my $type = type_example; # String | The second factor type to filter on. Can be specified multiple times.

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

# create an instance of the API class
api_instance = swagger_client.Class2faApi()
uid = uid_example # String | The user id to filter on. Can contain wildcards. (optional)
type = type_example # String | The second factor type to filter on. Can be specified multiple times. (optional)

try: 
    # Search for second factors
    api_response = api_instance.search_second_factors(uid=uid, type=type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class2faApi->searchSecondFactors: %s\n" % e)

Parameters

Query parameters
Name Description
uid
String
The user id to filter on. Can contain wildcards.
type
String
The second factor type to filter on. Can be specified multiple times.

Responses

Status: 200 - A list of search results


Default

status

Check the status of the API


/api/v1/status

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/status"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            Status result = apiInstance.status();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#status");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            Status result = apiInstance.status();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#status");
            e.printStackTrace();
        }
    }
}

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

// Check the status of the API
[apiInstance statusWithCompletionHandler: 
              ^(Status output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

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

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

            var apiInstance = new DefaultApi();

            try
            {
                // Check the status of the API
                Status result = apiInstance.status();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.status: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDefaultApi();

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

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

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Check the status of the API
    api_response = api_instance.status()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->status: %s\n" % e)

Parameters

Responses

Status: 200 - Response to API health check

Status: 503 - Response to API health check


History

getHistory

Get the login history for a user


/api/v1/history/{uid}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/history/{uid}?result="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HistoryApi;

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

public class HistoryApiExample {

    public static void main(String[] args) {
        
        HistoryApi apiInstance = new HistoryApi();
        String uid = uid_example; // String | 
        String result = result_example; // String | 
        try {
            array[HistoryItem] result = apiInstance.getHistory(uid, result);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HistoryApi#getHistory");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HistoryApi;

public class HistoryApiExample {

    public static void main(String[] args) {
        HistoryApi apiInstance = new HistoryApi();
        String uid = uid_example; // String | 
        String result = result_example; // String | 
        try {
            array[HistoryItem] result = apiInstance.getHistory(uid, result);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HistoryApi#getHistory");
            e.printStackTrace();
        }
    }
}
String *uid = uid_example; // 
String *result = result_example; //  (optional)

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

// Get the login history for a user
[apiInstance getHistoryWith:uid
    result:result
              completionHandler: ^(array[HistoryItem] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.HistoryApi()
var uid = uid_example; // {{String}} 
var opts = { 
  'result': result_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getHistory(uid, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new HistoryApi();
            var uid = uid_example;  // String | 
            var result = result_example;  // String |  (optional) 

            try
            {
                // Get the login history for a user
                array[HistoryItem] result = apiInstance.getHistory(uid, result);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HistoryApi.getHistory: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiHistoryApi();
$uid = uid_example; // String | 
$result = result_example; // String | 

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

my $api_instance = WWW::SwaggerClient::HistoryApi->new();
my $uid = uid_example; # String | 
my $result = result_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.HistoryApi()
uid = uid_example # String | 
result = result_example # String |  (optional)

try: 
    # Get the login history for a user
    api_response = api_instance.get_history(uid, result=result)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HistoryApi->getHistory: %s\n" % e)

Parameters

Path parameters
Name Description
uid*
String
Required
Query parameters
Name Description
result
String

Responses

Status: 200 - List of history entries, sorted by date, from most recent to least recent

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


getHistoryLast

Get the last history event for a user


/api/v1/history/{uid}/last

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/history/{uid}/last?result="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HistoryApi;

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

public class HistoryApiExample {

    public static void main(String[] args) {
        
        HistoryApi apiInstance = new HistoryApi();
        String uid = uid_example; // String | 
        String result = result_example; // String | 
        try {
            HistoryItem result = apiInstance.getHistoryLast(uid, result);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HistoryApi#getHistoryLast");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HistoryApi;

public class HistoryApiExample {

    public static void main(String[] args) {
        HistoryApi apiInstance = new HistoryApi();
        String uid = uid_example; // String | 
        String result = result_example; // String | 
        try {
            HistoryItem result = apiInstance.getHistoryLast(uid, result);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HistoryApi#getHistoryLast");
            e.printStackTrace();
        }
    }
}
String *uid = uid_example; // 
String *result = result_example; //  (optional)

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

// Get the last history event for a user
[apiInstance getHistoryLastWith:uid
    result:result
              completionHandler: ^(HistoryItem output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.HistoryApi()
var uid = uid_example; // {{String}} 
var opts = { 
  'result': result_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getHistoryLast(uid, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new HistoryApi();
            var uid = uid_example;  // String | 
            var result = result_example;  // String |  (optional) 

            try
            {
                // Get the last history event for a user
                HistoryItem result = apiInstance.getHistoryLast(uid, result);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HistoryApi.getHistoryLast: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiHistoryApi();
$uid = uid_example; // String | 
$result = result_example; // String | 

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

my $api_instance = WWW::SwaggerClient::HistoryApi->new();
my $uid = uid_example; # String | 
my $result = result_example; # String | 

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

# create an instance of the API class
api_instance = swagger_client.HistoryApi()
uid = uid_example # String | 
result = result_example # String |  (optional)

try: 
    # Get the last history event for a user
    api_response = api_instance.get_history_last(uid, result=result)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HistoryApi->getHistoryLast: %s\n" % e)

Parameters

Path parameters
Name Description
uid*
String
Required
Query parameters
Name Description
result
String

Responses

Status: 200 - History entry

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


Menuapp

addMenuApp

Create a new Menu Application within a Menu Category


/api/v1/menu/app/{cat}

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/menu/app/{cat}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenuappApi;

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        MenuApp body = ; // MenuApp | Menu Application to add
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        try {
            apiInstance.addMenuApp(body, cat);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#addMenuApp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        MenuApp body = ; // MenuApp | Menu Application to add
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        try {
            apiInstance.addMenuApp(body, cat);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#addMenuApp");
            e.printStackTrace();
        }
    }
}
MenuApp *body = ; // Menu Application to add
menuCatConfKey *cat = ; // Configuration key of Menu Category to work with

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

// Create a new Menu Application within a Menu Category
[apiInstance addMenuAppWith:body
    cat:cat
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var body = ; // {{MenuApp}} Menu Application to add
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with

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

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

            var apiInstance = new MenuappApi();
            var body = new MenuApp(); // MenuApp | Menu Application to add
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with

            try
            {
                // Create a new Menu Application within a Menu Category
                apiInstance.addMenuApp(body, cat);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.addMenuApp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenuappApi();
$body = ; // MenuApp | Menu Application to add
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $body = WWW::SwaggerClient::Object::MenuApp->new(); # MenuApp | Menu Application to add
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
body =  # MenuApp | Menu Application to add
cat =  # menuCatConfKey | Configuration key of Menu Category to work with

try: 
    # Create a new Menu Application within a Menu Category
    api_instance.add_menu_app(body, cat)
except ApiException as e:
    print("Exception when calling MenuappApi->addMenuApp: %s\n" % e)

Parameters

Path parameters
Name Description
cat*
menuCatConfKey
Configuration key of Menu Category to work with
Required
Body parameters
Name Description
body *

Responses

Status: 201 - Successful creation

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


deleteMenuApp

Deletes a Menu Application


/api/v1/menu/app/{cat}/{confKey}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/menu/app/{cat}/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenuappApi;

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application to delete
        try {
            apiInstance.deleteMenuApp(cat, confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#deleteMenuApp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application to delete
        try {
            apiInstance.deleteMenuApp(cat, confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#deleteMenuApp");
            e.printStackTrace();
        }
    }
}
menuCatConfKey *cat = ; // Configuration key of Menu Category to work with
confKey *confKey = ; // Configuration key of Menu Application to delete

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

// Deletes a Menu Application
[apiInstance deleteMenuAppWith:cat
    confKey:confKey
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with
var confKey = ; // {{confKey}} Configuration key of Menu Application to delete

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

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

            var apiInstance = new MenuappApi();
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with
            var confKey = new confKey(); // confKey | Configuration key of Menu Application to delete

            try
            {
                // Deletes a Menu Application
                apiInstance.deleteMenuApp(cat, confKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.deleteMenuApp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenuappApi();
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
$confKey = ; // confKey | Configuration key of Menu Application to delete

try {
    $api_instance->deleteMenuApp($cat, $confKey);
} catch (Exception $e) {
    echo 'Exception when calling MenuappApi->deleteMenuApp: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::MenuappApi;

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with
my $confKey = ; # confKey | Configuration key of Menu Application to delete

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
cat =  # menuCatConfKey | Configuration key of Menu Category to work with
confKey =  # confKey | Configuration key of Menu Application to delete

try: 
    # Deletes a Menu Application
    api_instance.delete_menu_app(cat, confKey)
except ApiException as e:
    print("Exception when calling MenuappApi->deleteMenuApp: %s\n" % e)

Parameters

Path parameters
Name Description
cat*
menuCatConfKey
Configuration key of Menu Category to work with
Required
confKey*
confKey
Configuration key of Menu Application to delete
Required

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


findMenuAppByConfKey

Finds Menu Applications by configuration key within a Menu Category

Takes a search pattern to be tested against existing applications within a menu category


/api/v1/menu/app/{cat}/findByConfKey

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/menu/app/{cat}/findByConfKey?pattern="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenuappApi;

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        String pattern = pattern_example; // String | Search pattern
        try {
            array[MenuApp] result = apiInstance.findMenuAppByConfKey(cat, pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#findMenuAppByConfKey");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        String pattern = pattern_example; // String | Search pattern
        try {
            array[MenuApp] result = apiInstance.findMenuAppByConfKey(cat, pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#findMenuAppByConfKey");
            e.printStackTrace();
        }
    }
}
menuCatConfKey *cat = ; // Configuration key of Menu Category to work with
String *pattern = pattern_example; // Search pattern

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

// Finds Menu Applications by configuration key within a Menu Category
[apiInstance findMenuAppByConfKeyWith:cat
    pattern:pattern
              completionHandler: ^(array[MenuApp] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with
var pattern = pattern_example; // {{String}} Search pattern

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

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

            var apiInstance = new MenuappApi();
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with
            var pattern = pattern_example;  // String | Search pattern

            try
            {
                // Finds Menu Applications by configuration key within a Menu Category
                array[MenuApp] result = apiInstance.findMenuAppByConfKey(cat, pattern);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.findMenuAppByConfKey: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenuappApi();
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
$pattern = pattern_example; // String | Search pattern

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with
my $pattern = pattern_example; # String | Search pattern

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
cat =  # menuCatConfKey | Configuration key of Menu Category to work with
pattern = pattern_example # String | Search pattern

try: 
    # Finds Menu Applications by configuration key within a Menu Category
    api_response = api_instance.find_menu_app_by_conf_key(cat, pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MenuappApi->findMenuAppByConfKey: %s\n" % e)

Parameters

Path parameters
Name Description
cat*
menuCatConfKey
Configuration key of Menu Category to work with
Required
Query parameters
Name Description
pattern*
String
Search pattern
Required

Responses

Status: 200 - Return a list of Menu Applications

Status: 400 - An error was encountered when processing the request


getMenuAppByConfKey

Get Menu Application within a Menu Category by configuration key

Returns a single application


/api/v1/menu/app/{cat}/{confKey}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/menu/app/{cat}/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenuappApi;

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application
        try {
            MenuApp result = apiInstance.getMenuAppByConfKey(cat, confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#getMenuAppByConfKey");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application
        try {
            MenuApp result = apiInstance.getMenuAppByConfKey(cat, confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#getMenuAppByConfKey");
            e.printStackTrace();
        }
    }
}
menuCatConfKey *cat = ; // Configuration key of Menu Category to work with
confKey *confKey = ; // Configuration key of Menu Application

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

// Get Menu Application within a Menu Category by configuration key
[apiInstance getMenuAppByConfKeyWith:cat
    confKey:confKey
              completionHandler: ^(MenuApp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with
var confKey = ; // {{confKey}} Configuration key of Menu Application

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

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

            var apiInstance = new MenuappApi();
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with
            var confKey = new confKey(); // confKey | Configuration key of Menu Application

            try
            {
                // Get Menu Application within a Menu Category by configuration key
                MenuApp result = apiInstance.getMenuAppByConfKey(cat, confKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.getMenuAppByConfKey: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenuappApi();
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
$confKey = ; // confKey | Configuration key of Menu Application

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with
my $confKey = ; # confKey | Configuration key of Menu Application

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
cat =  # menuCatConfKey | Configuration key of Menu Category to work with
confKey =  # confKey | Configuration key of Menu Application

try: 
    # Get Menu Application within a Menu Category by configuration key
    api_response = api_instance.get_menu_app_by_conf_key(cat, confKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MenuappApi->getMenuAppByConfKey: %s\n" % e)

Parameters

Path parameters
Name Description
cat*
menuCatConfKey
Configuration key of Menu Category to work with
Required
confKey*
confKey
Configuration key of Menu Application
Required

Responses

Status: 200 - Return a Menu Application

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


getMenuApps

Get Menu Applications within a Menu Category

Return existing applications within a menu category


/api/v1/menu/app/{cat}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/menu/app/{cat}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenuappApi;

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        try {
            array[MenuApp] result = apiInstance.getMenuApps(cat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#getMenuApps");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        try {
            array[MenuApp] result = apiInstance.getMenuApps(cat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#getMenuApps");
            e.printStackTrace();
        }
    }
}
menuCatConfKey *cat = ; // Configuration key of Menu Category to work with

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

// Get Menu Applications within a Menu Category
[apiInstance getMenuAppsWith:cat
              completionHandler: ^(array[MenuApp] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with

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

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

            var apiInstance = new MenuappApi();
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with

            try
            {
                // Get Menu Applications within a Menu Category
                array[MenuApp] result = apiInstance.getMenuApps(cat);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.getMenuApps: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenuappApi();
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
cat =  # menuCatConfKey | Configuration key of Menu Category to work with

try: 
    # Get Menu Applications within a Menu Category
    api_response = api_instance.get_menu_apps(cat)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MenuappApi->getMenuApps: %s\n" % e)

Parameters

Path parameters
Name Description
cat*
menuCatConfKey
Configuration key of Menu Category to work with
Required

Responses

Status: 200 - Return a list of Menu Applications

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


replaceMenuApp

Replaces a Menu Application


/api/v1/menu/app/{cat}/{confKey}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/menu/app/{cat}/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenuappApi;

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application that needs to be replaced
        MenuApp body = ; // MenuApp | 
        try {
            apiInstance.replaceMenuApp(cat, confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#replaceMenuApp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application that needs to be replaced
        MenuApp body = ; // MenuApp | 
        try {
            apiInstance.replaceMenuApp(cat, confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#replaceMenuApp");
            e.printStackTrace();
        }
    }
}
menuCatConfKey *cat = ; // Configuration key of Menu Category to work with
confKey *confKey = ; // Configuration key of Menu Application that needs to be replaced
MenuApp *body = ; //  (optional)

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

// Replaces a Menu Application
[apiInstance replaceMenuAppWith:cat
    confKey:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with
var confKey = ; // {{confKey}} Configuration key of Menu Application that needs to be replaced
var opts = { 
  'body':  // {{MenuApp}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.replaceMenuApp(catconfKey, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new MenuappApi();
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with
            var confKey = new confKey(); // confKey | Configuration key of Menu Application that needs to be replaced
            var body = new MenuApp(); // MenuApp |  (optional) 

            try
            {
                // Replaces a Menu Application
                apiInstance.replaceMenuApp(cat, confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.replaceMenuApp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenuappApi();
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
$confKey = ; // confKey | Configuration key of Menu Application that needs to be replaced
$body = ; // MenuApp | 

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with
my $confKey = ; # confKey | Configuration key of Menu Application that needs to be replaced
my $body = WWW::SwaggerClient::Object::MenuApp->new(); # MenuApp | 

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
cat =  # menuCatConfKey | Configuration key of Menu Category to work with
confKey =  # confKey | Configuration key of Menu Application that needs to be replaced
body =  # MenuApp |  (optional)

try: 
    # Replaces a Menu Application
    api_instance.replace_menu_app(cat, confKey, body=body)
except ApiException as e:
    print("Exception when calling MenuappApi->replaceMenuApp: %s\n" % e)

Parameters

Path parameters
Name Description
cat*
menuCatConfKey
Configuration key of Menu Category to work with
Required
confKey*
confKey
Configuration key of Menu Application that needs to be replaced
Required
Body parameters
Name Description
body

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


updateMenuApp

Updates a Menu Application


/api/v1/menu/app/{cat}/{confKey}

Usage and SDK Samples

curl -X PATCH\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/menu/app/{cat}/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenuappApi;

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

public class MenuappApiExample {

    public static void main(String[] args) {
        
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application that needs to be updated
        MenuAppUpdate body = ; // MenuAppUpdate | 
        try {
            apiInstance.updateMenuApp(cat, confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#updateMenuApp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenuappApi;

public class MenuappApiExample {

    public static void main(String[] args) {
        MenuappApi apiInstance = new MenuappApi();
        menuCatConfKey cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
        confKey confKey = ; // confKey | Configuration key of Menu Application that needs to be updated
        MenuAppUpdate body = ; // MenuAppUpdate | 
        try {
            apiInstance.updateMenuApp(cat, confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenuappApi#updateMenuApp");
            e.printStackTrace();
        }
    }
}
menuCatConfKey *cat = ; // Configuration key of Menu Category to work with
confKey *confKey = ; // Configuration key of Menu Application that needs to be updated
MenuAppUpdate *body = ; //  (optional)

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

// Updates a Menu Application
[apiInstance updateMenuAppWith:cat
    confKey:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenuappApi()
var cat = ; // {{menuCatConfKey}} Configuration key of Menu Category to work with
var confKey = ; // {{confKey}} Configuration key of Menu Application that needs to be updated
var opts = { 
  'body':  // {{MenuAppUpdate}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateMenuApp(catconfKey, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new MenuappApi();
            var cat = new menuCatConfKey(); // menuCatConfKey | Configuration key of Menu Category to work with
            var confKey = new confKey(); // confKey | Configuration key of Menu Application that needs to be updated
            var body = new MenuAppUpdate(); // MenuAppUpdate |  (optional) 

            try
            {
                // Updates a Menu Application
                apiInstance.updateMenuApp(cat, confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenuappApi.updateMenuApp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenuappApi();
$cat = ; // menuCatConfKey | Configuration key of Menu Category to work with
$confKey = ; // confKey | Configuration key of Menu Application that needs to be updated
$body = ; // MenuAppUpdate | 

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

my $api_instance = WWW::SwaggerClient::MenuappApi->new();
my $cat = ; # menuCatConfKey | Configuration key of Menu Category to work with
my $confKey = ; # confKey | Configuration key of Menu Application that needs to be updated
my $body = WWW::SwaggerClient::Object::MenuAppUpdate->new(); # MenuAppUpdate | 

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

# create an instance of the API class
api_instance = swagger_client.MenuappApi()
cat =  # menuCatConfKey | Configuration key of Menu Category to work with
confKey =  # confKey | Configuration key of Menu Application that needs to be updated
body =  # MenuAppUpdate |  (optional)

try: 
    # Updates a Menu Application
    api_instance.update_menu_app(cat, confKey, body=body)
except ApiException as e:
    print("Exception when calling MenuappApi->updateMenuApp: %s\n" % e)

Parameters

Path parameters
Name Description
cat*
menuCatConfKey
Configuration key of Menu Category to work with
Required
confKey*
confKey
Configuration key of Menu Application that needs to be updated
Required
Body parameters
Name Description
body

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


Menucat

addMenuCat

Create a new Menu Category


/api/v1/menu/cat

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/menu/cat"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenucatApi;

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

public class MenucatApiExample {

    public static void main(String[] args) {
        
        MenucatApi apiInstance = new MenucatApi();
        MenuCat body = ; // MenuCat | Menu Category to add
        try {
            apiInstance.addMenuCat(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#addMenuCat");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenucatApi;

public class MenucatApiExample {

    public static void main(String[] args) {
        MenucatApi apiInstance = new MenucatApi();
        MenuCat body = ; // MenuCat | Menu Category to add
        try {
            apiInstance.addMenuCat(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#addMenuCat");
            e.printStackTrace();
        }
    }
}
MenuCat *body = ; // Menu Category to add

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

// Create a new Menu Category
[apiInstance addMenuCatWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenucatApi()
var body = ; // {{MenuCat}} Menu Category to add

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

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

            var apiInstance = new MenucatApi();
            var body = new MenuCat(); // MenuCat | Menu Category to add

            try
            {
                // Create a new Menu Category
                apiInstance.addMenuCat(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenucatApi.addMenuCat: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenucatApi();
$body = ; // MenuCat | Menu Category to add

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

my $api_instance = WWW::SwaggerClient::MenucatApi->new();
my $body = WWW::SwaggerClient::Object::MenuCat->new(); # MenuCat | Menu Category to add

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

# create an instance of the API class
api_instance = swagger_client.MenucatApi()
body =  # MenuCat | Menu Category to add

try: 
    # Create a new Menu Category
    api_instance.add_menu_cat(body)
except ApiException as e:
    print("Exception when calling MenucatApi->addMenuCat: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Successful creation

Status: 400 - An error was encountered when processing the request

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


deleteMenuCat

Deletes a Menu Category


/api/v1/menu/cat/{confKey}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/menu/cat/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenucatApi;

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

public class MenucatApiExample {

    public static void main(String[] args) {
        
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category to delete
        try {
            apiInstance.deleteMenuCat(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#deleteMenuCat");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenucatApi;

public class MenucatApiExample {

    public static void main(String[] args) {
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category to delete
        try {
            apiInstance.deleteMenuCat(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#deleteMenuCat");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of Menu Category to delete

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

// Deletes a Menu Category
[apiInstance deleteMenuCatWith:confKey
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenucatApi()
var confKey = ; // {{confKey}} Configuration key of Menu Category to delete

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

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

            var apiInstance = new MenucatApi();
            var confKey = new confKey(); // confKey | Configuration key of Menu Category to delete

            try
            {
                // Deletes a Menu Category
                apiInstance.deleteMenuCat(confKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenucatApi.deleteMenuCat: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenucatApi();
$confKey = ; // confKey | Configuration key of Menu Category to delete

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

my $api_instance = WWW::SwaggerClient::MenucatApi->new();
my $confKey = ; # confKey | Configuration key of Menu Category to delete

eval { 
    $api_instance->deleteMenuCat(confKey => $confKey);
};
if ($@) {
    warn "Exception when calling MenucatApi->deleteMenuCat: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.MenucatApi()
confKey =  # confKey | Configuration key of Menu Category to delete

try: 
    # Deletes a Menu Category
    api_instance.delete_menu_cat(confKey)
except ApiException as e:
    print("Exception when calling MenucatApi->deleteMenuCat: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of Menu Category to delete
Required

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


findMenuCatByConfKey

Finds Menu Categories by configuration key

Takes a search pattern to be tested against existing categories


/api/v1/menu/cat/findByConfKey

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/menu/cat/findByConfKey?pattern="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenucatApi;

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

public class MenucatApiExample {

    public static void main(String[] args) {
        
        MenucatApi apiInstance = new MenucatApi();
        String pattern = pattern_example; // String | Search pattern
        try {
            array[MenuCat] result = apiInstance.findMenuCatByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#findMenuCatByConfKey");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenucatApi;

public class MenucatApiExample {

    public static void main(String[] args) {
        MenucatApi apiInstance = new MenucatApi();
        String pattern = pattern_example; // String | Search pattern
        try {
            array[MenuCat] result = apiInstance.findMenuCatByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#findMenuCatByConfKey");
            e.printStackTrace();
        }
    }
}
String *pattern = pattern_example; // Search pattern

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

// Finds Menu Categories by configuration key
[apiInstance findMenuCatByConfKeyWith:pattern
              completionHandler: ^(array[MenuCat] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenucatApi()
var pattern = pattern_example; // {{String}} Search pattern

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

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

            var apiInstance = new MenucatApi();
            var pattern = pattern_example;  // String | Search pattern

            try
            {
                // Finds Menu Categories by configuration key
                array[MenuCat] result = apiInstance.findMenuCatByConfKey(pattern);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenucatApi.findMenuCatByConfKey: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenucatApi();
$pattern = pattern_example; // String | Search pattern

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

my $api_instance = WWW::SwaggerClient::MenucatApi->new();
my $pattern = pattern_example; # String | Search pattern

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

# create an instance of the API class
api_instance = swagger_client.MenucatApi()
pattern = pattern_example # String | Search pattern

try: 
    # Finds Menu Categories by configuration key
    api_response = api_instance.find_menu_cat_by_conf_key(pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MenucatApi->findMenuCatByConfKey: %s\n" % e)

Parameters

Query parameters
Name Description
pattern*
String
Search pattern
Required

Responses

Status: 200 - Return a list of Menu Categories

Status: 400 - An error was encountered when processing the request


getMenuCatByConfKey

Get Menu Category by configuration key

Returns a single Category


/api/v1/menu/cat/{confKey}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/menu/cat/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenucatApi;

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

public class MenucatApiExample {

    public static void main(String[] args) {
        
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category
        try {
            MenuCat result = apiInstance.getMenuCatByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#getMenuCatByConfKey");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenucatApi;

public class MenucatApiExample {

    public static void main(String[] args) {
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category
        try {
            MenuCat result = apiInstance.getMenuCatByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#getMenuCatByConfKey");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of Menu Category

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

// Get Menu Category by configuration key
[apiInstance getMenuCatByConfKeyWith:confKey
              completionHandler: ^(MenuCat output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenucatApi()
var confKey = ; // {{confKey}} Configuration key of Menu Category

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

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

            var apiInstance = new MenucatApi();
            var confKey = new confKey(); // confKey | Configuration key of Menu Category

            try
            {
                // Get Menu Category by configuration key
                MenuCat result = apiInstance.getMenuCatByConfKey(confKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenucatApi.getMenuCatByConfKey: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenucatApi();
$confKey = ; // confKey | Configuration key of Menu Category

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

my $api_instance = WWW::SwaggerClient::MenucatApi->new();
my $confKey = ; # confKey | Configuration key of Menu Category

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

# create an instance of the API class
api_instance = swagger_client.MenucatApi()
confKey =  # confKey | Configuration key of Menu Category

try: 
    # Get Menu Category by configuration key
    api_response = api_instance.get_menu_cat_by_conf_key(confKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MenucatApi->getMenuCatByConfKey: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of Menu Category
Required

Responses

Status: 200 - Return a Menu Category

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


replaceMenuCat

Replaces a Menu Category


/api/v1/menu/cat/{confKey}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/menu/cat/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenucatApi;

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

public class MenucatApiExample {

    public static void main(String[] args) {
        
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category that needs to be replaced
        MenuCat body = ; // MenuCat | 
        try {
            apiInstance.replaceMenuCat(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#replaceMenuCat");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenucatApi;

public class MenucatApiExample {

    public static void main(String[] args) {
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category that needs to be replaced
        MenuCat body = ; // MenuCat | 
        try {
            apiInstance.replaceMenuCat(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#replaceMenuCat");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of Menu Category that needs to be replaced
MenuCat *body = ; //  (optional)

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

// Replaces a Menu Category
[apiInstance replaceMenuCatWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenucatApi()
var confKey = ; // {{confKey}} Configuration key of Menu Category that needs to be replaced
var opts = { 
  'body':  // {{MenuCat}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.replaceMenuCat(confKey, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new MenucatApi();
            var confKey = new confKey(); // confKey | Configuration key of Menu Category that needs to be replaced
            var body = new MenuCat(); // MenuCat |  (optional) 

            try
            {
                // Replaces a Menu Category
                apiInstance.replaceMenuCat(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenucatApi.replaceMenuCat: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenucatApi();
$confKey = ; // confKey | Configuration key of Menu Category that needs to be replaced
$body = ; // MenuCat | 

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

my $api_instance = WWW::SwaggerClient::MenucatApi->new();
my $confKey = ; # confKey | Configuration key of Menu Category that needs to be replaced
my $body = WWW::SwaggerClient::Object::MenuCat->new(); # MenuCat | 

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

# create an instance of the API class
api_instance = swagger_client.MenucatApi()
confKey =  # confKey | Configuration key of Menu Category that needs to be replaced
body =  # MenuCat |  (optional)

try: 
    # Replaces a Menu Category
    api_instance.replace_menu_cat(confKey, body=body)
except ApiException as e:
    print("Exception when calling MenucatApi->replaceMenuCat: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of Menu Category that needs to be replaced
Required
Body parameters
Name Description
body

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


updateMenuCat

Updates a Menu Category


/api/v1/menu/cat/{confKey}

Usage and SDK Samples

curl -X PATCH\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/menu/cat/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.MenucatApi;

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

public class MenucatApiExample {

    public static void main(String[] args) {
        
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category that needs to be updated
        MenuCatUpdate body = ; // MenuCatUpdate | 
        try {
            apiInstance.updateMenuCat(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#updateMenuCat");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.MenucatApi;

public class MenucatApiExample {

    public static void main(String[] args) {
        MenucatApi apiInstance = new MenucatApi();
        confKey confKey = ; // confKey | Configuration key of Menu Category that needs to be updated
        MenuCatUpdate body = ; // MenuCatUpdate | 
        try {
            apiInstance.updateMenuCat(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MenucatApi#updateMenuCat");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of Menu Category that needs to be updated
MenuCatUpdate *body = ; //  (optional)

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

// Updates a Menu Category
[apiInstance updateMenuCatWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.MenucatApi()
var confKey = ; // {{confKey}} Configuration key of Menu Category that needs to be updated
var opts = { 
  'body':  // {{MenuCatUpdate}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateMenuCat(confKey, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new MenucatApi();
            var confKey = new confKey(); // confKey | Configuration key of Menu Category that needs to be updated
            var body = new MenuCatUpdate(); // MenuCatUpdate |  (optional) 

            try
            {
                // Updates a Menu Category
                apiInstance.updateMenuCat(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MenucatApi.updateMenuCat: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiMenucatApi();
$confKey = ; // confKey | Configuration key of Menu Category that needs to be updated
$body = ; // MenuCatUpdate | 

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

my $api_instance = WWW::SwaggerClient::MenucatApi->new();
my $confKey = ; # confKey | Configuration key of Menu Category that needs to be updated
my $body = WWW::SwaggerClient::Object::MenuCatUpdate->new(); # MenuCatUpdate | 

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

# create an instance of the API class
api_instance = swagger_client.MenucatApi()
confKey =  # confKey | Configuration key of Menu Category that needs to be updated
body =  # MenuCatUpdate |  (optional)

try: 
    # Updates a Menu Category
    api_instance.update_menu_cat(confKey, body=body)
except ApiException as e:
    print("Exception when calling MenucatApi->updateMenuCat: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of Menu Category that needs to be updated
Required
Body parameters
Name Description
body

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


Oidcrp

addoidcrp

Create a new OpenID Connect Relying Party


/api/v1/providers/oidc/rp

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/providers/oidc/rp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OidcrpApi;

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        OidcRp body = ; // OidcRp | OpenID Connect Relying Party to add
        try {
            apiInstance.addoidcrp(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#addoidcrp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        OidcRp body = ; // OidcRp | OpenID Connect Relying Party to add
        try {
            apiInstance.addoidcrp(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#addoidcrp");
            e.printStackTrace();
        }
    }
}
OidcRp *body = ; // OpenID Connect Relying Party to add

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

// Create a new OpenID Connect Relying Party
[apiInstance addoidcrpWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var body = ; // {{OidcRp}} OpenID Connect Relying Party to add

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

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

            var apiInstance = new OidcrpApi();
            var body = new OidcRp(); // OidcRp | OpenID Connect Relying Party to add

            try
            {
                // Create a new OpenID Connect Relying Party
                apiInstance.addoidcrp(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.addoidcrp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOidcrpApi();
$body = ; // OidcRp | OpenID Connect Relying Party to add

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $body = WWW::SwaggerClient::Object::OidcRp->new(); # OidcRp | OpenID Connect Relying Party to add

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
body =  # OidcRp | OpenID Connect Relying Party to add

try: 
    # Create a new OpenID Connect Relying Party
    api_instance.addoidcrp(body)
except ApiException as e:
    print("Exception when calling OidcrpApi->addoidcrp: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Successful creation

Status: 400 - An error was encountered when processing the request

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


deleteOidcRp

Deletes a OpenID Connect Relying Party


/api/v1/providers/oidc/rp/{confKey}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/providers/oidc/rp/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OidcrpApi;

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relying Party to delete
        try {
            apiInstance.deleteOidcRp(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#deleteOidcRp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relying Party to delete
        try {
            apiInstance.deleteOidcRp(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#deleteOidcRp");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of OpenID Connect Relying Party to delete

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

// Deletes a OpenID Connect Relying Party
[apiInstance deleteOidcRpWith:confKey
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var confKey = ; // {{confKey}} Configuration key of OpenID Connect Relying Party to delete

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

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

            var apiInstance = new OidcrpApi();
            var confKey = new confKey(); // confKey | Configuration key of OpenID Connect Relying Party to delete

            try
            {
                // Deletes a OpenID Connect Relying Party
                apiInstance.deleteOidcRp(confKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.deleteOidcRp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOidcrpApi();
$confKey = ; // confKey | Configuration key of OpenID Connect Relying Party to delete

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $confKey = ; # confKey | Configuration key of OpenID Connect Relying Party to delete

eval { 
    $api_instance->deleteOidcRp(confKey => $confKey);
};
if ($@) {
    warn "Exception when calling OidcrpApi->deleteOidcRp: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
confKey =  # confKey | Configuration key of OpenID Connect Relying Party to delete

try: 
    # Deletes a OpenID Connect Relying Party
    api_instance.delete_oidc_rp(confKey)
except ApiException as e:
    print("Exception when calling OidcrpApi->deleteOidcRp: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of OpenID Connect Relying Party to delete
Required

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


findOidcRpByClientId

Finds OpenID Connect Relying Party by Client ID


/api/v1/providers/oidc/rp/findByClientId

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/providers/oidc/rp/findByClientId?clientId="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OidcrpApi;

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        String clientId = clientId_example; // String | Client ID to search
        try {
            OidcRp result = apiInstance.findOidcRpByClientId(clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#findOidcRpByClientId");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        String clientId = clientId_example; // String | Client ID to search
        try {
            OidcRp result = apiInstance.findOidcRpByClientId(clientId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#findOidcRpByClientId");
            e.printStackTrace();
        }
    }
}
String *clientId = clientId_example; // Client ID to search

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

// Finds OpenID Connect Relying Party by Client ID
[apiInstance findOidcRpByClientIdWith:clientId
              completionHandler: ^(OidcRp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var clientId = clientId_example; // {{String}} Client ID to search

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

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

            var apiInstance = new OidcrpApi();
            var clientId = clientId_example;  // String | Client ID to search

            try
            {
                // Finds OpenID Connect Relying Party by Client ID
                OidcRp result = apiInstance.findOidcRpByClientId(clientId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.findOidcRpByClientId: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOidcrpApi();
$clientId = clientId_example; // String | Client ID to search

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $clientId = clientId_example; # String | Client ID to search

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
clientId = clientId_example # String | Client ID to search

try: 
    # Finds OpenID Connect Relying Party by Client ID
    api_response = api_instance.find_oidc_rp_by_client_id(clientId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OidcrpApi->findOidcRpByClientId: %s\n" % e)

Parameters

Query parameters
Name Description
clientId*
String
Client ID to search
Required

Responses

Status: 200 - Return an OpenID Connect Provider

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


findOidcRpByConfKey

Finds OpenID Connect Relying Partys by configuration key

Takes a search pattern to be tested against existing service providers


/api/v1/providers/oidc/rp/findByConfKey

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/providers/oidc/rp/findByConfKey?pattern="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OidcrpApi;

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        confKey pattern = ; // confKey | Search pattern
        try {
            array[OidcRp] result = apiInstance.findOidcRpByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#findOidcRpByConfKey");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        confKey pattern = ; // confKey | Search pattern
        try {
            array[OidcRp] result = apiInstance.findOidcRpByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#findOidcRpByConfKey");
            e.printStackTrace();
        }
    }
}
confKey *pattern = ; // Search pattern

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

// Finds OpenID Connect Relying Partys by configuration key
[apiInstance findOidcRpByConfKeyWith:pattern
              completionHandler: ^(array[OidcRp] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var pattern = ; // {{confKey}} Search pattern

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

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

            var apiInstance = new OidcrpApi();
            var pattern = new confKey(); // confKey | Search pattern

            try
            {
                // Finds OpenID Connect Relying Partys by configuration key
                array[OidcRp] result = apiInstance.findOidcRpByConfKey(pattern);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.findOidcRpByConfKey: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOidcrpApi();
$pattern = ; // confKey | Search pattern

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $pattern = ; # confKey | Search pattern

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
pattern =  # confKey | Search pattern

try: 
    # Finds OpenID Connect Relying Partys by configuration key
    api_response = api_instance.find_oidc_rp_by_conf_key(pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OidcrpApi->findOidcRpByConfKey: %s\n" % e)

Parameters

Query parameters
Name Description
pattern*
confKey
Search pattern
Required

Responses

Status: 200 - Return a list of OpenID Connect Providers

Status: 400 - An error was encountered when processing the request


getOidcRpByConfKey

Get OpenID Connect Relying Party by configuration key

Returns a single Service Provider


/api/v1/providers/oidc/rp/{confKey}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/providers/oidc/rp/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OidcrpApi;

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relying Party
        try {
            OidcRp result = apiInstance.getOidcRpByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#getOidcRpByConfKey");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relying Party
        try {
            OidcRp result = apiInstance.getOidcRpByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#getOidcRpByConfKey");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of OpenID Connect Relying Party

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

// Get OpenID Connect Relying Party by configuration key
[apiInstance getOidcRpByConfKeyWith:confKey
              completionHandler: ^(OidcRp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var confKey = ; // {{confKey}} Configuration key of OpenID Connect Relying Party

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

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

            var apiInstance = new OidcrpApi();
            var confKey = new confKey(); // confKey | Configuration key of OpenID Connect Relying Party

            try
            {
                // Get OpenID Connect Relying Party by configuration key
                OidcRp result = apiInstance.getOidcRpByConfKey(confKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.getOidcRpByConfKey: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOidcrpApi();
$confKey = ; // confKey | Configuration key of OpenID Connect Relying Party

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $confKey = ; # confKey | Configuration key of OpenID Connect Relying Party

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
confKey =  # confKey | Configuration key of OpenID Connect Relying Party

try: 
    # Get OpenID Connect Relying Party by configuration key
    api_response = api_instance.get_oidc_rp_by_conf_key(confKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OidcrpApi->getOidcRpByConfKey: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of OpenID Connect Relying Party
Required

Responses

Status: 200 - Return an OpenID Connect Provider

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


replaceOidcRp

Replaces an OpenID Connect Relying Party


/api/v1/providers/oidc/rp/{confKey}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/providers/oidc/rp/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OidcrpApi;

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relying Party that needs to be replaced
        OidcRpReplace body = ; // OidcRpReplace | 
        try {
            apiInstance.replaceOidcRp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#replaceOidcRp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relying Party that needs to be replaced
        OidcRpReplace body = ; // OidcRpReplace | 
        try {
            apiInstance.replaceOidcRp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#replaceOidcRp");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of OpenID Connect Relying Party that needs to be replaced
OidcRpReplace *body = ; //  (optional)

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

// Replaces an OpenID Connect Relying Party
[apiInstance replaceOidcRpWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var confKey = ; // {{confKey}} Configuration key of OpenID Connect Relying Party that needs to be replaced
var opts = { 
  'body':  // {{OidcRpReplace}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.replaceOidcRp(confKey, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new OidcrpApi();
            var confKey = new confKey(); // confKey | Configuration key of OpenID Connect Relying Party that needs to be replaced
            var body = new OidcRpReplace(); // OidcRpReplace |  (optional) 

            try
            {
                // Replaces an OpenID Connect Relying Party
                apiInstance.replaceOidcRp(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.replaceOidcRp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOidcrpApi();
$confKey = ; // confKey | Configuration key of OpenID Connect Relying Party that needs to be replaced
$body = ; // OidcRpReplace | 

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $confKey = ; # confKey | Configuration key of OpenID Connect Relying Party that needs to be replaced
my $body = WWW::SwaggerClient::Object::OidcRpReplace->new(); # OidcRpReplace | 

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
confKey =  # confKey | Configuration key of OpenID Connect Relying Party that needs to be replaced
body =  # OidcRpReplace |  (optional)

try: 
    # Replaces an OpenID Connect Relying Party
    api_instance.replace_oidc_rp(confKey, body=body)
except ApiException as e:
    print("Exception when calling OidcrpApi->replaceOidcRp: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of OpenID Connect Relying Party that needs to be replaced
Required
Body parameters
Name Description
body

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


updateOidcRp

Updates an OpenID Connect Relying Party


/api/v1/providers/oidc/rp/{confKey}

Usage and SDK Samples

curl -X PATCH\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/providers/oidc/rp/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OidcrpApi;

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

public class OidcrpApiExample {

    public static void main(String[] args) {
        
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relying Party that needs to be updated
        OidcRpUpdate body = ; // OidcRpUpdate | 
        try {
            apiInstance.updateOidcRp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#updateOidcRp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OidcrpApi;

public class OidcrpApiExample {

    public static void main(String[] args) {
        OidcrpApi apiInstance = new OidcrpApi();
        confKey confKey = ; // confKey | Configuration key of OpenID Connect Relying Party that needs to be updated
        OidcRpUpdate body = ; // OidcRpUpdate | 
        try {
            apiInstance.updateOidcRp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling OidcrpApi#updateOidcRp");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of OpenID Connect Relying Party that needs to be updated
OidcRpUpdate *body = ; //  (optional)

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

// Updates an OpenID Connect Relying Party
[apiInstance updateOidcRpWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.OidcrpApi()
var confKey = ; // {{confKey}} Configuration key of OpenID Connect Relying Party that needs to be updated
var opts = { 
  'body':  // {{OidcRpUpdate}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateOidcRp(confKey, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new OidcrpApi();
            var confKey = new confKey(); // confKey | Configuration key of OpenID Connect Relying Party that needs to be updated
            var body = new OidcRpUpdate(); // OidcRpUpdate |  (optional) 

            try
            {
                // Updates an OpenID Connect Relying Party
                apiInstance.updateOidcRp(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OidcrpApi.updateOidcRp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiOidcrpApi();
$confKey = ; // confKey | Configuration key of OpenID Connect Relying Party that needs to be updated
$body = ; // OidcRpUpdate | 

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

my $api_instance = WWW::SwaggerClient::OidcrpApi->new();
my $confKey = ; # confKey | Configuration key of OpenID Connect Relying Party that needs to be updated
my $body = WWW::SwaggerClient::Object::OidcRpUpdate->new(); # OidcRpUpdate | 

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

# create an instance of the API class
api_instance = swagger_client.OidcrpApi()
confKey =  # confKey | Configuration key of OpenID Connect Relying Party that needs to be updated
body =  # OidcRpUpdate |  (optional)

try: 
    # Updates an OpenID Connect Relying Party
    api_instance.update_oidc_rp(confKey, body=body)
except ApiException as e:
    print("Exception when calling OidcrpApi->updateOidcRp: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of OpenID Connect Relying Party that needs to be updated
Required
Body parameters
Name Description
body

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


Samlsp

addsamlsp

Create a new SAML Service provider


/api/v1/providers/saml/sp

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/providers/saml/sp"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SamlspApi;

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        SamlSp body = ; // SamlSp | SAML Service provider to add
        try {
            apiInstance.addsamlsp(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#addsamlsp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        SamlSp body = ; // SamlSp | SAML Service provider to add
        try {
            apiInstance.addsamlsp(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#addsamlsp");
            e.printStackTrace();
        }
    }
}
SamlSp *body = ; // SAML Service provider to add

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

// Create a new SAML Service provider
[apiInstance addsamlspWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var body = ; // {{SamlSp}} SAML Service provider to add

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

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

            var apiInstance = new SamlspApi();
            var body = new SamlSp(); // SamlSp | SAML Service provider to add

            try
            {
                // Create a new SAML Service provider
                apiInstance.addsamlsp(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.addsamlsp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSamlspApi();
$body = ; // SamlSp | SAML Service provider to add

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $body = WWW::SwaggerClient::Object::SamlSp->new(); # SamlSp | SAML Service provider to add

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
body =  # SamlSp | SAML Service provider to add

try: 
    # Create a new SAML Service provider
    api_instance.addsamlsp(body)
except ApiException as e:
    print("Exception when calling SamlspApi->addsamlsp: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Successful creation

Status: 400 - An error was encountered when processing the request

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


deleteSamlSp

Deletes a SAML Service Provider


/api/v1/providers/saml/sp/{confKey}

Usage and SDK Samples

curl -X DELETE\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/providers/saml/sp/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SamlspApi;

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider to delete
        try {
            apiInstance.deleteSamlSp(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#deleteSamlSp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider to delete
        try {
            apiInstance.deleteSamlSp(confKey);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#deleteSamlSp");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of SAML Service Provider to delete

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

// Deletes a SAML Service Provider
[apiInstance deleteSamlSpWith:confKey
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var confKey = ; // {{confKey}} Configuration key of SAML Service Provider to delete

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

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

            var apiInstance = new SamlspApi();
            var confKey = new confKey(); // confKey | Configuration key of SAML Service Provider to delete

            try
            {
                // Deletes a SAML Service Provider
                apiInstance.deleteSamlSp(confKey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.deleteSamlSp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSamlspApi();
$confKey = ; // confKey | Configuration key of SAML Service Provider to delete

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $confKey = ; # confKey | Configuration key of SAML Service Provider to delete

eval { 
    $api_instance->deleteSamlSp(confKey => $confKey);
};
if ($@) {
    warn "Exception when calling SamlspApi->deleteSamlSp: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
confKey =  # confKey | Configuration key of SAML Service Provider to delete

try: 
    # Deletes a SAML Service Provider
    api_instance.delete_saml_sp(confKey)
except ApiException as e:
    print("Exception when calling SamlspApi->deleteSamlSp: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of SAML Service Provider to delete
Required

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


findSamlSpByConfKey

Finds SAML Service providers by configuration key

Takes a search pattern to be tested against existing service providers


/api/v1/providers/saml/sp/findByConfKey

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/providers/saml/sp/findByConfKey?pattern="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SamlspApi;

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        String pattern = pattern_example; // String | Search pattern
        try {
            array[SamlSp] result = apiInstance.findSamlSpByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#findSamlSpByConfKey");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        String pattern = pattern_example; // String | Search pattern
        try {
            array[SamlSp] result = apiInstance.findSamlSpByConfKey(pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#findSamlSpByConfKey");
            e.printStackTrace();
        }
    }
}
String *pattern = pattern_example; // Search pattern

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

// Finds SAML Service providers by configuration key
[apiInstance findSamlSpByConfKeyWith:pattern
              completionHandler: ^(array[SamlSp] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var pattern = pattern_example; // {{String}} Search pattern

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

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

            var apiInstance = new SamlspApi();
            var pattern = pattern_example;  // String | Search pattern

            try
            {
                // Finds SAML Service providers by configuration key
                array[SamlSp] result = apiInstance.findSamlSpByConfKey(pattern);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.findSamlSpByConfKey: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSamlspApi();
$pattern = pattern_example; // String | Search pattern

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $pattern = pattern_example; # String | Search pattern

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
pattern = pattern_example # String | Search pattern

try: 
    # Finds SAML Service providers by configuration key
    api_response = api_instance.find_saml_sp_by_conf_key(pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SamlspApi->findSamlSpByConfKey: %s\n" % e)

Parameters

Query parameters
Name Description
pattern*
String
Search pattern
Required

Responses

Status: 200 - Return a list of SAML Providers

Status: 400 - An error was encountered when processing the request


findSamlSpByEntityId

Finds SAML Service Provider by Entity ID


/api/v1/providers/saml/sp/findByEntityId

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/providers/saml/sp/findByEntityId?entityId="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SamlspApi;

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        String entityId = entityId_example; // String | Entity ID to search
        try {
            SamlSp result = apiInstance.findSamlSpByEntityId(entityId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#findSamlSpByEntityId");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        String entityId = entityId_example; // String | Entity ID to search
        try {
            SamlSp result = apiInstance.findSamlSpByEntityId(entityId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#findSamlSpByEntityId");
            e.printStackTrace();
        }
    }
}
String *entityId = entityId_example; // Entity ID to search

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

// Finds SAML Service Provider by Entity ID
[apiInstance findSamlSpByEntityIdWith:entityId
              completionHandler: ^(SamlSp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var entityId = entityId_example; // {{String}} Entity ID to search

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

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

            var apiInstance = new SamlspApi();
            var entityId = entityId_example;  // String | Entity ID to search

            try
            {
                // Finds SAML Service Provider by Entity ID
                SamlSp result = apiInstance.findSamlSpByEntityId(entityId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.findSamlSpByEntityId: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSamlspApi();
$entityId = entityId_example; // String | Entity ID to search

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $entityId = entityId_example; # String | Entity ID to search

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
entityId = entityId_example # String | Entity ID to search

try: 
    # Finds SAML Service Provider by Entity ID
    api_response = api_instance.find_saml_sp_by_entity_id(entityId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SamlspApi->findSamlSpByEntityId: %s\n" % e)

Parameters

Query parameters
Name Description
entityId*
String
Entity ID to search
Required

Responses

Status: 200 - Return a SAML Provider

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


getSamlSpByConfKey

Get SAML Service Provider by configuration key

Returns a single Service Provider


/api/v1/providers/saml/sp/{confKey}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"https://manager-api.example.com/api/v1/providers/saml/sp/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SamlspApi;

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider
        try {
            SamlSp result = apiInstance.getSamlSpByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#getSamlSpByConfKey");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider
        try {
            SamlSp result = apiInstance.getSamlSpByConfKey(confKey);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#getSamlSpByConfKey");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of SAML Service Provider

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

// Get SAML Service Provider by configuration key
[apiInstance getSamlSpByConfKeyWith:confKey
              completionHandler: ^(SamlSp output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var confKey = ; // {{confKey}} Configuration key of SAML Service Provider

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

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

            var apiInstance = new SamlspApi();
            var confKey = new confKey(); // confKey | Configuration key of SAML Service Provider

            try
            {
                // Get SAML Service Provider by configuration key
                SamlSp result = apiInstance.getSamlSpByConfKey(confKey);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.getSamlSpByConfKey: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSamlspApi();
$confKey = ; // confKey | Configuration key of SAML Service Provider

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $confKey = ; # confKey | Configuration key of SAML Service Provider

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
confKey =  # confKey | Configuration key of SAML Service Provider

try: 
    # Get SAML Service Provider by configuration key
    api_response = api_instance.get_saml_sp_by_conf_key(confKey)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SamlspApi->getSamlSpByConfKey: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of SAML Service Provider
Required

Responses

Status: 200 - Return a SAML Provider

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found


replaceSamlSp

Replaces a SAML Service


/api/v1/providers/saml/sp/{confKey}

Usage and SDK Samples

curl -X PUT\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/providers/saml/sp/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SamlspApi;

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider that needs to be replaced
        SamlSpReplace body = ; // SamlSpReplace | 
        try {
            apiInstance.replaceSamlSp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#replaceSamlSp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider that needs to be replaced
        SamlSpReplace body = ; // SamlSpReplace | 
        try {
            apiInstance.replaceSamlSp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#replaceSamlSp");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of SAML Service Provider that needs to be replaced
SamlSpReplace *body = ; //  (optional)

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

// Replaces a SAML Service
[apiInstance replaceSamlSpWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var confKey = ; // {{confKey}} Configuration key of SAML Service Provider that needs to be replaced
var opts = { 
  'body':  // {{SamlSpReplace}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.replaceSamlSp(confKey, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new SamlspApi();
            var confKey = new confKey(); // confKey | Configuration key of SAML Service Provider that needs to be replaced
            var body = new SamlSpReplace(); // SamlSpReplace |  (optional) 

            try
            {
                // Replaces a SAML Service
                apiInstance.replaceSamlSp(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.replaceSamlSp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSamlspApi();
$confKey = ; // confKey | Configuration key of SAML Service Provider that needs to be replaced
$body = ; // SamlSpReplace | 

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $confKey = ; # confKey | Configuration key of SAML Service Provider that needs to be replaced
my $body = WWW::SwaggerClient::Object::SamlSpReplace->new(); # SamlSpReplace | 

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
confKey =  # confKey | Configuration key of SAML Service Provider that needs to be replaced
body =  # SamlSpReplace |  (optional)

try: 
    # Replaces a SAML Service
    api_instance.replace_saml_sp(confKey, body=body)
except ApiException as e:
    print("Exception when calling SamlspApi->replaceSamlSp: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of SAML Service Provider that needs to be replaced
Required
Body parameters
Name Description
body

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists


updateSamlSp

Updates a SAML Service.


/api/v1/providers/saml/sp/{confKey}

Usage and SDK Samples

curl -X PATCH\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://manager-api.example.com/api/v1/providers/saml/sp/{confKey}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SamlspApi;

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

public class SamlspApiExample {

    public static void main(String[] args) {
        
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider that needs to be updated
        SamlSpUpdate body = ; // SamlSpUpdate | 
        try {
            apiInstance.updateSamlSp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#updateSamlSp");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SamlspApi;

public class SamlspApiExample {

    public static void main(String[] args) {
        SamlspApi apiInstance = new SamlspApi();
        confKey confKey = ; // confKey | Configuration key of SAML Service Provider that needs to be updated
        SamlSpUpdate body = ; // SamlSpUpdate | 
        try {
            apiInstance.updateSamlSp(confKey, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SamlspApi#updateSamlSp");
            e.printStackTrace();
        }
    }
}
confKey *confKey = ; // Configuration key of SAML Service Provider that needs to be updated
SamlSpUpdate *body = ; //  (optional)

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

// Updates a SAML Service.
[apiInstance updateSamlSpWith:confKey
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LemonLdapngManagerApi = require('lemon_ldapng_manager_api');

var api = new LemonLdapngManagerApi.SamlspApi()
var confKey = ; // {{confKey}} Configuration key of SAML Service Provider that needs to be updated
var opts = { 
  'body':  // {{SamlSpUpdate}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.updateSamlSp(confKey, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new SamlspApi();
            var confKey = new confKey(); // confKey | Configuration key of SAML Service Provider that needs to be updated
            var body = new SamlSpUpdate(); // SamlSpUpdate |  (optional) 

            try
            {
                // Updates a SAML Service.
                apiInstance.updateSamlSp(confKey, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SamlspApi.updateSamlSp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSamlspApi();
$confKey = ; // confKey | Configuration key of SAML Service Provider that needs to be updated
$body = ; // SamlSpUpdate | 

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

my $api_instance = WWW::SwaggerClient::SamlspApi->new();
my $confKey = ; # confKey | Configuration key of SAML Service Provider that needs to be updated
my $body = WWW::SwaggerClient::Object::SamlSpUpdate->new(); # SamlSpUpdate | 

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

# create an instance of the API class
api_instance = swagger_client.SamlspApi()
confKey =  # confKey | Configuration key of SAML Service Provider that needs to be updated
body =  # SamlSpUpdate |  (optional)

try: 
    # Updates a SAML Service.
    api_instance.update_saml_sp(confKey, body=body)
except ApiException as e:
    print("Exception when calling SamlspApi->updateSamlSp: %s\n" % e)

Parameters

Path parameters
Name Description
confKey*
confKey
Configuration key of SAML Service Provider that needs to be updated
Required
Body parameters
Name Description
body

Responses

Status: 204 - Successful modification

Status: 400 - An error was encountered when processing the request

Status: 404 - The specified resource was not found

Status: 409 - The specified object could not be created because its configuration key, client_id or entityID already exists