MetExplore 3 REST api

Analyses

addAnalyses

add Analysis

add an Analysis with data in the body of the request as json (name, description and url)


/analyses

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/analyses" \
 -d '{
  "editionDate" : "2023-06-29 13:26:00",
  "name" : "My mapping",
  "description" : "mapping of metabolites on mouse biosource",
  "id" : 1,
  "creationDate" : "2023-06-29 13:26:00",
  "url" : "http://localhost:3000/mapping/metabolites/23"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AnalysesApi;

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

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

        // Create an instance of the API class
        AnalysesApi apiInstance = new AnalysesApi();
        Analysis analysis = ; // Analysis | 

        try {
            AnalysesResponse result = apiInstance.addAnalyses(analysis);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalysesApi#addAnalyses");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AnalysesApi;

public class AnalysesApiExample {
    public static void main(String[] args) {
        AnalysesApi apiInstance = new AnalysesApi();
        Analysis analysis = ; // Analysis | 

        try {
            AnalysesResponse result = apiInstance.addAnalyses(analysis);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalysesApi#addAnalyses");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
AnalysesApi *apiInstance = [[AnalysesApi alloc] init];
Analysis *analysis = ; //  (optional)

// add Analysis
[apiInstance addAnalysesWith:analysis
              completionHandler: ^(AnalysesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.AnalysesApi()
var opts = {
  'analysis':  // {Analysis} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new AnalysesApi();
            var analysis = new Analysis(); // Analysis |  (optional) 

            try {
                // add Analysis
                AnalysesResponse result = apiInstance.addAnalyses(analysis);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AnalysesApi.addAnalyses: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AnalysesApi();
$analysis = ; // Analysis | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AnalysesApi->new();
my $analysis = WWW::OPenAPIClient::Object::Analysis->new(); # Analysis | 

eval {
    my $result = $api_instance->addAnalyses(analysis => $analysis);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnalysesApi->addAnalyses: $@\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.AnalysesApi()
analysis =  # Analysis |  (optional)

try:
    # add Analysis
    api_response = api_instance.add_analyses(analysis=analysis)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnalysesApi->addAnalyses: %s\n" % e)
extern crate AnalysesApi;

pub fn main() {
    let analysis = ; // Analysis

    let mut context = AnalysesApi::Context::default();
    let result = client.addAnalyses(analysis, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
analysis

Responses


delAnalyses

delete Analysis

delete the Analysis with its id


/analyses

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/analyses?id=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AnalysesApi;

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

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

        // Create an instance of the API class
        AnalysesApi apiInstance = new AnalysesApi();
        Integer id = 56; // Integer | the id for the Analysis

        try {
            AnalysesResponse result = apiInstance.delAnalyses(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalysesApi#delAnalyses");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AnalysesApi;

public class AnalysesApiExample {
    public static void main(String[] args) {
        AnalysesApi apiInstance = new AnalysesApi();
        Integer id = 56; // Integer | the id for the Analysis

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


// Create an instance of the API class
AnalysesApi *apiInstance = [[AnalysesApi alloc] init];
Integer *id = 56; // the id for the Analysis (default to null)

// delete Analysis
[apiInstance delAnalysesWith:id
              completionHandler: ^(AnalysesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.AnalysesApi()
var id = 56; // {Integer} the id for the Analysis

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

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

            // Create an instance of the API class
            var apiInstance = new AnalysesApi();
            var id = 56;  // Integer | the id for the Analysis (default to null)

            try {
                // delete Analysis
                AnalysesResponse result = apiInstance.delAnalyses(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AnalysesApi.delAnalyses: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AnalysesApi();
$id = 56; // Integer | the id for the Analysis

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AnalysesApi->new();
my $id = 56; # Integer | the id for the Analysis

eval {
    my $result = $api_instance->delAnalyses(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnalysesApi->delAnalyses: $@\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.AnalysesApi()
id = 56 # Integer | the id for the Analysis (default to null)

try:
    # delete Analysis
    api_response = api_instance.del_analyses(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnalysesApi->delAnalyses: %s\n" % e)
extern crate AnalysesApi;

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

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

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

Scopes

Parameters

Query parameters
Name Description
id*
Integer
the id for the Analysis
Required

Responses


getAnalyses

get Analysis

get data from Analysis : if no id specified, all the analysis ; else only the one with corresponding id


/analyses

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/analyses?id=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AnalysesApi;

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

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

        // Create an instance of the API class
        AnalysesApi apiInstance = new AnalysesApi();
        Integer id = 56; // Integer | id of the analysis

        try {
            AnalysesResponse result = apiInstance.getAnalyses(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalysesApi#getAnalyses");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AnalysesApi;

public class AnalysesApiExample {
    public static void main(String[] args) {
        AnalysesApi apiInstance = new AnalysesApi();
        Integer id = 56; // Integer | id of the analysis

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


// Create an instance of the API class
AnalysesApi *apiInstance = [[AnalysesApi alloc] init];
Integer *id = 56; // id of the analysis (optional) (default to null)

// get Analysis
[apiInstance getAnalysesWith:id
              completionHandler: ^(AnalysesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.AnalysesApi()
var opts = {
  'id': 56 // {Integer} id of the analysis
};

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

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

            // Create an instance of the API class
            var apiInstance = new AnalysesApi();
            var id = 56;  // Integer | id of the analysis (optional)  (default to null)

            try {
                // get Analysis
                AnalysesResponse result = apiInstance.getAnalyses(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AnalysesApi.getAnalyses: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AnalysesApi();
$id = 56; // Integer | id of the analysis

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AnalysesApi->new();
my $id = 56; # Integer | id of the analysis

eval {
    my $result = $api_instance->getAnalyses(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnalysesApi->getAnalyses: $@\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.AnalysesApi()
id = 56 # Integer | id of the analysis (optional) (default to null)

try:
    # get Analysis
    api_response = api_instance.get_analyses(id=id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnalysesApi->getAnalyses: %s\n" % e)
extern crate AnalysesApi;

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

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

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

Scopes

Parameters

Query parameters
Name Description
id
Integer
id of the analysis

Responses


updateAnalysis

update Analysis

update one Analysis with its id, the data to modify is passed in the body of the request in json format (name, description, url)


/analyses

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/analyses" \
 -d '{
  "editionDate" : "2023-06-29 13:26:00",
  "name" : "My mapping",
  "description" : "mapping of metabolites on mouse biosource",
  "id" : 1,
  "creationDate" : "2023-06-29 13:26:00",
  "url" : "http://localhost:3000/mapping/metabolites/23"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AnalysesApi;

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

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

        // Create an instance of the API class
        AnalysesApi apiInstance = new AnalysesApi();
        Analysis analysis = ; // Analysis | 

        try {
            AnalysesResponse result = apiInstance.updateAnalysis(analysis);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalysesApi#updateAnalysis");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.AnalysesApi;

public class AnalysesApiExample {
    public static void main(String[] args) {
        AnalysesApi apiInstance = new AnalysesApi();
        Analysis analysis = ; // Analysis | 

        try {
            AnalysesResponse result = apiInstance.updateAnalysis(analysis);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AnalysesApi#updateAnalysis");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
AnalysesApi *apiInstance = [[AnalysesApi alloc] init];
Analysis *analysis = ; //  (optional)

// update Analysis
[apiInstance updateAnalysisWith:analysis
              completionHandler: ^(AnalysesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.AnalysesApi()
var opts = {
  'analysis':  // {Analysis} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new AnalysesApi();
            var analysis = new Analysis(); // Analysis |  (optional) 

            try {
                // update Analysis
                AnalysesResponse result = apiInstance.updateAnalysis(analysis);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AnalysesApi.updateAnalysis: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AnalysesApi();
$analysis = ; // Analysis | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AnalysesApi->new();
my $analysis = WWW::OPenAPIClient::Object::Analysis->new(); # Analysis | 

eval {
    my $result = $api_instance->updateAnalysis(analysis => $analysis);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AnalysesApi->updateAnalysis: $@\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.AnalysesApi()
analysis =  # Analysis |  (optional)

try:
    # update Analysis
    api_response = api_instance.update_analysis(analysis=analysis)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AnalysesApi->updateAnalysis: %s\n" % e)
extern crate AnalysesApi;

pub fn main() {
    let analysis = ; // Analysis

    let mut context = AnalysesApi::Context::default();
    let result = client.updateAnalysis(analysis, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
analysis

Responses


ApiApps

addApp

add an app and generate a token

add an app and generate a token


/apiapps

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/apiapps" \
 -d '{
  "institution" : "inrae",
  "name" : "MetExplore",
  "id" : 2,
  "lab" : "toxalim",
  "desc" : "awesome tool for metabolic network analysis",
  "token" : "123HY"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ApiAppsApi;

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

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

        // Create an instance of the API class
        ApiAppsApi apiInstance = new ApiAppsApi();
        array[ApiApp] apiApp = ; // array[ApiApp] | 

        try {
            ApiAppResponse result = apiInstance.addApp(apiApp);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiAppsApi#addApp");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ApiAppsApi;

public class ApiAppsApiExample {
    public static void main(String[] args) {
        ApiAppsApi apiInstance = new ApiAppsApi();
        array[ApiApp] apiApp = ; // array[ApiApp] | 

        try {
            ApiAppResponse result = apiInstance.addApp(apiApp);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiAppsApi#addApp");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ApiAppsApi *apiInstance = [[ApiAppsApi alloc] init];
array[ApiApp] *apiApp = ; //  (optional)

// add an app and generate a token
[apiInstance addAppWith:apiApp
              completionHandler: ^(ApiAppResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.ApiAppsApi()
var opts = {
  'apiApp':  // {array[ApiApp]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new ApiAppsApi();
            var apiApp = new array[ApiApp](); // array[ApiApp] |  (optional) 

            try {
                // add an app and generate a token
                ApiAppResponse result = apiInstance.addApp(apiApp);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiAppsApi.addApp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApiAppsApi();
$apiApp = ; // array[ApiApp] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApiAppsApi->new();
my $apiApp = [WWW::OPenAPIClient::Object::array[ApiApp]->new()]; # array[ApiApp] | 

eval {
    my $result = $api_instance->addApp(apiApp => $apiApp);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiAppsApi->addApp: $@\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.ApiAppsApi()
apiApp =  # array[ApiApp] |  (optional)

try:
    # add an app and generate a token
    api_response = api_instance.add_app(apiApp=apiApp)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiAppsApi->addApp: %s\n" % e)
extern crate ApiAppsApi;

pub fn main() {
    let apiApp = ; // array[ApiApp]

    let mut context = ApiAppsApi::Context::default();
    let result = client.addApp(apiApp, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
apiApp

Responses


Biosources

getBioSources

Get all biosources

get all biosources


/biosources

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/biosources"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.BiosourcesApi;

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

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

        // Create an instance of the API class
        BiosourcesApi apiInstance = new BiosourcesApi();

        try {
            BioSourcesResponse result = apiInstance.getBioSources();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BiosourcesApi#getBioSources");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.BiosourcesApi;

public class BiosourcesApiExample {
    public static void main(String[] args) {
        BiosourcesApi apiInstance = new BiosourcesApi();

        try {
            BioSourcesResponse result = apiInstance.getBioSources();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BiosourcesApi#getBioSources");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
BiosourcesApi *apiInstance = [[BiosourcesApi alloc] init];

// Get all biosources
[apiInstance getBioSourcesWithCompletionHandler: 
              ^(BioSourcesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.BiosourcesApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBioSources(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new BiosourcesApi();

            try {
                // Get all biosources
                BioSourcesResponse result = apiInstance.getBioSources();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BiosourcesApi.getBioSources: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BiosourcesApi();

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BiosourcesApi->new();

eval {
    my $result = $api_instance->getBioSources();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BiosourcesApi->getBioSources: $@\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.BiosourcesApi()

try:
    # Get all biosources
    api_response = api_instance.get_bio_sources()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BiosourcesApi->getBioSources: %s\n" % e)
extern crate BiosourcesApi;

pub fn main() {

    let mut context = BiosourcesApi::Context::default();
    let result = client.getBioSources(&context).wait();

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

Scopes

Parameters

Responses


Default

root

Root of metexplore3-api

Root of metexplore3-api


/

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            BaseResponse result = apiInstance.root();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#root");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            BaseResponse result = apiInstance.root();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#root");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Root of metexplore3-api
[apiInstance rootWithCompletionHandler: 
              ^(BaseResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.root(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // Root of metexplore3-api
                BaseResponse result = apiInstance.root();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.root: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    my $result = $api_instance->root();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->root: $@\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.DefaultApi()

try:
    # Root of metexplore3-api
    api_response = api_instance.root()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->root: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.root(&context).wait();

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

Scopes

Parameters

Responses


Enzymes

addEnzymes

add Enzyme

add for Enzyme


/enzymes

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/enzymes" \
 -d 'null'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.EnzymesApi;

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

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

        // Create an instance of the API class
        EnzymesApi apiInstance = new EnzymesApi();
        array[EnzymesResponse] enzymesResponse = ; // array[EnzymesResponse] | 

        try {
            EnzymesResponse result = apiInstance.addEnzymes(enzymesResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnzymesApi#addEnzymes");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.EnzymesApi;

public class EnzymesApiExample {
    public static void main(String[] args) {
        EnzymesApi apiInstance = new EnzymesApi();
        array[EnzymesResponse] enzymesResponse = ; // array[EnzymesResponse] | 

        try {
            EnzymesResponse result = apiInstance.addEnzymes(enzymesResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnzymesApi#addEnzymes");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
EnzymesApi *apiInstance = [[EnzymesApi alloc] init];
array[EnzymesResponse] *enzymesResponse = ; //  (optional)

// add Enzyme
[apiInstance addEnzymesWith:enzymesResponse
              completionHandler: ^(EnzymesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.EnzymesApi()
var opts = {
  'enzymesResponse':  // {array[EnzymesResponse]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new EnzymesApi();
            var enzymesResponse = new array[EnzymesResponse](); // array[EnzymesResponse] |  (optional) 

            try {
                // add Enzyme
                EnzymesResponse result = apiInstance.addEnzymes(enzymesResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EnzymesApi.addEnzymes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EnzymesApi();
$enzymesResponse = ; // array[EnzymesResponse] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EnzymesApi->new();
my $enzymesResponse = [WWW::OPenAPIClient::Object::array[EnzymesResponse]->new()]; # array[EnzymesResponse] | 

eval {
    my $result = $api_instance->addEnzymes(enzymesResponse => $enzymesResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnzymesApi->addEnzymes: $@\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.EnzymesApi()
enzymesResponse =  # array[EnzymesResponse] |  (optional)

try:
    # add Enzyme
    api_response = api_instance.add_enzymes(enzymesResponse=enzymesResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnzymesApi->addEnzymes: %s\n" % e)
extern crate EnzymesApi;

pub fn main() {
    let enzymesResponse = ; // array[EnzymesResponse]

    let mut context = EnzymesApi::Context::default();
    let result = client.addEnzymes(enzymesResponse, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
enzymesResponse

Responses


countEnzymes

count ligns Enzyme

get the number of enzymes for one biosource


/enzymes/count

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/enzymes/count?idBioSource=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.EnzymesApi;

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

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

        // Create an instance of the API class
        EnzymesApi apiInstance = new EnzymesApi();
        Integer idBioSource = 56; // Integer | the idBioSource for the Enzyme

        try {
            CountResponse result = apiInstance.countEnzymes(idBioSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnzymesApi#countEnzymes");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.EnzymesApi;

public class EnzymesApiExample {
    public static void main(String[] args) {
        EnzymesApi apiInstance = new EnzymesApi();
        Integer idBioSource = 56; // Integer | the idBioSource for the Enzyme

        try {
            CountResponse result = apiInstance.countEnzymes(idBioSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnzymesApi#countEnzymes");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
EnzymesApi *apiInstance = [[EnzymesApi alloc] init];
Integer *idBioSource = 56; // the idBioSource for the Enzyme (default to null)

// count ligns Enzyme
[apiInstance countEnzymesWith:idBioSource
              completionHandler: ^(CountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.EnzymesApi()
var idBioSource = 56; // {Integer} the idBioSource for the Enzyme

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

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

            // Create an instance of the API class
            var apiInstance = new EnzymesApi();
            var idBioSource = 56;  // Integer | the idBioSource for the Enzyme (default to null)

            try {
                // count ligns Enzyme
                CountResponse result = apiInstance.countEnzymes(idBioSource);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EnzymesApi.countEnzymes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EnzymesApi();
$idBioSource = 56; // Integer | the idBioSource for the Enzyme

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EnzymesApi->new();
my $idBioSource = 56; # Integer | the idBioSource for the Enzyme

eval {
    my $result = $api_instance->countEnzymes(idBioSource => $idBioSource);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnzymesApi->countEnzymes: $@\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.EnzymesApi()
idBioSource = 56 # Integer | the idBioSource for the Enzyme (default to null)

try:
    # count ligns Enzyme
    api_response = api_instance.count_enzymes(idBioSource)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnzymesApi->countEnzymes: %s\n" % e)
extern crate EnzymesApi;

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

    let mut context = EnzymesApi::Context::default();
    let result = client.countEnzymes(idBioSource, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
idBioSource*
Integer
the idBioSource for the Enzyme
Required

Responses


delEnzymes

del Enzyme

delete for Enzyme


/enzymes

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/enzymes?id=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.EnzymesApi;

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

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

        // Create an instance of the API class
        EnzymesApi apiInstance = new EnzymesApi();
        Integer id = 56; // Integer | the id for the Enzyme

        try {
            EnzymesResponse result = apiInstance.delEnzymes(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnzymesApi#delEnzymes");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.EnzymesApi;

public class EnzymesApiExample {
    public static void main(String[] args) {
        EnzymesApi apiInstance = new EnzymesApi();
        Integer id = 56; // Integer | the id for the Enzyme

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


// Create an instance of the API class
EnzymesApi *apiInstance = [[EnzymesApi alloc] init];
Integer *id = 56; // the id for the Enzyme (default to null)

// del Enzyme
[apiInstance delEnzymesWith:id
              completionHandler: ^(EnzymesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.EnzymesApi()
var id = 56; // {Integer} the id for the Enzyme

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

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

            // Create an instance of the API class
            var apiInstance = new EnzymesApi();
            var id = 56;  // Integer | the id for the Enzyme (default to null)

            try {
                // del Enzyme
                EnzymesResponse result = apiInstance.delEnzymes(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EnzymesApi.delEnzymes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EnzymesApi();
$id = 56; // Integer | the id for the Enzyme

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EnzymesApi->new();
my $id = 56; # Integer | the id for the Enzyme

eval {
    my $result = $api_instance->delEnzymes(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnzymesApi->delEnzymes: $@\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.EnzymesApi()
id = 56 # Integer | the id for the Enzyme (default to null)

try:
    # del Enzyme
    api_response = api_instance.del_enzymes(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnzymesApi->delEnzymes: %s\n" % e)
extern crate EnzymesApi;

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

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

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

Scopes

Parameters

Query parameters
Name Description
id*
Integer
the id for the Enzyme
Required

Responses


getEnzymes

get Enzyme

get from Enzyme


/enzymes

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/enzymes?id=56&idBioSource=56&idDB=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.EnzymesApi;

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

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

        // Create an instance of the API class
        EnzymesApi apiInstance = new EnzymesApi();
        Integer id = 56; // Integer | the id for the Enzyme
        Integer idBioSource = 56; // Integer | the idBioSource for the Enzyme
        Integer idDB = 56; // Integer | the idDB for the Enzyme

        try {
            EnzymesResponse result = apiInstance.getEnzymes(id, idBioSource, idDB);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnzymesApi#getEnzymes");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.EnzymesApi;

public class EnzymesApiExample {
    public static void main(String[] args) {
        EnzymesApi apiInstance = new EnzymesApi();
        Integer id = 56; // Integer | the id for the Enzyme
        Integer idBioSource = 56; // Integer | the idBioSource for the Enzyme
        Integer idDB = 56; // Integer | the idDB for the Enzyme

        try {
            EnzymesResponse result = apiInstance.getEnzymes(id, idBioSource, idDB);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnzymesApi#getEnzymes");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
EnzymesApi *apiInstance = [[EnzymesApi alloc] init];
Integer *id = 56; // the id for the Enzyme (optional) (default to null)
Integer *idBioSource = 56; // the idBioSource for the Enzyme (optional) (default to null)
Integer *idDB = 56; // the idDB for the Enzyme (optional) (default to null)

// get Enzyme
[apiInstance getEnzymesWith:id
    idBioSource:idBioSource
    idDB:idDB
              completionHandler: ^(EnzymesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.EnzymesApi()
var opts = {
  'id': 56, // {Integer} the id for the Enzyme
  'idBioSource': 56, // {Integer} the idBioSource for the Enzyme
  'idDB': 56 // {Integer} the idDB for the Enzyme
};

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

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

            // Create an instance of the API class
            var apiInstance = new EnzymesApi();
            var id = 56;  // Integer | the id for the Enzyme (optional)  (default to null)
            var idBioSource = 56;  // Integer | the idBioSource for the Enzyme (optional)  (default to null)
            var idDB = 56;  // Integer | the idDB for the Enzyme (optional)  (default to null)

            try {
                // get Enzyme
                EnzymesResponse result = apiInstance.getEnzymes(id, idBioSource, idDB);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EnzymesApi.getEnzymes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EnzymesApi();
$id = 56; // Integer | the id for the Enzyme
$idBioSource = 56; // Integer | the idBioSource for the Enzyme
$idDB = 56; // Integer | the idDB for the Enzyme

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EnzymesApi->new();
my $id = 56; # Integer | the id for the Enzyme
my $idBioSource = 56; # Integer | the idBioSource for the Enzyme
my $idDB = 56; # Integer | the idDB for the Enzyme

eval {
    my $result = $api_instance->getEnzymes(id => $id, idBioSource => $idBioSource, idDB => $idDB);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnzymesApi->getEnzymes: $@\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.EnzymesApi()
id = 56 # Integer | the id for the Enzyme (optional) (default to null)
idBioSource = 56 # Integer | the idBioSource for the Enzyme (optional) (default to null)
idDB = 56 # Integer | the idDB for the Enzyme (optional) (default to null)

try:
    # get Enzyme
    api_response = api_instance.get_enzymes(id=id, idBioSource=idBioSource, idDB=idDB)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnzymesApi->getEnzymes: %s\n" % e)
extern crate EnzymesApi;

pub fn main() {
    let id = 56; // Integer
    let idBioSource = 56; // Integer
    let idDB = 56; // Integer

    let mut context = EnzymesApi::Context::default();
    let result = client.getEnzymes(id, idBioSource, idDB, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
id
Integer
the id for the Enzyme
idBioSource
Integer
the idBioSource for the Enzyme
idDB
Integer
the idDB for the Enzyme

Responses


updateEnzymes

update Enzyme

update for Enzyme


/enzymes

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/enzymes" \
 -d 'null'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.EnzymesApi;

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

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

        // Create an instance of the API class
        EnzymesApi apiInstance = new EnzymesApi();
        array[EnzymesResponse] enzymesResponse = ; // array[EnzymesResponse] | 

        try {
            EnzymesResponse result = apiInstance.updateEnzymes(enzymesResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnzymesApi#updateEnzymes");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.EnzymesApi;

public class EnzymesApiExample {
    public static void main(String[] args) {
        EnzymesApi apiInstance = new EnzymesApi();
        array[EnzymesResponse] enzymesResponse = ; // array[EnzymesResponse] | 

        try {
            EnzymesResponse result = apiInstance.updateEnzymes(enzymesResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnzymesApi#updateEnzymes");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
EnzymesApi *apiInstance = [[EnzymesApi alloc] init];
array[EnzymesResponse] *enzymesResponse = ; //  (optional)

// update Enzyme
[apiInstance updateEnzymesWith:enzymesResponse
              completionHandler: ^(EnzymesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.EnzymesApi()
var opts = {
  'enzymesResponse':  // {array[EnzymesResponse]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new EnzymesApi();
            var enzymesResponse = new array[EnzymesResponse](); // array[EnzymesResponse] |  (optional) 

            try {
                // update Enzyme
                EnzymesResponse result = apiInstance.updateEnzymes(enzymesResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EnzymesApi.updateEnzymes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EnzymesApi();
$enzymesResponse = ; // array[EnzymesResponse] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EnzymesApi->new();
my $enzymesResponse = [WWW::OPenAPIClient::Object::array[EnzymesResponse]->new()]; # array[EnzymesResponse] | 

eval {
    my $result = $api_instance->updateEnzymes(enzymesResponse => $enzymesResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnzymesApi->updateEnzymes: $@\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.EnzymesApi()
enzymesResponse =  # array[EnzymesResponse] |  (optional)

try:
    # update Enzyme
    api_response = api_instance.update_enzymes(enzymesResponse=enzymesResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnzymesApi->updateEnzymes: %s\n" % e)
extern crate EnzymesApi;

pub fn main() {
    let enzymesResponse = ; // array[EnzymesResponse]

    let mut context = EnzymesApi::Context::default();
    let result = client.updateEnzymes(enzymesResponse, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
enzymesResponse

Responses


Filters

getFilter

filter identifiers of metabolic entities by ids of other metabolic entities

filter identifiers of metabolic entities by ids of other metabolic entities


/filter

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/filter" \
 -d '{
  "ids" : "1,12",
  "filtertype" : "Gene2Reaction"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FiltersApi;

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

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

        // Create an instance of the API class
        FiltersApi apiInstance = new FiltersApi();
        array[Filter] filter = ; // array[Filter] | 

        try {
            FiltersResponse result = apiInstance.getFilter(filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FiltersApi#getFilter");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.FiltersApi;

public class FiltersApiExample {
    public static void main(String[] args) {
        FiltersApi apiInstance = new FiltersApi();
        array[Filter] filter = ; // array[Filter] | 

        try {
            FiltersResponse result = apiInstance.getFilter(filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FiltersApi#getFilter");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
FiltersApi *apiInstance = [[FiltersApi alloc] init];
array[Filter] *filter = ; //  (optional)

// filter identifiers of metabolic entities by ids of other metabolic entities
[apiInstance getFilterWith:filter
              completionHandler: ^(FiltersResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.FiltersApi()
var opts = {
  'filter':  // {array[Filter]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new FiltersApi();
            var filter = new array[Filter](); // array[Filter] |  (optional) 

            try {
                // filter identifiers of metabolic entities by ids of other metabolic entities
                FiltersResponse result = apiInstance.getFilter(filter);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FiltersApi.getFilter: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FiltersApi();
$filter = ; // array[Filter] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FiltersApi->new();
my $filter = [WWW::OPenAPIClient::Object::array[Filter]->new()]; # array[Filter] | 

eval {
    my $result = $api_instance->getFilter(filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FiltersApi->getFilter: $@\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.FiltersApi()
filter =  # array[Filter] |  (optional)

try:
    # filter identifiers of metabolic entities by ids of other metabolic entities
    api_response = api_instance.get_filter(filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FiltersApi->getFilter: %s\n" % e)
extern crate FiltersApi;

pub fn main() {
    let filter = ; // array[Filter]

    let mut context = FiltersApi::Context::default();
    let result = client.getFilter(filter, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
filter

Responses


Genes

addGenes

add Gene

add for Gene


/genes

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/genes" \
 -d 'null'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GenesApi;

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

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

        // Create an instance of the API class
        GenesApi apiInstance = new GenesApi();
        array[GenesResponse] genesResponse = ; // array[GenesResponse] | 

        try {
            GenesResponse result = apiInstance.addGenes(genesResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GenesApi#addGenes");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GenesApi;

public class GenesApiExample {
    public static void main(String[] args) {
        GenesApi apiInstance = new GenesApi();
        array[GenesResponse] genesResponse = ; // array[GenesResponse] | 

        try {
            GenesResponse result = apiInstance.addGenes(genesResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GenesApi#addGenes");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GenesApi *apiInstance = [[GenesApi alloc] init];
array[GenesResponse] *genesResponse = ; //  (optional)

// add Gene
[apiInstance addGenesWith:genesResponse
              completionHandler: ^(GenesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.GenesApi()
var opts = {
  'genesResponse':  // {array[GenesResponse]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new GenesApi();
            var genesResponse = new array[GenesResponse](); // array[GenesResponse] |  (optional) 

            try {
                // add Gene
                GenesResponse result = apiInstance.addGenes(genesResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GenesApi.addGenes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GenesApi();
$genesResponse = ; // array[GenesResponse] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GenesApi->new();
my $genesResponse = [WWW::OPenAPIClient::Object::array[GenesResponse]->new()]; # array[GenesResponse] | 

eval {
    my $result = $api_instance->addGenes(genesResponse => $genesResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GenesApi->addGenes: $@\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.GenesApi()
genesResponse =  # array[GenesResponse] |  (optional)

try:
    # add Gene
    api_response = api_instance.add_genes(genesResponse=genesResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GenesApi->addGenes: %s\n" % e)
extern crate GenesApi;

pub fn main() {
    let genesResponse = ; // array[GenesResponse]

    let mut context = GenesApi::Context::default();
    let result = client.addGenes(genesResponse, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
genesResponse

Responses


countGenes

count ligns Genes

get the number of genes for one biosource


/genes/count

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/genes/count?idBioSource=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GenesApi;

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

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

        // Create an instance of the API class
        GenesApi apiInstance = new GenesApi();
        Integer idBioSource = 56; // Integer | the idBioSource for the genes

        try {
            CountResponse result = apiInstance.countGenes(idBioSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GenesApi#countGenes");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GenesApi;

public class GenesApiExample {
    public static void main(String[] args) {
        GenesApi apiInstance = new GenesApi();
        Integer idBioSource = 56; // Integer | the idBioSource for the genes

        try {
            CountResponse result = apiInstance.countGenes(idBioSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GenesApi#countGenes");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GenesApi *apiInstance = [[GenesApi alloc] init];
Integer *idBioSource = 56; // the idBioSource for the genes (default to null)

// count ligns Genes
[apiInstance countGenesWith:idBioSource
              completionHandler: ^(CountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.GenesApi()
var idBioSource = 56; // {Integer} the idBioSource for the genes

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

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

            // Create an instance of the API class
            var apiInstance = new GenesApi();
            var idBioSource = 56;  // Integer | the idBioSource for the genes (default to null)

            try {
                // count ligns Genes
                CountResponse result = apiInstance.countGenes(idBioSource);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GenesApi.countGenes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GenesApi();
$idBioSource = 56; // Integer | the idBioSource for the genes

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GenesApi->new();
my $idBioSource = 56; # Integer | the idBioSource for the genes

eval {
    my $result = $api_instance->countGenes(idBioSource => $idBioSource);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GenesApi->countGenes: $@\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.GenesApi()
idBioSource = 56 # Integer | the idBioSource for the genes (default to null)

try:
    # count ligns Genes
    api_response = api_instance.count_genes(idBioSource)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GenesApi->countGenes: %s\n" % e)
extern crate GenesApi;

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

    let mut context = GenesApi::Context::default();
    let result = client.countGenes(idBioSource, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
idBioSource*
Integer
the idBioSource for the genes
Required

Responses


delGenes

del Gene

delete for Gene


/genes

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/genes?id=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GenesApi;

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

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

        // Create an instance of the API class
        GenesApi apiInstance = new GenesApi();
        Integer id = 56; // Integer | the id for the Gene

        try {
            GenesResponse result = apiInstance.delGenes(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GenesApi#delGenes");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GenesApi;

public class GenesApiExample {
    public static void main(String[] args) {
        GenesApi apiInstance = new GenesApi();
        Integer id = 56; // Integer | the id for the Gene

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


// Create an instance of the API class
GenesApi *apiInstance = [[GenesApi alloc] init];
Integer *id = 56; // the id for the Gene (default to null)

// del Gene
[apiInstance delGenesWith:id
              completionHandler: ^(GenesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.GenesApi()
var id = 56; // {Integer} the id for the Gene

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

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

            // Create an instance of the API class
            var apiInstance = new GenesApi();
            var id = 56;  // Integer | the id for the Gene (default to null)

            try {
                // del Gene
                GenesResponse result = apiInstance.delGenes(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GenesApi.delGenes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GenesApi();
$id = 56; // Integer | the id for the Gene

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GenesApi->new();
my $id = 56; # Integer | the id for the Gene

eval {
    my $result = $api_instance->delGenes(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GenesApi->delGenes: $@\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.GenesApi()
id = 56 # Integer | the id for the Gene (default to null)

try:
    # del Gene
    api_response = api_instance.del_genes(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GenesApi->delGenes: %s\n" % e)
extern crate GenesApi;

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

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

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

Scopes

Parameters

Query parameters
Name Description
id*
Integer
the id for the Gene
Required

Responses


getGenes

get Gene

get from Gene


/genes

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/genes?id=56&idBioSource=56&idDB=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GenesApi;

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

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

        // Create an instance of the API class
        GenesApi apiInstance = new GenesApi();
        Integer id = 56; // Integer | the id for the Gene
        Integer idBioSource = 56; // Integer | the idBioSource for the Gene
        Integer idDB = 56; // Integer | the idDB for the Gene

        try {
            GenesResponse result = apiInstance.getGenes(id, idBioSource, idDB);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GenesApi#getGenes");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GenesApi;

public class GenesApiExample {
    public static void main(String[] args) {
        GenesApi apiInstance = new GenesApi();
        Integer id = 56; // Integer | the id for the Gene
        Integer idBioSource = 56; // Integer | the idBioSource for the Gene
        Integer idDB = 56; // Integer | the idDB for the Gene

        try {
            GenesResponse result = apiInstance.getGenes(id, idBioSource, idDB);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GenesApi#getGenes");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GenesApi *apiInstance = [[GenesApi alloc] init];
Integer *id = 56; // the id for the Gene (optional) (default to null)
Integer *idBioSource = 56; // the idBioSource for the Gene (optional) (default to null)
Integer *idDB = 56; // the idDB for the Gene (optional) (default to null)

// get Gene
[apiInstance getGenesWith:id
    idBioSource:idBioSource
    idDB:idDB
              completionHandler: ^(GenesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.GenesApi()
var opts = {
  'id': 56, // {Integer} the id for the Gene
  'idBioSource': 56, // {Integer} the idBioSource for the Gene
  'idDB': 56 // {Integer} the idDB for the Gene
};

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

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

            // Create an instance of the API class
            var apiInstance = new GenesApi();
            var id = 56;  // Integer | the id for the Gene (optional)  (default to null)
            var idBioSource = 56;  // Integer | the idBioSource for the Gene (optional)  (default to null)
            var idDB = 56;  // Integer | the idDB for the Gene (optional)  (default to null)

            try {
                // get Gene
                GenesResponse result = apiInstance.getGenes(id, idBioSource, idDB);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GenesApi.getGenes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GenesApi();
$id = 56; // Integer | the id for the Gene
$idBioSource = 56; // Integer | the idBioSource for the Gene
$idDB = 56; // Integer | the idDB for the Gene

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GenesApi->new();
my $id = 56; # Integer | the id for the Gene
my $idBioSource = 56; # Integer | the idBioSource for the Gene
my $idDB = 56; # Integer | the idDB for the Gene

eval {
    my $result = $api_instance->getGenes(id => $id, idBioSource => $idBioSource, idDB => $idDB);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GenesApi->getGenes: $@\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.GenesApi()
id = 56 # Integer | the id for the Gene (optional) (default to null)
idBioSource = 56 # Integer | the idBioSource for the Gene (optional) (default to null)
idDB = 56 # Integer | the idDB for the Gene (optional) (default to null)

try:
    # get Gene
    api_response = api_instance.get_genes(id=id, idBioSource=idBioSource, idDB=idDB)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GenesApi->getGenes: %s\n" % e)
extern crate GenesApi;

pub fn main() {
    let id = 56; // Integer
    let idBioSource = 56; // Integer
    let idDB = 56; // Integer

    let mut context = GenesApi::Context::default();
    let result = client.getGenes(id, idBioSource, idDB, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
id
Integer
the id for the Gene
idBioSource
Integer
the idBioSource for the Gene
idDB
Integer
the idDB for the Gene

Responses


updateGenes

update Gene

update for Gene


/genes

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/genes" \
 -d 'null'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GenesApi;

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

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

        // Create an instance of the API class
        GenesApi apiInstance = new GenesApi();
        array[GenesResponse] genesResponse = ; // array[GenesResponse] | 

        try {
            GenesResponse result = apiInstance.updateGenes(genesResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GenesApi#updateGenes");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GenesApi;

public class GenesApiExample {
    public static void main(String[] args) {
        GenesApi apiInstance = new GenesApi();
        array[GenesResponse] genesResponse = ; // array[GenesResponse] | 

        try {
            GenesResponse result = apiInstance.updateGenes(genesResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GenesApi#updateGenes");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GenesApi *apiInstance = [[GenesApi alloc] init];
array[GenesResponse] *genesResponse = ; //  (optional)

// update Gene
[apiInstance updateGenesWith:genesResponse
              completionHandler: ^(GenesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.GenesApi()
var opts = {
  'genesResponse':  // {array[GenesResponse]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new GenesApi();
            var genesResponse = new array[GenesResponse](); // array[GenesResponse] |  (optional) 

            try {
                // update Gene
                GenesResponse result = apiInstance.updateGenes(genesResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GenesApi.updateGenes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GenesApi();
$genesResponse = ; // array[GenesResponse] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GenesApi->new();
my $genesResponse = [WWW::OPenAPIClient::Object::array[GenesResponse]->new()]; # array[GenesResponse] | 

eval {
    my $result = $api_instance->updateGenes(genesResponse => $genesResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GenesApi->updateGenes: $@\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.GenesApi()
genesResponse =  # array[GenesResponse] |  (optional)

try:
    # update Gene
    api_response = api_instance.update_genes(genesResponse=genesResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GenesApi->updateGenes: %s\n" % e)
extern crate GenesApi;

pub fn main() {
    let genesResponse = ; // array[GenesResponse]

    let mut context = GenesApi::Context::default();
    let result = client.updateGenes(genesResponse, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
genesResponse

Responses


Metabolites

addMetabolites

add Metabolite

add for Metabolite


/metabolites

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/metabolites" \
 -d 'null'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MetabolitesApi;

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

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

        // Create an instance of the API class
        MetabolitesApi apiInstance = new MetabolitesApi();
        array[MetabolitesResponse] metabolitesResponse = ; // array[MetabolitesResponse] | 

        try {
            MetabolitesResponse result = apiInstance.addMetabolites(metabolitesResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetabolitesApi#addMetabolites");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MetabolitesApi;

public class MetabolitesApiExample {
    public static void main(String[] args) {
        MetabolitesApi apiInstance = new MetabolitesApi();
        array[MetabolitesResponse] metabolitesResponse = ; // array[MetabolitesResponse] | 

        try {
            MetabolitesResponse result = apiInstance.addMetabolites(metabolitesResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetabolitesApi#addMetabolites");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
MetabolitesApi *apiInstance = [[MetabolitesApi alloc] init];
array[MetabolitesResponse] *metabolitesResponse = ; //  (optional)

// add Metabolite
[apiInstance addMetabolitesWith:metabolitesResponse
              completionHandler: ^(MetabolitesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.MetabolitesApi()
var opts = {
  'metabolitesResponse':  // {array[MetabolitesResponse]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new MetabolitesApi();
            var metabolitesResponse = new array[MetabolitesResponse](); // array[MetabolitesResponse] |  (optional) 

            try {
                // add Metabolite
                MetabolitesResponse result = apiInstance.addMetabolites(metabolitesResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MetabolitesApi.addMetabolites: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MetabolitesApi();
$metabolitesResponse = ; // array[MetabolitesResponse] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MetabolitesApi->new();
my $metabolitesResponse = [WWW::OPenAPIClient::Object::array[MetabolitesResponse]->new()]; # array[MetabolitesResponse] | 

eval {
    my $result = $api_instance->addMetabolites(metabolitesResponse => $metabolitesResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MetabolitesApi->addMetabolites: $@\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.MetabolitesApi()
metabolitesResponse =  # array[MetabolitesResponse] |  (optional)

try:
    # add Metabolite
    api_response = api_instance.add_metabolites(metabolitesResponse=metabolitesResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MetabolitesApi->addMetabolites: %s\n" % e)
extern crate MetabolitesApi;

pub fn main() {
    let metabolitesResponse = ; // array[MetabolitesResponse]

    let mut context = MetabolitesApi::Context::default();
    let result = client.addMetabolites(metabolitesResponse, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
metabolitesResponse

Responses


countMetabolites

count ligns Metabolites

get the number of metabolites for one biosource


/metabolites/count

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/metabolites/count?idBioSource=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MetabolitesApi;

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

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

        // Create an instance of the API class
        MetabolitesApi apiInstance = new MetabolitesApi();
        Integer idBioSource = 56; // Integer | the idBioSource for the metabolites

        try {
            CountResponse result = apiInstance.countMetabolites(idBioSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetabolitesApi#countMetabolites");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MetabolitesApi;

public class MetabolitesApiExample {
    public static void main(String[] args) {
        MetabolitesApi apiInstance = new MetabolitesApi();
        Integer idBioSource = 56; // Integer | the idBioSource for the metabolites

        try {
            CountResponse result = apiInstance.countMetabolites(idBioSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetabolitesApi#countMetabolites");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
MetabolitesApi *apiInstance = [[MetabolitesApi alloc] init];
Integer *idBioSource = 56; // the idBioSource for the metabolites (default to null)

// count ligns Metabolites
[apiInstance countMetabolitesWith:idBioSource
              completionHandler: ^(CountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.MetabolitesApi()
var idBioSource = 56; // {Integer} the idBioSource for the metabolites

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

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

            // Create an instance of the API class
            var apiInstance = new MetabolitesApi();
            var idBioSource = 56;  // Integer | the idBioSource for the metabolites (default to null)

            try {
                // count ligns Metabolites
                CountResponse result = apiInstance.countMetabolites(idBioSource);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MetabolitesApi.countMetabolites: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MetabolitesApi();
$idBioSource = 56; // Integer | the idBioSource for the metabolites

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MetabolitesApi->new();
my $idBioSource = 56; # Integer | the idBioSource for the metabolites

eval {
    my $result = $api_instance->countMetabolites(idBioSource => $idBioSource);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MetabolitesApi->countMetabolites: $@\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.MetabolitesApi()
idBioSource = 56 # Integer | the idBioSource for the metabolites (default to null)

try:
    # count ligns Metabolites
    api_response = api_instance.count_metabolites(idBioSource)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MetabolitesApi->countMetabolites: %s\n" % e)
extern crate MetabolitesApi;

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

    let mut context = MetabolitesApi::Context::default();
    let result = client.countMetabolites(idBioSource, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
idBioSource*
Integer
the idBioSource for the metabolites
Required

Responses


delMetabolites

del Metabolite

delete for Metabolite


/metabolites

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/metabolites?id=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MetabolitesApi;

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

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

        // Create an instance of the API class
        MetabolitesApi apiInstance = new MetabolitesApi();
        Integer id = 56; // Integer | the id for the Metabolite

        try {
            MetabolitesResponse result = apiInstance.delMetabolites(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetabolitesApi#delMetabolites");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MetabolitesApi;

public class MetabolitesApiExample {
    public static void main(String[] args) {
        MetabolitesApi apiInstance = new MetabolitesApi();
        Integer id = 56; // Integer | the id for the Metabolite

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


// Create an instance of the API class
MetabolitesApi *apiInstance = [[MetabolitesApi alloc] init];
Integer *id = 56; // the id for the Metabolite (default to null)

// del Metabolite
[apiInstance delMetabolitesWith:id
              completionHandler: ^(MetabolitesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.MetabolitesApi()
var id = 56; // {Integer} the id for the Metabolite

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

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

            // Create an instance of the API class
            var apiInstance = new MetabolitesApi();
            var id = 56;  // Integer | the id for the Metabolite (default to null)

            try {
                // del Metabolite
                MetabolitesResponse result = apiInstance.delMetabolites(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MetabolitesApi.delMetabolites: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MetabolitesApi();
$id = 56; // Integer | the id for the Metabolite

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MetabolitesApi->new();
my $id = 56; # Integer | the id for the Metabolite

eval {
    my $result = $api_instance->delMetabolites(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MetabolitesApi->delMetabolites: $@\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.MetabolitesApi()
id = 56 # Integer | the id for the Metabolite (default to null)

try:
    # del Metabolite
    api_response = api_instance.del_metabolites(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MetabolitesApi->delMetabolites: %s\n" % e)
extern crate MetabolitesApi;

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

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

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

Scopes

Parameters

Query parameters
Name Description
id*
Integer
the id for the Metabolite
Required

Responses


getMetabolites

get Metabolite

get from Metabolite


/metabolites

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/metabolites?id=56&idBioSource=56&idDB=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MetabolitesApi;

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

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

        // Create an instance of the API class
        MetabolitesApi apiInstance = new MetabolitesApi();
        Integer id = 56; // Integer | the id for the Metabolite
        Integer idBioSource = 56; // Integer | the idBioSource for the Metabolite
        Integer idDB = 56; // Integer | the idDB for the Metabolite

        try {
            MetabolitesResponse result = apiInstance.getMetabolites(id, idBioSource, idDB);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetabolitesApi#getMetabolites");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MetabolitesApi;

public class MetabolitesApiExample {
    public static void main(String[] args) {
        MetabolitesApi apiInstance = new MetabolitesApi();
        Integer id = 56; // Integer | the id for the Metabolite
        Integer idBioSource = 56; // Integer | the idBioSource for the Metabolite
        Integer idDB = 56; // Integer | the idDB for the Metabolite

        try {
            MetabolitesResponse result = apiInstance.getMetabolites(id, idBioSource, idDB);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetabolitesApi#getMetabolites");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
MetabolitesApi *apiInstance = [[MetabolitesApi alloc] init];
Integer *id = 56; // the id for the Metabolite (optional) (default to null)
Integer *idBioSource = 56; // the idBioSource for the Metabolite (optional) (default to null)
Integer *idDB = 56; // the idDB for the Metabolite (optional) (default to null)

// get Metabolite
[apiInstance getMetabolitesWith:id
    idBioSource:idBioSource
    idDB:idDB
              completionHandler: ^(MetabolitesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.MetabolitesApi()
var opts = {
  'id': 56, // {Integer} the id for the Metabolite
  'idBioSource': 56, // {Integer} the idBioSource for the Metabolite
  'idDB': 56 // {Integer} the idDB for the Metabolite
};

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

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

            // Create an instance of the API class
            var apiInstance = new MetabolitesApi();
            var id = 56;  // Integer | the id for the Metabolite (optional)  (default to null)
            var idBioSource = 56;  // Integer | the idBioSource for the Metabolite (optional)  (default to null)
            var idDB = 56;  // Integer | the idDB for the Metabolite (optional)  (default to null)

            try {
                // get Metabolite
                MetabolitesResponse result = apiInstance.getMetabolites(id, idBioSource, idDB);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MetabolitesApi.getMetabolites: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MetabolitesApi();
$id = 56; // Integer | the id for the Metabolite
$idBioSource = 56; // Integer | the idBioSource for the Metabolite
$idDB = 56; // Integer | the idDB for the Metabolite

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MetabolitesApi->new();
my $id = 56; # Integer | the id for the Metabolite
my $idBioSource = 56; # Integer | the idBioSource for the Metabolite
my $idDB = 56; # Integer | the idDB for the Metabolite

eval {
    my $result = $api_instance->getMetabolites(id => $id, idBioSource => $idBioSource, idDB => $idDB);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MetabolitesApi->getMetabolites: $@\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.MetabolitesApi()
id = 56 # Integer | the id for the Metabolite (optional) (default to null)
idBioSource = 56 # Integer | the idBioSource for the Metabolite (optional) (default to null)
idDB = 56 # Integer | the idDB for the Metabolite (optional) (default to null)

try:
    # get Metabolite
    api_response = api_instance.get_metabolites(id=id, idBioSource=idBioSource, idDB=idDB)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MetabolitesApi->getMetabolites: %s\n" % e)
extern crate MetabolitesApi;

pub fn main() {
    let id = 56; // Integer
    let idBioSource = 56; // Integer
    let idDB = 56; // Integer

    let mut context = MetabolitesApi::Context::default();
    let result = client.getMetabolites(id, idBioSource, idDB, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
id
Integer
the id for the Metabolite
idBioSource
Integer
the idBioSource for the Metabolite
idDB
Integer
the idDB for the Metabolite

Responses


updateMetabolites

update Metabolite

update for Metabolite


/metabolites

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/metabolites" \
 -d 'null'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MetabolitesApi;

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

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

        // Create an instance of the API class
        MetabolitesApi apiInstance = new MetabolitesApi();
        array[MetabolitesResponse] metabolitesResponse = ; // array[MetabolitesResponse] | 

        try {
            MetabolitesResponse result = apiInstance.updateMetabolites(metabolitesResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetabolitesApi#updateMetabolites");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MetabolitesApi;

public class MetabolitesApiExample {
    public static void main(String[] args) {
        MetabolitesApi apiInstance = new MetabolitesApi();
        array[MetabolitesResponse] metabolitesResponse = ; // array[MetabolitesResponse] | 

        try {
            MetabolitesResponse result = apiInstance.updateMetabolites(metabolitesResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MetabolitesApi#updateMetabolites");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
MetabolitesApi *apiInstance = [[MetabolitesApi alloc] init];
array[MetabolitesResponse] *metabolitesResponse = ; //  (optional)

// update Metabolite
[apiInstance updateMetabolitesWith:metabolitesResponse
              completionHandler: ^(MetabolitesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.MetabolitesApi()
var opts = {
  'metabolitesResponse':  // {array[MetabolitesResponse]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new MetabolitesApi();
            var metabolitesResponse = new array[MetabolitesResponse](); // array[MetabolitesResponse] |  (optional) 

            try {
                // update Metabolite
                MetabolitesResponse result = apiInstance.updateMetabolites(metabolitesResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MetabolitesApi.updateMetabolites: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MetabolitesApi();
$metabolitesResponse = ; // array[MetabolitesResponse] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MetabolitesApi->new();
my $metabolitesResponse = [WWW::OPenAPIClient::Object::array[MetabolitesResponse]->new()]; # array[MetabolitesResponse] | 

eval {
    my $result = $api_instance->updateMetabolites(metabolitesResponse => $metabolitesResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MetabolitesApi->updateMetabolites: $@\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.MetabolitesApi()
metabolitesResponse =  # array[MetabolitesResponse] |  (optional)

try:
    # update Metabolite
    api_response = api_instance.update_metabolites(metabolitesResponse=metabolitesResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MetabolitesApi->updateMetabolites: %s\n" % e)
extern crate MetabolitesApi;

pub fn main() {
    let metabolitesResponse = ; // array[MetabolitesResponse]

    let mut context = MetabolitesApi::Context::default();
    let result = client.updateMetabolites(metabolitesResponse, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
metabolitesResponse

Responses


Pathways

addPathways

add Pathway

add for Pathway


/pathways

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/pathways" \
 -d 'null'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PathwaysApi;

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

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

        // Create an instance of the API class
        PathwaysApi apiInstance = new PathwaysApi();
        array[PathwaysResponse] pathwaysResponse = ; // array[PathwaysResponse] | 

        try {
            PathwaysResponse result = apiInstance.addPathways(pathwaysResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PathwaysApi#addPathways");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PathwaysApi;

public class PathwaysApiExample {
    public static void main(String[] args) {
        PathwaysApi apiInstance = new PathwaysApi();
        array[PathwaysResponse] pathwaysResponse = ; // array[PathwaysResponse] | 

        try {
            PathwaysResponse result = apiInstance.addPathways(pathwaysResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PathwaysApi#addPathways");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
PathwaysApi *apiInstance = [[PathwaysApi alloc] init];
array[PathwaysResponse] *pathwaysResponse = ; //  (optional)

// add Pathway
[apiInstance addPathwaysWith:pathwaysResponse
              completionHandler: ^(PathwaysResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.PathwaysApi()
var opts = {
  'pathwaysResponse':  // {array[PathwaysResponse]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new PathwaysApi();
            var pathwaysResponse = new array[PathwaysResponse](); // array[PathwaysResponse] |  (optional) 

            try {
                // add Pathway
                PathwaysResponse result = apiInstance.addPathways(pathwaysResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PathwaysApi.addPathways: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PathwaysApi();
$pathwaysResponse = ; // array[PathwaysResponse] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PathwaysApi->new();
my $pathwaysResponse = [WWW::OPenAPIClient::Object::array[PathwaysResponse]->new()]; # array[PathwaysResponse] | 

eval {
    my $result = $api_instance->addPathways(pathwaysResponse => $pathwaysResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PathwaysApi->addPathways: $@\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.PathwaysApi()
pathwaysResponse =  # array[PathwaysResponse] |  (optional)

try:
    # add Pathway
    api_response = api_instance.add_pathways(pathwaysResponse=pathwaysResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PathwaysApi->addPathways: %s\n" % e)
extern crate PathwaysApi;

pub fn main() {
    let pathwaysResponse = ; // array[PathwaysResponse]

    let mut context = PathwaysApi::Context::default();
    let result = client.addPathways(pathwaysResponse, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
pathwaysResponse

Responses


countPathways

count ligns Pathways

get the number of pathways for one biosource


/pathways/count

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/pathways/count?idBioSource=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PathwaysApi;

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

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

        // Create an instance of the API class
        PathwaysApi apiInstance = new PathwaysApi();
        Integer idBioSource = 56; // Integer | the idBioSource for the pathways

        try {
            CountResponse result = apiInstance.countPathways(idBioSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PathwaysApi#countPathways");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PathwaysApi;

public class PathwaysApiExample {
    public static void main(String[] args) {
        PathwaysApi apiInstance = new PathwaysApi();
        Integer idBioSource = 56; // Integer | the idBioSource for the pathways

        try {
            CountResponse result = apiInstance.countPathways(idBioSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PathwaysApi#countPathways");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
PathwaysApi *apiInstance = [[PathwaysApi alloc] init];
Integer *idBioSource = 56; // the idBioSource for the pathways (default to null)

// count ligns Pathways
[apiInstance countPathwaysWith:idBioSource
              completionHandler: ^(CountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.PathwaysApi()
var idBioSource = 56; // {Integer} the idBioSource for the pathways

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

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

            // Create an instance of the API class
            var apiInstance = new PathwaysApi();
            var idBioSource = 56;  // Integer | the idBioSource for the pathways (default to null)

            try {
                // count ligns Pathways
                CountResponse result = apiInstance.countPathways(idBioSource);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PathwaysApi.countPathways: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PathwaysApi();
$idBioSource = 56; // Integer | the idBioSource for the pathways

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PathwaysApi->new();
my $idBioSource = 56; # Integer | the idBioSource for the pathways

eval {
    my $result = $api_instance->countPathways(idBioSource => $idBioSource);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PathwaysApi->countPathways: $@\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.PathwaysApi()
idBioSource = 56 # Integer | the idBioSource for the pathways (default to null)

try:
    # count ligns Pathways
    api_response = api_instance.count_pathways(idBioSource)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PathwaysApi->countPathways: %s\n" % e)
extern crate PathwaysApi;

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

    let mut context = PathwaysApi::Context::default();
    let result = client.countPathways(idBioSource, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
idBioSource*
Integer
the idBioSource for the pathways
Required

Responses


delPathways

del Pathway

delete for Pathway


/pathways

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/pathways?id=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PathwaysApi;

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

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

        // Create an instance of the API class
        PathwaysApi apiInstance = new PathwaysApi();
        Integer id = 56; // Integer | the id for the Pathway

        try {
            PathwaysResponse result = apiInstance.delPathways(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PathwaysApi#delPathways");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PathwaysApi;

public class PathwaysApiExample {
    public static void main(String[] args) {
        PathwaysApi apiInstance = new PathwaysApi();
        Integer id = 56; // Integer | the id for the Pathway

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


// Create an instance of the API class
PathwaysApi *apiInstance = [[PathwaysApi alloc] init];
Integer *id = 56; // the id for the Pathway (default to null)

// del Pathway
[apiInstance delPathwaysWith:id
              completionHandler: ^(PathwaysResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.PathwaysApi()
var id = 56; // {Integer} the id for the Pathway

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

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

            // Create an instance of the API class
            var apiInstance = new PathwaysApi();
            var id = 56;  // Integer | the id for the Pathway (default to null)

            try {
                // del Pathway
                PathwaysResponse result = apiInstance.delPathways(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PathwaysApi.delPathways: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PathwaysApi();
$id = 56; // Integer | the id for the Pathway

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PathwaysApi->new();
my $id = 56; # Integer | the id for the Pathway

eval {
    my $result = $api_instance->delPathways(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PathwaysApi->delPathways: $@\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.PathwaysApi()
id = 56 # Integer | the id for the Pathway (default to null)

try:
    # del Pathway
    api_response = api_instance.del_pathways(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PathwaysApi->delPathways: %s\n" % e)
extern crate PathwaysApi;

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

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

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

Scopes

Parameters

Query parameters
Name Description
id*
Integer
the id for the Pathway
Required

Responses


getPathways

get Pathway

get from Pathway


/pathways

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/pathways?id=56&idBioSource=56&idDB=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PathwaysApi;

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

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

        // Create an instance of the API class
        PathwaysApi apiInstance = new PathwaysApi();
        Integer id = 56; // Integer | the id for the Pathway
        Integer idBioSource = 56; // Integer | the idBioSource for the Pathway
        Integer idDB = 56; // Integer | the idDB for the Pathway

        try {
            PathwaysResponse result = apiInstance.getPathways(id, idBioSource, idDB);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PathwaysApi#getPathways");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PathwaysApi;

public class PathwaysApiExample {
    public static void main(String[] args) {
        PathwaysApi apiInstance = new PathwaysApi();
        Integer id = 56; // Integer | the id for the Pathway
        Integer idBioSource = 56; // Integer | the idBioSource for the Pathway
        Integer idDB = 56; // Integer | the idDB for the Pathway

        try {
            PathwaysResponse result = apiInstance.getPathways(id, idBioSource, idDB);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PathwaysApi#getPathways");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
PathwaysApi *apiInstance = [[PathwaysApi alloc] init];
Integer *id = 56; // the id for the Pathway (optional) (default to null)
Integer *idBioSource = 56; // the idBioSource for the Pathway (optional) (default to null)
Integer *idDB = 56; // the idDB for the Pathway (optional) (default to null)

// get Pathway
[apiInstance getPathwaysWith:id
    idBioSource:idBioSource
    idDB:idDB
              completionHandler: ^(PathwaysResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.PathwaysApi()
var opts = {
  'id': 56, // {Integer} the id for the Pathway
  'idBioSource': 56, // {Integer} the idBioSource for the Pathway
  'idDB': 56 // {Integer} the idDB for the Pathway
};

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

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

            // Create an instance of the API class
            var apiInstance = new PathwaysApi();
            var id = 56;  // Integer | the id for the Pathway (optional)  (default to null)
            var idBioSource = 56;  // Integer | the idBioSource for the Pathway (optional)  (default to null)
            var idDB = 56;  // Integer | the idDB for the Pathway (optional)  (default to null)

            try {
                // get Pathway
                PathwaysResponse result = apiInstance.getPathways(id, idBioSource, idDB);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PathwaysApi.getPathways: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PathwaysApi();
$id = 56; // Integer | the id for the Pathway
$idBioSource = 56; // Integer | the idBioSource for the Pathway
$idDB = 56; // Integer | the idDB for the Pathway

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PathwaysApi->new();
my $id = 56; # Integer | the id for the Pathway
my $idBioSource = 56; # Integer | the idBioSource for the Pathway
my $idDB = 56; # Integer | the idDB for the Pathway

eval {
    my $result = $api_instance->getPathways(id => $id, idBioSource => $idBioSource, idDB => $idDB);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PathwaysApi->getPathways: $@\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.PathwaysApi()
id = 56 # Integer | the id for the Pathway (optional) (default to null)
idBioSource = 56 # Integer | the idBioSource for the Pathway (optional) (default to null)
idDB = 56 # Integer | the idDB for the Pathway (optional) (default to null)

try:
    # get Pathway
    api_response = api_instance.get_pathways(id=id, idBioSource=idBioSource, idDB=idDB)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PathwaysApi->getPathways: %s\n" % e)
extern crate PathwaysApi;

pub fn main() {
    let id = 56; // Integer
    let idBioSource = 56; // Integer
    let idDB = 56; // Integer

    let mut context = PathwaysApi::Context::default();
    let result = client.getPathways(id, idBioSource, idDB, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
id
Integer
the id for the Pathway
idBioSource
Integer
the idBioSource for the Pathway
idDB
Integer
the idDB for the Pathway

Responses


updatePathways

update Pathway

update for Pathway


/pathways

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/pathways" \
 -d 'null'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PathwaysApi;

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

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

        // Create an instance of the API class
        PathwaysApi apiInstance = new PathwaysApi();
        array[PathwaysResponse] pathwaysResponse = ; // array[PathwaysResponse] | 

        try {
            PathwaysResponse result = apiInstance.updatePathways(pathwaysResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PathwaysApi#updatePathways");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.PathwaysApi;

public class PathwaysApiExample {
    public static void main(String[] args) {
        PathwaysApi apiInstance = new PathwaysApi();
        array[PathwaysResponse] pathwaysResponse = ; // array[PathwaysResponse] | 

        try {
            PathwaysResponse result = apiInstance.updatePathways(pathwaysResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PathwaysApi#updatePathways");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
PathwaysApi *apiInstance = [[PathwaysApi alloc] init];
array[PathwaysResponse] *pathwaysResponse = ; //  (optional)

// update Pathway
[apiInstance updatePathwaysWith:pathwaysResponse
              completionHandler: ^(PathwaysResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.PathwaysApi()
var opts = {
  'pathwaysResponse':  // {array[PathwaysResponse]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new PathwaysApi();
            var pathwaysResponse = new array[PathwaysResponse](); // array[PathwaysResponse] |  (optional) 

            try {
                // update Pathway
                PathwaysResponse result = apiInstance.updatePathways(pathwaysResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PathwaysApi.updatePathways: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PathwaysApi();
$pathwaysResponse = ; // array[PathwaysResponse] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PathwaysApi->new();
my $pathwaysResponse = [WWW::OPenAPIClient::Object::array[PathwaysResponse]->new()]; # array[PathwaysResponse] | 

eval {
    my $result = $api_instance->updatePathways(pathwaysResponse => $pathwaysResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PathwaysApi->updatePathways: $@\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.PathwaysApi()
pathwaysResponse =  # array[PathwaysResponse] |  (optional)

try:
    # update Pathway
    api_response = api_instance.update_pathways(pathwaysResponse=pathwaysResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PathwaysApi->updatePathways: %s\n" % e)
extern crate PathwaysApi;

pub fn main() {
    let pathwaysResponse = ; // array[PathwaysResponse]

    let mut context = PathwaysApi::Context::default();
    let result = client.updatePathways(pathwaysResponse, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
pathwaysResponse

Responses


Proteins

addProteins

add Protein

add for Protein


/proteins

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/proteins" \
 -d 'null'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProteinsApi;

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

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

        // Create an instance of the API class
        ProteinsApi apiInstance = new ProteinsApi();
        array[ProteinsResponse] proteinsResponse = ; // array[ProteinsResponse] | 

        try {
            ProteinsResponse result = apiInstance.addProteins(proteinsResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProteinsApi#addProteins");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProteinsApi;

public class ProteinsApiExample {
    public static void main(String[] args) {
        ProteinsApi apiInstance = new ProteinsApi();
        array[ProteinsResponse] proteinsResponse = ; // array[ProteinsResponse] | 

        try {
            ProteinsResponse result = apiInstance.addProteins(proteinsResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProteinsApi#addProteins");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProteinsApi *apiInstance = [[ProteinsApi alloc] init];
array[ProteinsResponse] *proteinsResponse = ; //  (optional)

// add Protein
[apiInstance addProteinsWith:proteinsResponse
              completionHandler: ^(ProteinsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.ProteinsApi()
var opts = {
  'proteinsResponse':  // {array[ProteinsResponse]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new ProteinsApi();
            var proteinsResponse = new array[ProteinsResponse](); // array[ProteinsResponse] |  (optional) 

            try {
                // add Protein
                ProteinsResponse result = apiInstance.addProteins(proteinsResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProteinsApi.addProteins: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProteinsApi();
$proteinsResponse = ; // array[ProteinsResponse] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProteinsApi->new();
my $proteinsResponse = [WWW::OPenAPIClient::Object::array[ProteinsResponse]->new()]; # array[ProteinsResponse] | 

eval {
    my $result = $api_instance->addProteins(proteinsResponse => $proteinsResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProteinsApi->addProteins: $@\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.ProteinsApi()
proteinsResponse =  # array[ProteinsResponse] |  (optional)

try:
    # add Protein
    api_response = api_instance.add_proteins(proteinsResponse=proteinsResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProteinsApi->addProteins: %s\n" % e)
extern crate ProteinsApi;

pub fn main() {
    let proteinsResponse = ; // array[ProteinsResponse]

    let mut context = ProteinsApi::Context::default();
    let result = client.addProteins(proteinsResponse, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
proteinsResponse

Responses


countProteins

count ligns Proteins

get the number of proteins for one biosource


/proteins/count

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/proteins/count?idBioSource=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProteinsApi;

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

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

        // Create an instance of the API class
        ProteinsApi apiInstance = new ProteinsApi();
        Integer idBioSource = 56; // Integer | the idBioSource for the proteins

        try {
            CountResponse result = apiInstance.countProteins(idBioSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProteinsApi#countProteins");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProteinsApi;

public class ProteinsApiExample {
    public static void main(String[] args) {
        ProteinsApi apiInstance = new ProteinsApi();
        Integer idBioSource = 56; // Integer | the idBioSource for the proteins

        try {
            CountResponse result = apiInstance.countProteins(idBioSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProteinsApi#countProteins");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProteinsApi *apiInstance = [[ProteinsApi alloc] init];
Integer *idBioSource = 56; // the idBioSource for the proteins (default to null)

// count ligns Proteins
[apiInstance countProteinsWith:idBioSource
              completionHandler: ^(CountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.ProteinsApi()
var idBioSource = 56; // {Integer} the idBioSource for the proteins

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

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

            // Create an instance of the API class
            var apiInstance = new ProteinsApi();
            var idBioSource = 56;  // Integer | the idBioSource for the proteins (default to null)

            try {
                // count ligns Proteins
                CountResponse result = apiInstance.countProteins(idBioSource);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProteinsApi.countProteins: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProteinsApi();
$idBioSource = 56; // Integer | the idBioSource for the proteins

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProteinsApi->new();
my $idBioSource = 56; # Integer | the idBioSource for the proteins

eval {
    my $result = $api_instance->countProteins(idBioSource => $idBioSource);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProteinsApi->countProteins: $@\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.ProteinsApi()
idBioSource = 56 # Integer | the idBioSource for the proteins (default to null)

try:
    # count ligns Proteins
    api_response = api_instance.count_proteins(idBioSource)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProteinsApi->countProteins: %s\n" % e)
extern crate ProteinsApi;

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

    let mut context = ProteinsApi::Context::default();
    let result = client.countProteins(idBioSource, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
idBioSource*
Integer
the idBioSource for the proteins
Required

Responses


delProteins

del Protein

delete for Protein


/proteins

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/proteins?id=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProteinsApi;

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

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

        // Create an instance of the API class
        ProteinsApi apiInstance = new ProteinsApi();
        Integer id = 56; // Integer | the id for the Protein

        try {
            ProteinsResponse result = apiInstance.delProteins(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProteinsApi#delProteins");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProteinsApi;

public class ProteinsApiExample {
    public static void main(String[] args) {
        ProteinsApi apiInstance = new ProteinsApi();
        Integer id = 56; // Integer | the id for the Protein

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


// Create an instance of the API class
ProteinsApi *apiInstance = [[ProteinsApi alloc] init];
Integer *id = 56; // the id for the Protein (default to null)

// del Protein
[apiInstance delProteinsWith:id
              completionHandler: ^(ProteinsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.ProteinsApi()
var id = 56; // {Integer} the id for the Protein

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

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

            // Create an instance of the API class
            var apiInstance = new ProteinsApi();
            var id = 56;  // Integer | the id for the Protein (default to null)

            try {
                // del Protein
                ProteinsResponse result = apiInstance.delProteins(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProteinsApi.delProteins: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProteinsApi();
$id = 56; // Integer | the id for the Protein

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProteinsApi->new();
my $id = 56; # Integer | the id for the Protein

eval {
    my $result = $api_instance->delProteins(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProteinsApi->delProteins: $@\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.ProteinsApi()
id = 56 # Integer | the id for the Protein (default to null)

try:
    # del Protein
    api_response = api_instance.del_proteins(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProteinsApi->delProteins: %s\n" % e)
extern crate ProteinsApi;

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

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

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

Scopes

Parameters

Query parameters
Name Description
id*
Integer
the id for the Protein
Required

Responses


getProteins

get Protein

get from Protein


/proteins

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/proteins?id=56&idBioSource=56&idDB=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProteinsApi;

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

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

        // Create an instance of the API class
        ProteinsApi apiInstance = new ProteinsApi();
        Integer id = 56; // Integer | the id for the Protein
        Integer idBioSource = 56; // Integer | the idBioSource for the Protein
        Integer idDB = 56; // Integer | the idDB for the Protein

        try {
            ProteinsResponse result = apiInstance.getProteins(id, idBioSource, idDB);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProteinsApi#getProteins");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProteinsApi;

public class ProteinsApiExample {
    public static void main(String[] args) {
        ProteinsApi apiInstance = new ProteinsApi();
        Integer id = 56; // Integer | the id for the Protein
        Integer idBioSource = 56; // Integer | the idBioSource for the Protein
        Integer idDB = 56; // Integer | the idDB for the Protein

        try {
            ProteinsResponse result = apiInstance.getProteins(id, idBioSource, idDB);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProteinsApi#getProteins");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProteinsApi *apiInstance = [[ProteinsApi alloc] init];
Integer *id = 56; // the id for the Protein (optional) (default to null)
Integer *idBioSource = 56; // the idBioSource for the Protein (optional) (default to null)
Integer *idDB = 56; // the idDB for the Protein (optional) (default to null)

// get Protein
[apiInstance getProteinsWith:id
    idBioSource:idBioSource
    idDB:idDB
              completionHandler: ^(ProteinsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.ProteinsApi()
var opts = {
  'id': 56, // {Integer} the id for the Protein
  'idBioSource': 56, // {Integer} the idBioSource for the Protein
  'idDB': 56 // {Integer} the idDB for the Protein
};

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

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

            // Create an instance of the API class
            var apiInstance = new ProteinsApi();
            var id = 56;  // Integer | the id for the Protein (optional)  (default to null)
            var idBioSource = 56;  // Integer | the idBioSource for the Protein (optional)  (default to null)
            var idDB = 56;  // Integer | the idDB for the Protein (optional)  (default to null)

            try {
                // get Protein
                ProteinsResponse result = apiInstance.getProteins(id, idBioSource, idDB);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProteinsApi.getProteins: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProteinsApi();
$id = 56; // Integer | the id for the Protein
$idBioSource = 56; // Integer | the idBioSource for the Protein
$idDB = 56; // Integer | the idDB for the Protein

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProteinsApi->new();
my $id = 56; # Integer | the id for the Protein
my $idBioSource = 56; # Integer | the idBioSource for the Protein
my $idDB = 56; # Integer | the idDB for the Protein

eval {
    my $result = $api_instance->getProteins(id => $id, idBioSource => $idBioSource, idDB => $idDB);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProteinsApi->getProteins: $@\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.ProteinsApi()
id = 56 # Integer | the id for the Protein (optional) (default to null)
idBioSource = 56 # Integer | the idBioSource for the Protein (optional) (default to null)
idDB = 56 # Integer | the idDB for the Protein (optional) (default to null)

try:
    # get Protein
    api_response = api_instance.get_proteins(id=id, idBioSource=idBioSource, idDB=idDB)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProteinsApi->getProteins: %s\n" % e)
extern crate ProteinsApi;

pub fn main() {
    let id = 56; // Integer
    let idBioSource = 56; // Integer
    let idDB = 56; // Integer

    let mut context = ProteinsApi::Context::default();
    let result = client.getProteins(id, idBioSource, idDB, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
id
Integer
the id for the Protein
idBioSource
Integer
the idBioSource for the Protein
idDB
Integer
the idDB for the Protein

Responses


updateProteins

update Protein

update for Protein


/proteins

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/proteins" \
 -d 'null'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProteinsApi;

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

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

        // Create an instance of the API class
        ProteinsApi apiInstance = new ProteinsApi();
        array[ProteinsResponse] proteinsResponse = ; // array[ProteinsResponse] | 

        try {
            ProteinsResponse result = apiInstance.updateProteins(proteinsResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProteinsApi#updateProteins");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProteinsApi;

public class ProteinsApiExample {
    public static void main(String[] args) {
        ProteinsApi apiInstance = new ProteinsApi();
        array[ProteinsResponse] proteinsResponse = ; // array[ProteinsResponse] | 

        try {
            ProteinsResponse result = apiInstance.updateProteins(proteinsResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProteinsApi#updateProteins");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProteinsApi *apiInstance = [[ProteinsApi alloc] init];
array[ProteinsResponse] *proteinsResponse = ; //  (optional)

// update Protein
[apiInstance updateProteinsWith:proteinsResponse
              completionHandler: ^(ProteinsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.ProteinsApi()
var opts = {
  'proteinsResponse':  // {array[ProteinsResponse]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new ProteinsApi();
            var proteinsResponse = new array[ProteinsResponse](); // array[ProteinsResponse] |  (optional) 

            try {
                // update Protein
                ProteinsResponse result = apiInstance.updateProteins(proteinsResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProteinsApi.updateProteins: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProteinsApi();
$proteinsResponse = ; // array[ProteinsResponse] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProteinsApi->new();
my $proteinsResponse = [WWW::OPenAPIClient::Object::array[ProteinsResponse]->new()]; # array[ProteinsResponse] | 

eval {
    my $result = $api_instance->updateProteins(proteinsResponse => $proteinsResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProteinsApi->updateProteins: $@\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.ProteinsApi()
proteinsResponse =  # array[ProteinsResponse] |  (optional)

try:
    # update Protein
    api_response = api_instance.update_proteins(proteinsResponse=proteinsResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProteinsApi->updateProteins: %s\n" % e)
extern crate ProteinsApi;

pub fn main() {
    let proteinsResponse = ; // array[ProteinsResponse]

    let mut context = ProteinsApi::Context::default();
    let result = client.updateProteins(proteinsResponse, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
proteinsResponse

Responses


Reactions

addReactions

add Reaction

addReaction for Reaction


/reactions

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/reactions" \
 -d 'null'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ReactionsApi;

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

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

        // Create an instance of the API class
        ReactionsApi apiInstance = new ReactionsApi();
        array[ReactionsResponse] reactionsResponse = ; // array[ReactionsResponse] | 

        try {
            ReactionsResponse result = apiInstance.addReactions(reactionsResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReactionsApi#addReactions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ReactionsApi;

public class ReactionsApiExample {
    public static void main(String[] args) {
        ReactionsApi apiInstance = new ReactionsApi();
        array[ReactionsResponse] reactionsResponse = ; // array[ReactionsResponse] | 

        try {
            ReactionsResponse result = apiInstance.addReactions(reactionsResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReactionsApi#addReactions");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ReactionsApi *apiInstance = [[ReactionsApi alloc] init];
array[ReactionsResponse] *reactionsResponse = ; //  (optional)

// add Reaction
[apiInstance addReactionsWith:reactionsResponse
              completionHandler: ^(ReactionsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.ReactionsApi()
var opts = {
  'reactionsResponse':  // {array[ReactionsResponse]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new ReactionsApi();
            var reactionsResponse = new array[ReactionsResponse](); // array[ReactionsResponse] |  (optional) 

            try {
                // add Reaction
                ReactionsResponse result = apiInstance.addReactions(reactionsResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReactionsApi.addReactions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReactionsApi();
$reactionsResponse = ; // array[ReactionsResponse] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReactionsApi->new();
my $reactionsResponse = [WWW::OPenAPIClient::Object::array[ReactionsResponse]->new()]; # array[ReactionsResponse] | 

eval {
    my $result = $api_instance->addReactions(reactionsResponse => $reactionsResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReactionsApi->addReactions: $@\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.ReactionsApi()
reactionsResponse =  # array[ReactionsResponse] |  (optional)

try:
    # add Reaction
    api_response = api_instance.add_reactions(reactionsResponse=reactionsResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReactionsApi->addReactions: %s\n" % e)
extern crate ReactionsApi;

pub fn main() {
    let reactionsResponse = ; // array[ReactionsResponse]

    let mut context = ReactionsApi::Context::default();
    let result = client.addReactions(reactionsResponse, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
reactionsResponse

Responses


countReactions

count ligns Reactions

get the number of reactions for one biosource


/reactions/count

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/reactions/count?idBioSource=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ReactionsApi;

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

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

        // Create an instance of the API class
        ReactionsApi apiInstance = new ReactionsApi();
        Integer idBioSource = 56; // Integer | the idBioSource for the reactions

        try {
            CountResponse result = apiInstance.countReactions(idBioSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReactionsApi#countReactions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ReactionsApi;

public class ReactionsApiExample {
    public static void main(String[] args) {
        ReactionsApi apiInstance = new ReactionsApi();
        Integer idBioSource = 56; // Integer | the idBioSource for the reactions

        try {
            CountResponse result = apiInstance.countReactions(idBioSource);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReactionsApi#countReactions");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ReactionsApi *apiInstance = [[ReactionsApi alloc] init];
Integer *idBioSource = 56; // the idBioSource for the reactions (default to null)

// count ligns Reactions
[apiInstance countReactionsWith:idBioSource
              completionHandler: ^(CountResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.ReactionsApi()
var idBioSource = 56; // {Integer} the idBioSource for the reactions

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

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

            // Create an instance of the API class
            var apiInstance = new ReactionsApi();
            var idBioSource = 56;  // Integer | the idBioSource for the reactions (default to null)

            try {
                // count ligns Reactions
                CountResponse result = apiInstance.countReactions(idBioSource);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReactionsApi.countReactions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReactionsApi();
$idBioSource = 56; // Integer | the idBioSource for the reactions

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReactionsApi->new();
my $idBioSource = 56; # Integer | the idBioSource for the reactions

eval {
    my $result = $api_instance->countReactions(idBioSource => $idBioSource);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReactionsApi->countReactions: $@\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.ReactionsApi()
idBioSource = 56 # Integer | the idBioSource for the reactions (default to null)

try:
    # count ligns Reactions
    api_response = api_instance.count_reactions(idBioSource)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReactionsApi->countReactions: %s\n" % e)
extern crate ReactionsApi;

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

    let mut context = ReactionsApi::Context::default();
    let result = client.countReactions(idBioSource, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
idBioSource*
Integer
the idBioSource for the reactions
Required

Responses


delReactions

delete Reaction

deleteReaction for Reaction


/reactions

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/reactions?id=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ReactionsApi;

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

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

        // Create an instance of the API class
        ReactionsApi apiInstance = new ReactionsApi();
        Integer id = 56; // Integer | the id for the Reaction

        try {
            ReactionsResponse result = apiInstance.delReactions(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReactionsApi#delReactions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ReactionsApi;

public class ReactionsApiExample {
    public static void main(String[] args) {
        ReactionsApi apiInstance = new ReactionsApi();
        Integer id = 56; // Integer | the id for the Reaction

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


// Create an instance of the API class
ReactionsApi *apiInstance = [[ReactionsApi alloc] init];
Integer *id = 56; // the id for the Reaction (default to null)

// delete Reaction
[apiInstance delReactionsWith:id
              completionHandler: ^(ReactionsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.ReactionsApi()
var id = 56; // {Integer} the id for the Reaction

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

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

            // Create an instance of the API class
            var apiInstance = new ReactionsApi();
            var id = 56;  // Integer | the id for the Reaction (default to null)

            try {
                // delete Reaction
                ReactionsResponse result = apiInstance.delReactions(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReactionsApi.delReactions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReactionsApi();
$id = 56; // Integer | the id for the Reaction

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReactionsApi->new();
my $id = 56; # Integer | the id for the Reaction

eval {
    my $result = $api_instance->delReactions(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReactionsApi->delReactions: $@\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.ReactionsApi()
id = 56 # Integer | the id for the Reaction (default to null)

try:
    # delete Reaction
    api_response = api_instance.del_reactions(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReactionsApi->delReactions: %s\n" % e)
extern crate ReactionsApi;

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

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

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

Scopes

Parameters

Query parameters
Name Description
id*
Integer
the id for the Reaction
Required

Responses


getReactions

get Reaction

getReaction from Reaction


/reactions

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/reactions?id=56&idBioSource=56&idDB=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ReactionsApi;

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

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

        // Create an instance of the API class
        ReactionsApi apiInstance = new ReactionsApi();
        Integer id = 56; // Integer | the id for the Reaction
        Integer idBioSource = 56; // Integer | the idbiosource for the Reaction
        Integer idDB = 56; // Integer | the idDB for the Reaction

        try {
            ReactionsResponse result = apiInstance.getReactions(id, idBioSource, idDB);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReactionsApi#getReactions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ReactionsApi;

public class ReactionsApiExample {
    public static void main(String[] args) {
        ReactionsApi apiInstance = new ReactionsApi();
        Integer id = 56; // Integer | the id for the Reaction
        Integer idBioSource = 56; // Integer | the idbiosource for the Reaction
        Integer idDB = 56; // Integer | the idDB for the Reaction

        try {
            ReactionsResponse result = apiInstance.getReactions(id, idBioSource, idDB);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReactionsApi#getReactions");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ReactionsApi *apiInstance = [[ReactionsApi alloc] init];
Integer *id = 56; // the id for the Reaction (optional) (default to null)
Integer *idBioSource = 56; // the idbiosource for the Reaction (optional) (default to null)
Integer *idDB = 56; // the idDB for the Reaction (optional) (default to null)

// get Reaction
[apiInstance getReactionsWith:id
    idBioSource:idBioSource
    idDB:idDB
              completionHandler: ^(ReactionsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.ReactionsApi()
var opts = {
  'id': 56, // {Integer} the id for the Reaction
  'idBioSource': 56, // {Integer} the idbiosource for the Reaction
  'idDB': 56 // {Integer} the idDB for the Reaction
};

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

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

            // Create an instance of the API class
            var apiInstance = new ReactionsApi();
            var id = 56;  // Integer | the id for the Reaction (optional)  (default to null)
            var idBioSource = 56;  // Integer | the idbiosource for the Reaction (optional)  (default to null)
            var idDB = 56;  // Integer | the idDB for the Reaction (optional)  (default to null)

            try {
                // get Reaction
                ReactionsResponse result = apiInstance.getReactions(id, idBioSource, idDB);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReactionsApi.getReactions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReactionsApi();
$id = 56; // Integer | the id for the Reaction
$idBioSource = 56; // Integer | the idbiosource for the Reaction
$idDB = 56; // Integer | the idDB for the Reaction

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReactionsApi->new();
my $id = 56; # Integer | the id for the Reaction
my $idBioSource = 56; # Integer | the idbiosource for the Reaction
my $idDB = 56; # Integer | the idDB for the Reaction

eval {
    my $result = $api_instance->getReactions(id => $id, idBioSource => $idBioSource, idDB => $idDB);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReactionsApi->getReactions: $@\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.ReactionsApi()
id = 56 # Integer | the id for the Reaction (optional) (default to null)
idBioSource = 56 # Integer | the idbiosource for the Reaction (optional) (default to null)
idDB = 56 # Integer | the idDB for the Reaction (optional) (default to null)

try:
    # get Reaction
    api_response = api_instance.get_reactions(id=id, idBioSource=idBioSource, idDB=idDB)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReactionsApi->getReactions: %s\n" % e)
extern crate ReactionsApi;

pub fn main() {
    let id = 56; // Integer
    let idBioSource = 56; // Integer
    let idDB = 56; // Integer

    let mut context = ReactionsApi::Context::default();
    let result = client.getReactions(id, idBioSource, idDB, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
id
Integer
the id for the Reaction
idBioSource
Integer
the idbiosource for the Reaction
idDB
Integer
the idDB for the Reaction

Responses


updateReactions

update Reaction

updateReaction for Reaction


/reactions

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://metexplore.toulouse.inrae.fr/metexplore3-api/v0.1/reactions" \
 -d 'null'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ReactionsApi;

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

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

        // Create an instance of the API class
        ReactionsApi apiInstance = new ReactionsApi();
        array[ReactionsResponse] reactionsResponse = ; // array[ReactionsResponse] | 

        try {
            ReactionsResponse result = apiInstance.updateReactions(reactionsResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReactionsApi#updateReactions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ReactionsApi;

public class ReactionsApiExample {
    public static void main(String[] args) {
        ReactionsApi apiInstance = new ReactionsApi();
        array[ReactionsResponse] reactionsResponse = ; // array[ReactionsResponse] | 

        try {
            ReactionsResponse result = apiInstance.updateReactions(reactionsResponse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReactionsApi#updateReactions");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ReactionsApi *apiInstance = [[ReactionsApi alloc] init];
array[ReactionsResponse] *reactionsResponse = ; //  (optional)

// update Reaction
[apiInstance updateReactionsWith:reactionsResponse
              completionHandler: ^(ReactionsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var MetExplore3RestApi = require('met_explore_3_rest_api');

// Create an instance of the API class
var api = new MetExplore3RestApi.ReactionsApi()
var opts = {
  'reactionsResponse':  // {array[ReactionsResponse]} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new ReactionsApi();
            var reactionsResponse = new array[ReactionsResponse](); // array[ReactionsResponse] |  (optional) 

            try {
                // update Reaction
                ReactionsResponse result = apiInstance.updateReactions(reactionsResponse);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReactionsApi.updateReactions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReactionsApi();
$reactionsResponse = ; // array[ReactionsResponse] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReactionsApi->new();
my $reactionsResponse = [WWW::OPenAPIClient::Object::array[ReactionsResponse]->new()]; # array[ReactionsResponse] | 

eval {
    my $result = $api_instance->updateReactions(reactionsResponse => $reactionsResponse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReactionsApi->updateReactions: $@\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.ReactionsApi()
reactionsResponse =  # array[ReactionsResponse] |  (optional)

try:
    # update Reaction
    api_response = api_instance.update_reactions(reactionsResponse=reactionsResponse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReactionsApi->updateReactions: %s\n" % e)