Linked Data API

Authority

authorityAssignmentCheck

Checks if authority can be assigned to work


/linked-data/authority-assignment-check

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/linked-data/authority-assignment-check" \
 -d ''

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

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

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

        // Create an instance of the API class
        AuthorityApi apiInstance = new AuthorityApi();
        AssignmentCheckDto assignmentCheckDto = ; // AssignmentCheckDto | 

        try {
            assignmentCheckResponseDto result = apiInstance.authorityAssignmentCheck(assignmentCheckDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorityApi#authorityAssignmentCheck");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AssignmentCheckDto assignmentCheckDto = new AssignmentCheckDto(); // AssignmentCheckDto | 

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


import org.openapitools.client.api.AuthorityApi;

public class AuthorityApiExample {
    public static void main(String[] args) {
        AuthorityApi apiInstance = new AuthorityApi();
        AssignmentCheckDto assignmentCheckDto = ; // AssignmentCheckDto | 

        try {
            assignmentCheckResponseDto result = apiInstance.authorityAssignmentCheck(assignmentCheckDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthorityApi#authorityAssignmentCheck");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
AuthorityApi *apiInstance = [[AuthorityApi alloc] init];
AssignmentCheckDto *assignmentCheckDto = ; //  (optional)

[apiInstance authorityAssignmentCheckWith:assignmentCheckDto
              completionHandler: ^(assignmentCheckResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.AuthorityApi()
var opts = {
  'assignmentCheckDto':  // {AssignmentCheckDto} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AuthorityApi();
            var assignmentCheckDto = new AssignmentCheckDto(); // AssignmentCheckDto |  (optional) 

            try {
                assignmentCheckResponseDto result = apiInstance.authorityAssignmentCheck(assignmentCheckDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthorityApi.authorityAssignmentCheck: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthorityApi();
$assignmentCheckDto = ; // AssignmentCheckDto | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthorityApi->new();
my $assignmentCheckDto = WWW::OPenAPIClient::Object::AssignmentCheckDto->new(); # AssignmentCheckDto | 

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

# Create an instance of the API class
api_instance = openapi_client.AuthorityApi()
assignmentCheckDto =  # AssignmentCheckDto |  (optional)

try:
    api_response = api_instance.authority_assignment_check(assignmentCheckDto=assignmentCheckDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthorityApi->authorityAssignmentCheck: %s\n" % e)
extern crate AuthorityApi;

pub fn main() {
    let assignmentCheckDto = ; // AssignmentCheckDto

    let mut context = AuthorityApi::Context::default();
    let result = client.authorityAssignmentCheck(assignmentCheckDto, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
assignmentCheckDto

Responses

Graph

getResourceGraphById

Get a resource graph by id


/linked-data/resource/{id}/graph

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/linked-data/resource/{id}/graph"

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

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

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

        // Create an instance of the API class
        GraphApi apiInstance = new GraphApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            resourceGraphDto result = apiInstance.getResourceGraphById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#getResourceGraphById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Linked Data resource id

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


import org.openapitools.client.api.GraphApi;

public class GraphApiExample {
    public static void main(String[] args) {
        GraphApi apiInstance = new GraphApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            resourceGraphDto result = apiInstance.getResourceGraphById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#getResourceGraphById");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GraphApi *apiInstance = [[GraphApi alloc] init];
Long *id = 789; // Linked Data resource id (default to null)

[apiInstance getResourceGraphByIdWith:id
              completionHandler: ^(resourceGraphDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.GraphApi()
var id = 789; // {Long} Linked Data resource id

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphApi();
            var id = 789;  // Long | Linked Data resource id (default to null)

            try {
                resourceGraphDto result = apiInstance.getResourceGraphById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphApi.getResourceGraphById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphApi();
$id = 789; // Long | Linked Data resource id

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphApi->new();
my $id = 789; # Long | Linked Data resource id

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

# Create an instance of the API class
api_instance = openapi_client.GraphApi()
id = 789 # Long | Linked Data resource id (default to null)

try:
    api_response = api_instance.get_resource_graph_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphApi->getResourceGraphById: %s\n" % e)
extern crate GraphApi;

pub fn main() {
    let id = 789; // Long

    let mut context = GraphApi::Context::default();
    let result = client.getResourceGraphById(id, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Linked Data resource id
Required

Responses

Import

importFile

Imports an uploaded JSON file containing at least one resource


/linked-data/import/file

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: multipart/form-data" \
 "http://localhost/linked-data/import/file"

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

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

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

        // Create an instance of the API class
        ImportApi apiInstance = new ImportApi();
        File fileName = BINARY_DATA_HERE; // File | 

        try {
            importFileResponseDto result = apiInstance.importFile(fileName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImportApi#importFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final File fileName = new File(); // File | 

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


import org.openapitools.client.api.ImportApi;

public class ImportApiExample {
    public static void main(String[] args) {
        ImportApi apiInstance = new ImportApi();
        File fileName = BINARY_DATA_HERE; // File | 

        try {
            importFileResponseDto result = apiInstance.importFile(fileName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImportApi#importFile");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ImportApi *apiInstance = [[ImportApi alloc] init];
File *fileName = BINARY_DATA_HERE; //  (optional) (default to null)

[apiInstance importFileWith:fileName
              completionHandler: ^(importFileResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ImportApi()
var opts = {
  'fileName': BINARY_DATA_HERE // {File} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ImportApi();
            var fileName = BINARY_DATA_HERE;  // File |  (optional)  (default to null)

            try {
                importFileResponseDto result = apiInstance.importFile(fileName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImportApi.importFile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ImportApi();
$fileName = BINARY_DATA_HERE; // File | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ImportApi->new();
my $fileName = BINARY_DATA_HERE; # File | 

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

# Create an instance of the API class
api_instance = openapi_client.ImportApi()
fileName = BINARY_DATA_HERE # File |  (optional) (default to null)

try:
    api_response = api_instance.import_file(fileName=fileName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImportApi->importFile: %s\n" % e)
extern crate ImportApi;

pub fn main() {
    let fileName = BINARY_DATA_HERE; // File

    let mut context = ImportApi::Context::default();
    let result = client.importFile(fileName, &context).wait();

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

Scopes

Parameters

Form parameters
Name Description
fileName
File (binary)

Responses

Profile

deletePreferredProfile

Delete preferred profile for current user


/linked-data/profile/preferred

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/linked-data/profile/preferred?resourceType=resourceType_example"

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

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

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

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();
        String resourceType = resourceType_example; // String | The type of resource for which preferred profile has to be deleted.

        try {
            apiInstance.deletePreferredProfile(resourceType);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#deletePreferredProfile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String resourceType = new String(); // String | The type of resource for which preferred profile has to be deleted.

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


import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        String resourceType = resourceType_example; // String | The type of resource for which preferred profile has to be deleted.

        try {
            apiInstance.deletePreferredProfile(resourceType);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#deletePreferredProfile");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];
String *resourceType = resourceType_example; // The type of resource for which preferred profile has to be deleted. (default to null)

[apiInstance deletePreferredProfileWith:resourceType
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ProfileApi()
var resourceType = resourceType_example; // {String} The type of resource for which preferred profile has to be deleted.

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProfileApi();
            var resourceType = resourceType_example;  // String | The type of resource for which preferred profile has to be deleted. (default to null)

            try {
                apiInstance.deletePreferredProfile(resourceType);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.deletePreferredProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();
$resourceType = resourceType_example; // String | The type of resource for which preferred profile has to be deleted.

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();
my $resourceType = resourceType_example; # String | The type of resource for which preferred profile has to be deleted.

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

# Create an instance of the API class
api_instance = openapi_client.ProfileApi()
resourceType = resourceType_example # String | The type of resource for which preferred profile has to be deleted. (default to null)

try:
    api_instance.delete_preferred_profile(resourceType)
except ApiException as e:
    print("Exception when calling ProfileApi->deletePreferredProfile: %s\n" % e)
extern crate ProfileApi;

pub fn main() {
    let resourceType = resourceType_example; // String

    let mut context = ProfileApi::Context::default();
    let result = client.deletePreferredProfile(resourceType, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
resourceType*
String
The type of resource for which preferred profile has to be deleted.
Required

Responses

getPreferredProfileByResourceType

Get the preferred profile for a resource type for the current user


/linked-data/profile/preferred

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/linked-data/profile/preferred?resourceType=resourceType_example"

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

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

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

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();
        String resourceType = resourceType_example; // String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned

        try {
            array[profileMetadata] result = apiInstance.getPreferredProfileByResourceType(resourceType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getPreferredProfileByResourceType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String resourceType = new String(); // String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned

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


import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        String resourceType = resourceType_example; // String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned

        try {
            array[profileMetadata] result = apiInstance.getPreferredProfileByResourceType(resourceType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getPreferredProfileByResourceType");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];
String *resourceType = resourceType_example; // The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned (optional) (default to null)

[apiInstance getPreferredProfileByResourceTypeWith:resourceType
              completionHandler: ^(array[profileMetadata] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ProfileApi()
var opts = {
  'resourceType': resourceType_example // {String} The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProfileApi();
            var resourceType = resourceType_example;  // String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned (optional)  (default to null)

            try {
                array[profileMetadata] result = apiInstance.getPreferredProfileByResourceType(resourceType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.getPreferredProfileByResourceType: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();
$resourceType = resourceType_example; // String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();
my $resourceType = resourceType_example; # String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned

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

# Create an instance of the API class
api_instance = openapi_client.ProfileApi()
resourceType = resourceType_example # String | The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned (optional) (default to null)

try:
    api_response = api_instance.get_preferred_profile_by_resource_type(resourceType=resourceType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->getPreferredProfileByResourceType: %s\n" % e)
extern crate ProfileApi;

pub fn main() {
    let resourceType = resourceType_example; // String

    let mut context = ProfileApi::Context::default();
    let result = client.getPreferredProfileByResourceType(resourceType, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
resourceType
String
The type of resource for which preferred profile is requested. If not specified, profiles for all resource types will be returned

Responses

getProfileById

Get a profile by profileId


/linked-data/profile/{profileId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: text/plain;charset=utf-8,application/json" \
 "http://localhost/linked-data/profile/{profileId}"

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

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

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

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();
        Integer profileId = 56; // Integer | ID of the profile

        try {
            'String' result = apiInstance.getProfileById(profileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfileById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer profileId = new Integer(); // Integer | ID of the profile

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


import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        Integer profileId = 56; // Integer | ID of the profile

        try {
            'String' result = apiInstance.getProfileById(profileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfileById");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];
Integer *profileId = 56; // ID of the profile (default to null)

[apiInstance getProfileByIdWith:profileId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ProfileApi()
var profileId = 56; // {Integer} ID of the profile

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProfileApi();
            var profileId = 56;  // Integer | ID of the profile (default to null)

            try {
                'String' result = apiInstance.getProfileById(profileId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.getProfileById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();
$profileId = 56; // Integer | ID of the profile

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();
my $profileId = 56; # Integer | ID of the profile

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

# Create an instance of the API class
api_instance = openapi_client.ProfileApi()
profileId = 56 # Integer | ID of the profile (default to null)

try:
    api_response = api_instance.get_profile_by_id(profileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->getProfileById: %s\n" % e)
extern crate ProfileApi;

pub fn main() {
    let profileId = 56; // Integer

    let mut context = ProfileApi::Context::default();
    let result = client.getProfileById(profileId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
profileId*
Integer (int16)
ID of the profile
Required

Responses

getProfileMetadataByResourceType

Get profiles metadata for a resource type


/linked-data/profile/metadata

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/linked-data/profile/metadata?resourceType=resourceType_example"

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

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

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

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();
        String resourceType = resourceType_example; // String | The type of resource for which metadata are requested

        try {
            array[profileMetadata] result = apiInstance.getProfileMetadataByResourceType(resourceType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfileMetadataByResourceType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String resourceType = new String(); // String | The type of resource for which metadata are requested

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


import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        String resourceType = resourceType_example; // String | The type of resource for which metadata are requested

        try {
            array[profileMetadata] result = apiInstance.getProfileMetadataByResourceType(resourceType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#getProfileMetadataByResourceType");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];
String *resourceType = resourceType_example; // The type of resource for which metadata are requested (default to null)

[apiInstance getProfileMetadataByResourceTypeWith:resourceType
              completionHandler: ^(array[profileMetadata] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ProfileApi()
var resourceType = resourceType_example; // {String} The type of resource for which metadata are requested

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProfileApi();
            var resourceType = resourceType_example;  // String | The type of resource for which metadata are requested (default to null)

            try {
                array[profileMetadata] result = apiInstance.getProfileMetadataByResourceType(resourceType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.getProfileMetadataByResourceType: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();
$resourceType = resourceType_example; // String | The type of resource for which metadata are requested

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();
my $resourceType = resourceType_example; # String | The type of resource for which metadata are requested

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

# Create an instance of the API class
api_instance = openapi_client.ProfileApi()
resourceType = resourceType_example # String | The type of resource for which metadata are requested (default to null)

try:
    api_response = api_instance.get_profile_metadata_by_resource_type(resourceType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->getProfileMetadataByResourceType: %s\n" % e)
extern crate ProfileApi;

pub fn main() {
    let resourceType = resourceType_example; // String

    let mut context = ProfileApi::Context::default();
    let result = client.getProfileMetadataByResourceType(resourceType, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
resourceType*
String
The type of resource for which metadata are requested
Required

Responses

setPreferredProfile

Create or update the preferred profile for a resource type for the current user


/linked-data/profile/preferred

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/linked-data/profile/preferred" \
 -d ''

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

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

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

        // Create an instance of the API class
        ProfileApi apiInstance = new ProfileApi();
        PreferredProfileRequest preferredProfileRequest = ; // PreferredProfileRequest | 

        try {
            apiInstance.setPreferredProfile(preferredProfileRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#setPreferredProfile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PreferredProfileRequest preferredProfileRequest = new PreferredProfileRequest(); // PreferredProfileRequest | 

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


import org.openapitools.client.api.ProfileApi;

public class ProfileApiExample {
    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        PreferredProfileRequest preferredProfileRequest = ; // PreferredProfileRequest | 

        try {
            apiInstance.setPreferredProfile(preferredProfileRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#setPreferredProfile");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProfileApi *apiInstance = [[ProfileApi alloc] init];
PreferredProfileRequest *preferredProfileRequest = ; //  (optional)

[apiInstance setPreferredProfileWith:preferredProfileRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ProfileApi()
var opts = {
  'preferredProfileRequest':  // {PreferredProfileRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProfileApi();
            var preferredProfileRequest = new PreferredProfileRequest(); // PreferredProfileRequest |  (optional) 

            try {
                apiInstance.setPreferredProfile(preferredProfileRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProfileApi.setPreferredProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProfileApi();
$preferredProfileRequest = ; // PreferredProfileRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProfileApi->new();
my $preferredProfileRequest = WWW::OPenAPIClient::Object::PreferredProfileRequest->new(); # PreferredProfileRequest | 

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

# Create an instance of the API class
api_instance = openapi_client.ProfileApi()
preferredProfileRequest =  # PreferredProfileRequest |  (optional)

try:
    api_instance.set_preferred_profile(preferredProfileRequest=preferredProfileRequest)
except ApiException as e:
    print("Exception when calling ProfileApi->setPreferredProfile: %s\n" % e)
extern crate ProfileApi;

pub fn main() {
    let preferredProfileRequest = ; // PreferredProfileRequest

    let mut context = ProfileApi::Context::default();
    let result = client.setPreferredProfile(preferredProfileRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
preferredProfileRequest

Responses

Reindex

reindex

Start the process of reindexing of resources in the database


/linked-data/reindex

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost/linked-data/reindex?full=true"

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

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

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

        // Create an instance of the API class
        ReindexApi apiInstance = new ReindexApi();
        Boolean full = true; // Boolean | Reindex all records if true, otherwise only not indexed

        try {
            apiInstance.reindex(full);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReindexApi#reindex");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Boolean full = new Boolean(); // Boolean | Reindex all records if true, otherwise only not indexed

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


import org.openapitools.client.api.ReindexApi;

public class ReindexApiExample {
    public static void main(String[] args) {
        ReindexApi apiInstance = new ReindexApi();
        Boolean full = true; // Boolean | Reindex all records if true, otherwise only not indexed

        try {
            apiInstance.reindex(full);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReindexApi#reindex");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ReindexApi *apiInstance = [[ReindexApi alloc] init];
Boolean *full = true; // Reindex all records if true, otherwise only not indexed (optional) (default to null)

[apiInstance reindexWith:full
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ReindexApi()
var opts = {
  'full': true // {Boolean} Reindex all records if true, otherwise only not indexed
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ReindexApi();
            var full = true;  // Boolean | Reindex all records if true, otherwise only not indexed (optional)  (default to null)

            try {
                apiInstance.reindex(full);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReindexApi.reindex: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReindexApi();
$full = true; // Boolean | Reindex all records if true, otherwise only not indexed

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReindexApi->new();
my $full = true; # Boolean | Reindex all records if true, otherwise only not indexed

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

# Create an instance of the API class
api_instance = openapi_client.ReindexApi()
full = true # Boolean | Reindex all records if true, otherwise only not indexed (optional) (default to null)

try:
    api_instance.reindex(full=full)
except ApiException as e:
    print("Exception when calling ReindexApi->reindex: %s\n" % e)
extern crate ReindexApi;

pub fn main() {
    let full = true; // Boolean

    let mut context = ReindexApi::Context::default();
    let result = client.reindex(full, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
full
Boolean
Reindex all records if true, otherwise only not indexed

Responses

Resource

checkMarcBibImportableToGraph

Check if marc bibliographic record can be imported into linked data graph.


/linked-data/inventory-instance/{inventoryId}/import-supported

Usage and SDK Samples

curl -X GET \
 -H "Accept: text/plain,application/json" \
 "http://localhost/linked-data/inventory-instance/{inventoryId}/import-supported"

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

        try {
            'String' result = apiInstance.checkMarcBibImportableToGraph(inventoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#checkMarcBibImportableToGraph");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inventoryId = new String(); // String | Inventory ID (999 $i) of the MARC record in SRS

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


import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

        try {
            'String' result = apiInstance.checkMarcBibImportableToGraph(inventoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#checkMarcBibImportableToGraph");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
String *inventoryId = inventoryId_example; // Inventory ID (999 $i) of the MARC record in SRS (default to null)

[apiInstance checkMarcBibImportableToGraphWith:inventoryId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var inventoryId = inventoryId_example; // {String} Inventory ID (999 $i) of the MARC record in SRS

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var inventoryId = inventoryId_example;  // String | Inventory ID (999 $i) of the MARC record in SRS (default to null)

            try {
                'String' result = apiInstance.checkMarcBibImportableToGraph(inventoryId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.checkMarcBibImportableToGraph: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $inventoryId = inventoryId_example; # String | Inventory ID (999 $i) of the MARC record in SRS

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

# Create an instance of the API class
api_instance = openapi_client.ResourceApi()
inventoryId = inventoryId_example # String | Inventory ID (999 $i) of the MARC record in SRS (default to null)

try:
    api_response = api_instance.check_marc_bib_importable_to_graph(inventoryId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->checkMarcBibImportableToGraph: %s\n" % e)
extern crate ResourceApi;

pub fn main() {
    let inventoryId = inventoryId_example; // String

    let mut context = ResourceApi::Context::default();
    let result = client.checkMarcBibImportableToGraph(inventoryId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inventoryId*
String
Inventory ID (999 $i) of the MARC record in SRS
Required

Responses

createResource

Create a Resource


/linked-data/resource

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/linked-data/resource" \
 -d ''

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        ResourceRequestDto resourceRequestDto = ; // ResourceRequestDto | 

        try {
            resourceResponseDto result = apiInstance.createResource(resourceRequestDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#createResource");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ResourceRequestDto resourceRequestDto = new ResourceRequestDto(); // ResourceRequestDto | 

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


import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        ResourceRequestDto resourceRequestDto = ; // ResourceRequestDto | 

        try {
            resourceResponseDto result = apiInstance.createResource(resourceRequestDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#createResource");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
ResourceRequestDto *resourceRequestDto = ; //  (optional)

[apiInstance createResourceWith:resourceRequestDto
              completionHandler: ^(resourceResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var opts = {
  'resourceRequestDto':  // {ResourceRequestDto} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var resourceRequestDto = new ResourceRequestDto(); // ResourceRequestDto |  (optional) 

            try {
                resourceResponseDto result = apiInstance.createResource(resourceRequestDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.createResource: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$resourceRequestDto = ; // ResourceRequestDto | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $resourceRequestDto = WWW::OPenAPIClient::Object::ResourceRequestDto->new(); # ResourceRequestDto | 

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

# Create an instance of the API class
api_instance = openapi_client.ResourceApi()
resourceRequestDto =  # ResourceRequestDto |  (optional)

try:
    api_response = api_instance.create_resource(resourceRequestDto=resourceRequestDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->createResource: %s\n" % e)
extern crate ResourceApi;

pub fn main() {
    let resourceRequestDto = ; // ResourceRequestDto

    let mut context = ResourceApi::Context::default();
    let result = client.createResource(resourceRequestDto, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
resourceRequestDto

Responses

deleteResource

Delete a resource by id


/linked-data/resource/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/linked-data/resource/{id}"

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            apiInstance.deleteResource(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#deleteResource");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Linked Data resource id

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


import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            apiInstance.deleteResource(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#deleteResource");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
Long *id = 789; // Linked Data resource id (default to null)

[apiInstance deleteResourceWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var id = 789; // {Long} Linked Data resource id

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var id = 789;  // Long | Linked Data resource id (default to null)

            try {
                apiInstance.deleteResource(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.deleteResource: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$id = 789; // Long | Linked Data resource id

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $id = 789; # Long | Linked Data resource id

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

# Create an instance of the API class
api_instance = openapi_client.ResourceApi()
id = 789 # Long | Linked Data resource id (default to null)

try:
    api_instance.delete_resource(id)
except ApiException as e:
    print("Exception when calling ResourceApi->deleteResource: %s\n" % e)
extern crate ResourceApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ResourceApi::Context::default();
    let result = client.deleteResource(id, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Linked Data resource id
Required

Responses

exportInstanceToRdf

Export Instance resource to RDF by id


/linked-data/resource/{id}/rdf

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/linked-data/resource/{id}/rdf"

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            'String' result = apiInstance.exportInstanceToRdf(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#exportInstanceToRdf");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Linked Data resource id

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


import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            'String' result = apiInstance.exportInstanceToRdf(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#exportInstanceToRdf");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
Long *id = 789; // Linked Data resource id (default to null)

[apiInstance exportInstanceToRdfWith:id
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var id = 789; // {Long} Linked Data resource id

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var id = 789;  // Long | Linked Data resource id (default to null)

            try {
                'String' result = apiInstance.exportInstanceToRdf(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.exportInstanceToRdf: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$id = 789; // Long | Linked Data resource id

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $id = 789; # Long | Linked Data resource id

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

# Create an instance of the API class
api_instance = openapi_client.ResourceApi()
id = 789 # Long | Linked Data resource id (default to null)

try:
    api_response = api_instance.export_instance_to_rdf(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->exportInstanceToRdf: %s\n" % e)
extern crate ResourceApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ResourceApi::Context::default();
    let result = client.exportInstanceToRdf(id, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Linked Data resource id
Required

Responses

getResourceById

Get a resource by id


/linked-data/resource/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/linked-data/resource/{id}"

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            resourceResponseDto result = apiInstance.getResourceById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourceById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Linked Data resource id

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


import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            resourceResponseDto result = apiInstance.getResourceById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourceById");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
Long *id = 789; // Linked Data resource id (default to null)

[apiInstance getResourceByIdWith:id
              completionHandler: ^(resourceResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var id = 789; // {Long} Linked Data resource id

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var id = 789;  // Long | Linked Data resource id (default to null)

            try {
                resourceResponseDto result = apiInstance.getResourceById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.getResourceById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$id = 789; // Long | Linked Data resource id

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $id = 789; # Long | Linked Data resource id

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

# Create an instance of the API class
api_instance = openapi_client.ResourceApi()
id = 789 # Long | Linked Data resource id (default to null)

try:
    api_response = api_instance.get_resource_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->getResourceById: %s\n" % e)
extern crate ResourceApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ResourceApi::Context::default();
    let result = client.getResourceById(id, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Linked Data resource id
Required

Responses

getResourceIdByResourceInventoryId

Get id of a resource by its inventory id


/linked-data/resource/metadata/{inventoryId}/id

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/linked-data/resource/metadata/{inventoryId}/id"

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

        try {
            resourceIdDto result = apiInstance.getResourceIdByResourceInventoryId(inventoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourceIdByResourceInventoryId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inventoryId = new String(); // String | Inventory ID (999 $i) of the MARC record in SRS

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


import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

        try {
            resourceIdDto result = apiInstance.getResourceIdByResourceInventoryId(inventoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourceIdByResourceInventoryId");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
String *inventoryId = inventoryId_example; // Inventory ID (999 $i) of the MARC record in SRS (default to null)

[apiInstance getResourceIdByResourceInventoryIdWith:inventoryId
              completionHandler: ^(resourceIdDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var inventoryId = inventoryId_example; // {String} Inventory ID (999 $i) of the MARC record in SRS

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var inventoryId = inventoryId_example;  // String | Inventory ID (999 $i) of the MARC record in SRS (default to null)

            try {
                resourceIdDto result = apiInstance.getResourceIdByResourceInventoryId(inventoryId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.getResourceIdByResourceInventoryId: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $inventoryId = inventoryId_example; # String | Inventory ID (999 $i) of the MARC record in SRS

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

# Create an instance of the API class
api_instance = openapi_client.ResourceApi()
inventoryId = inventoryId_example # String | Inventory ID (999 $i) of the MARC record in SRS (default to null)

try:
    api_response = api_instance.get_resource_id_by_resource_inventory_id(inventoryId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->getResourceIdByResourceInventoryId: %s\n" % e)
extern crate ResourceApi;

pub fn main() {
    let inventoryId = inventoryId_example; // String

    let mut context = ResourceApi::Context::default();
    let result = client.getResourceIdByResourceInventoryId(inventoryId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inventoryId*
String
Inventory ID (999 $i) of the MARC record in SRS
Required

Responses

getResourceMarcViewById

Get a marc view of resource by id


/linked-data/resource/{id}/marc

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/linked-data/resource/{id}/marc"

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            resourceMarcViewDto result = apiInstance.getResourceMarcViewById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourceMarcViewById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Linked Data resource id

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


import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id

        try {
            resourceMarcViewDto result = apiInstance.getResourceMarcViewById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourceMarcViewById");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
Long *id = 789; // Linked Data resource id (default to null)

[apiInstance getResourceMarcViewByIdWith:id
              completionHandler: ^(resourceMarcViewDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var id = 789; // {Long} Linked Data resource id

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var id = 789;  // Long | Linked Data resource id (default to null)

            try {
                resourceMarcViewDto result = apiInstance.getResourceMarcViewById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.getResourceMarcViewById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$id = 789; // Long | Linked Data resource id

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $id = 789; # Long | Linked Data resource id

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

# Create an instance of the API class
api_instance = openapi_client.ResourceApi()
id = 789 # Long | Linked Data resource id (default to null)

try:
    api_response = api_instance.get_resource_marc_view_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->getResourceMarcViewById: %s\n" % e)
extern crate ResourceApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ResourceApi::Context::default();
    let result = client.getResourceMarcViewById(id, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Linked Data resource id
Required

Responses

getResourcePreviewByInventoryId

Get the preview of a resource


/linked-data/inventory-instance/{inventoryId}/preview

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/linked-data/inventory-instance/{inventoryId}/preview"

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

        try {
            resourceResponseDto result = apiInstance.getResourcePreviewByInventoryId(inventoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourcePreviewByInventoryId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inventoryId = new String(); // String | Inventory ID (999 $i) of the MARC record in SRS

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


import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

        try {
            resourceResponseDto result = apiInstance.getResourcePreviewByInventoryId(inventoryId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#getResourcePreviewByInventoryId");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
String *inventoryId = inventoryId_example; // Inventory ID (999 $i) of the MARC record in SRS (default to null)

[apiInstance getResourcePreviewByInventoryIdWith:inventoryId
              completionHandler: ^(resourceResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var inventoryId = inventoryId_example; // {String} Inventory ID (999 $i) of the MARC record in SRS

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var inventoryId = inventoryId_example;  // String | Inventory ID (999 $i) of the MARC record in SRS (default to null)

            try {
                resourceResponseDto result = apiInstance.getResourcePreviewByInventoryId(inventoryId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.getResourcePreviewByInventoryId: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $inventoryId = inventoryId_example; # String | Inventory ID (999 $i) of the MARC record in SRS

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

# Create an instance of the API class
api_instance = openapi_client.ResourceApi()
inventoryId = inventoryId_example # String | Inventory ID (999 $i) of the MARC record in SRS (default to null)

try:
    api_response = api_instance.get_resource_preview_by_inventory_id(inventoryId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->getResourcePreviewByInventoryId: %s\n" % e)
extern crate ResourceApi;

pub fn main() {
    let inventoryId = inventoryId_example; // String

    let mut context = ResourceApi::Context::default();
    let result = client.getResourcePreviewByInventoryId(inventoryId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inventoryId*
String
Inventory ID (999 $i) of the MARC record in SRS
Required

Responses

importMarcRecord

Create a Resource derived from MARC record


/linked-data/inventory-instance/{inventoryId}/import

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost/linked-data/inventory-instance/{inventoryId}/import?profileId=56"

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS
        Integer profileId = 56; // Integer | ID of the profile

        try {
            resourceIdDto result = apiInstance.importMarcRecord(inventoryId, profileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#importMarcRecord");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String inventoryId = new String(); // String | Inventory ID (999 $i) of the MARC record in SRS
final Integer profileId = new Integer(); // Integer | ID of the profile

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


import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        String inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS
        Integer profileId = 56; // Integer | ID of the profile

        try {
            resourceIdDto result = apiInstance.importMarcRecord(inventoryId, profileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#importMarcRecord");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
String *inventoryId = inventoryId_example; // Inventory ID (999 $i) of the MARC record in SRS (default to null)
Integer *profileId = 56; // ID of the profile (optional) (default to null)

[apiInstance importMarcRecordWith:inventoryId
    profileId:profileId
              completionHandler: ^(resourceIdDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var inventoryId = inventoryId_example; // {String} Inventory ID (999 $i) of the MARC record in SRS
var opts = {
  'profileId': 56 // {Integer} ID of the profile
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var inventoryId = inventoryId_example;  // String | Inventory ID (999 $i) of the MARC record in SRS (default to null)
            var profileId = 56;  // Integer | ID of the profile (optional)  (default to null)

            try {
                resourceIdDto result = apiInstance.importMarcRecord(inventoryId, profileId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.importMarcRecord: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$inventoryId = inventoryId_example; // String | Inventory ID (999 $i) of the MARC record in SRS
$profileId = 56; // Integer | ID of the profile

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $inventoryId = inventoryId_example; # String | Inventory ID (999 $i) of the MARC record in SRS
my $profileId = 56; # Integer | ID of the profile

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

# Create an instance of the API class
api_instance = openapi_client.ResourceApi()
inventoryId = inventoryId_example # String | Inventory ID (999 $i) of the MARC record in SRS (default to null)
profileId = 56 # Integer | ID of the profile (optional) (default to null)

try:
    api_response = api_instance.import_marc_record(inventoryId, profileId=profileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->importMarcRecord: %s\n" % e)
extern crate ResourceApi;

pub fn main() {
    let inventoryId = inventoryId_example; // String
    let profileId = 56; // Integer

    let mut context = ResourceApi::Context::default();
    let result = client.importMarcRecord(inventoryId, profileId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
inventoryId*
String
Inventory ID (999 $i) of the MARC record in SRS
Required
Query parameters
Name Description
profileId
Integer (int16)
ID of the profile

Responses

updateResource

Update a resource by id


/linked-data/resource/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/linked-data/resource/{id}" \
 -d ''

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

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

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

        // Create an instance of the API class
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id
        ResourceRequestDto resourceRequestDto = example/resourceRequest.sample; // ResourceRequestDto | 

        try {
            resourceResponseDto result = apiInstance.updateResource(id, resourceRequestDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#updateResource");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Linked Data resource id
final ResourceRequestDto resourceRequestDto = new ResourceRequestDto(); // ResourceRequestDto | 

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


import org.openapitools.client.api.ResourceApi;

public class ResourceApiExample {
    public static void main(String[] args) {
        ResourceApi apiInstance = new ResourceApi();
        Long id = 789; // Long | Linked Data resource id
        ResourceRequestDto resourceRequestDto = example/resourceRequest.sample; // ResourceRequestDto | 

        try {
            resourceResponseDto result = apiInstance.updateResource(id, resourceRequestDto);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResourceApi#updateResource");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ResourceApi *apiInstance = [[ResourceApi alloc] init];
Long *id = 789; // Linked Data resource id (default to null)
ResourceRequestDto *resourceRequestDto = example/resourceRequest.sample; //  (optional)

[apiInstance updateResourceWith:id
    resourceRequestDto:resourceRequestDto
              completionHandler: ^(resourceResponseDto output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var LinkedDataApi = require('linked_data_api');

// Create an instance of the API class
var api = new LinkedDataApi.ResourceApi()
var id = 789; // {Long} Linked Data resource id
var opts = {
  'resourceRequestDto': example/resourceRequest.sample // {ResourceRequestDto} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ResourceApi();
            var id = 789;  // Long | Linked Data resource id (default to null)
            var resourceRequestDto = new ResourceRequestDto(); // ResourceRequestDto |  (optional) 

            try {
                resourceResponseDto result = apiInstance.updateResource(id, resourceRequestDto);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResourceApi.updateResource: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResourceApi();
$id = 789; // Long | Linked Data resource id
$resourceRequestDto = example/resourceRequest.sample; // ResourceRequestDto | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResourceApi->new();
my $id = 789; # Long | Linked Data resource id
my $resourceRequestDto = WWW::OPenAPIClient::Object::ResourceRequestDto->new(); # ResourceRequestDto | 

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

# Create an instance of the API class
api_instance = openapi_client.ResourceApi()
id = 789 # Long | Linked Data resource id (default to null)
resourceRequestDto = example/resourceRequest.sample # ResourceRequestDto |  (optional)

try:
    api_response = api_instance.update_resource(id, resourceRequestDto=resourceRequestDto)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResourceApi->updateResource: %s\n" % e)
extern crate ResourceApi;

pub fn main() {
    let id = 789; // Long
    let resourceRequestDto = example/resourceRequest.sample; // ResourceRequestDto

    let mut context = ResourceApi::Context::default();
    let result = client.updateResource(id, resourceRequestDto, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Linked Data resource id
Required
Body parameters
Name Description
resourceRequestDto

Responses