GraphScope FLEX HTTP SERVICE API

Alert

createAlertReceiver

Create a new alert receiver

/api/v1/alert/receiver

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/alert/receiver" \
 -d '{
  "webhook_url" : "webhook_url",
  "is_at_all" : true,
  "enable" : true,
  "at_user_ids" : [ "at_user_ids", "at_user_ids" ],
  "type" : "webhook"
}'

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

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

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

        // Create an instance of the API class
        AlertApi apiInstance = new AlertApi();
        CreateAlertReceiverRequest createAlertReceiverRequest = ; // CreateAlertReceiverRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateAlertReceiverRequest createAlertReceiverRequest = new CreateAlertReceiverRequest(); // CreateAlertReceiverRequest | 

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

import org.openapitools.client.api.AlertApi;

public class AlertApiExample {
    public static void main(String[] args) {
        AlertApi apiInstance = new AlertApi();
        CreateAlertReceiverRequest createAlertReceiverRequest = ; // CreateAlertReceiverRequest | 

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



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

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.AlertApi()
var createAlertReceiverRequest = ; // {CreateAlertReceiverRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AlertApi();
            var createAlertReceiverRequest = new CreateAlertReceiverRequest(); // CreateAlertReceiverRequest | 

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AlertApi();
$createAlertReceiverRequest = ; // CreateAlertReceiverRequest | 

try {
    $result = $api_instance->createAlertReceiver($createAlertReceiverRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AlertApi->createAlertReceiver: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AlertApi->new();
my $createAlertReceiverRequest = WWW::OPenAPIClient::Object::CreateAlertReceiverRequest->new(); # CreateAlertReceiverRequest | 

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

try:
    api_response = api_instance.create_alert_receiver(createAlertReceiverRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AlertApi->createAlertReceiver: %s\n" % e)

extern crate AlertApi;

pub fn main() {
    let createAlertReceiverRequest = ; // CreateAlertReceiverRequest

    let mut context = AlertApi::Context::default();
    let result = client.createAlertReceiver(createAlertReceiverRequest, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
createAlertReceiverRequest *

Responses

Schema

Schema

delete alert rule by ID

/api/v1/alert/rule/{rule_id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/api/v1/alert/rule/{rule_id}"

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

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

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

        // Create an instance of the API class
        AlertApi apiInstance = new AlertApi();
        String ruleId = ruleId_example; // String | 

        try {
            'String' result = apiInstance.delete alert rule by ID(ruleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#delete alert rule by ID");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.delete alert rule by ID(ruleId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->delete alert rule by ID: $e\n');
}

import org.openapitools.client.api.AlertApi;

public class AlertApiExample {
    public static void main(String[] args) {
        AlertApi apiInstance = new AlertApi();
        String ruleId = ruleId_example; // String | 

        try {
            'String' result = apiInstance.delete alert rule by ID(ruleId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#delete alert rule by ID");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AlertApi *apiInstance = [[AlertApi alloc] init];
String *ruleId = ruleId_example; //  (default to null)

[apiInstance delete alert rule by IDWith:ruleId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.AlertApi()
var ruleId = ruleId_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.delete alert rule by ID(ruleId, callback);

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

namespace Example
{
    public class delete alert rule by IDExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AlertApi();
            var ruleId = ruleId_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.delete alert rule by ID(ruleId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AlertApi.delete alert rule by ID: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AlertApi();
$ruleId = ruleId_example; // String | 

try {
    $result = $api_instance->delete alert rule by ID($ruleId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AlertApi->delete alert rule by ID: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AlertApi->new();
my $ruleId = ruleId_example; # String | 

eval {
    my $result = $api_instance->delete alert rule by ID(ruleId => $ruleId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AlertApi->delete alert rule by ID: $@\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.AlertApi()
ruleId = ruleId_example # String |  (default to null)

try:
    api_response = api_instance.delete_alert_rule_by_id(ruleId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AlertApi->delete alert rule by ID: %s\n" % e)

extern crate AlertApi;

pub fn main() {
    let ruleId = ruleId_example; // String

    let mut context = AlertApi::Context::default();
    let result = client.delete alert rule by ID(ruleId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
rule_id*	String Required

Responses

Schema

Schema

deleteAlertMessageInBatch

Delete alert message in batch

/api/v1/alert/message-collection

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/api/v1/alert/message-collection?message_ids=messageIds_example"

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

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

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

        // Create an instance of the API class
        AlertApi apiInstance = new AlertApi();
        String messageIds = messageIds_example; // String | A list of message id separated by comma, e.g. id1,id2,id3

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String messageIds = new String(); // String | A list of message id separated by comma, e.g. id1,id2,id3

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

import org.openapitools.client.api.AlertApi;

public class AlertApiExample {
    public static void main(String[] args) {
        AlertApi apiInstance = new AlertApi();
        String messageIds = messageIds_example; // String | A list of message id separated by comma, e.g. id1,id2,id3

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



// Create an instance of the API class
AlertApi *apiInstance = [[AlertApi alloc] init];
String *messageIds = messageIds_example; // A list of message id separated by comma, e.g. id1,id2,id3 (default to null)

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.AlertApi()
var messageIds = messageIds_example; // {String} A list of message id separated by comma, e.g. id1,id2,id3

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

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

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

            // Create an instance of the API class
            var apiInstance = new AlertApi();
            var messageIds = messageIds_example;  // String | A list of message id separated by comma, e.g. id1,id2,id3 (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AlertApi();
$messageIds = messageIds_example; // String | A list of message id separated by comma, e.g. id1,id2,id3

try {
    $result = $api_instance->deleteAlertMessageInBatch($messageIds);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AlertApi->deleteAlertMessageInBatch: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AlertApi->new();
my $messageIds = messageIds_example; # String | A list of message id separated by comma, e.g. id1,id2,id3

eval {
    my $result = $api_instance->deleteAlertMessageInBatch(messageIds => $messageIds);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AlertApi->deleteAlertMessageInBatch: $@\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.AlertApi()
messageIds = messageIds_example # String | A list of message id separated by comma, e.g. id1,id2,id3 (default to null)

try:
    api_response = api_instance.delete_alert_message_in_batch(messageIds)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AlertApi->deleteAlertMessageInBatch: %s\n" % e)

extern crate AlertApi;

pub fn main() {
    let messageIds = messageIds_example; // String

    let mut context = AlertApi::Context::default();
    let result = client.deleteAlertMessageInBatch(messageIds, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
message_ids*	String A list of message id separated by comma, e.g. id1,id2,id3 Required

Responses

Schema

Schema

deleteAlertReceiverById

Delete the alert receiver by ID

/api/v1/alert/receiver/{receiver_id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/api/v1/alert/receiver/{receiver_id}"

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

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

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

        // Create an instance of the API class
        AlertApi apiInstance = new AlertApi();
        String receiverId = receiverId_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AlertApi;

public class AlertApiExample {
    public static void main(String[] args) {
        AlertApi apiInstance = new AlertApi();
        String receiverId = receiverId_example; // String | 

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



// Create an instance of the API class
AlertApi *apiInstance = [[AlertApi alloc] init];
String *receiverId = receiverId_example; //  (default to null)

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.AlertApi()
var receiverId = receiverId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new AlertApi();
            var receiverId = receiverId_example;  // String |  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AlertApi();
$receiverId = receiverId_example; // String | 

try {
    $result = $api_instance->deleteAlertReceiverById($receiverId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AlertApi->deleteAlertReceiverById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AlertApi->new();
my $receiverId = receiverId_example; # String | 

eval {
    my $result = $api_instance->deleteAlertReceiverById(receiverId => $receiverId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AlertApi->deleteAlertReceiverById: $@\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.AlertApi()
receiverId = receiverId_example # String |  (default to null)

try:
    api_response = api_instance.delete_alert_receiver_by_id(receiverId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AlertApi->deleteAlertReceiverById: %s\n" % e)

extern crate AlertApi;

pub fn main() {
    let receiverId = receiverId_example; // String

    let mut context = AlertApi::Context::default();
    let result = client.deleteAlertReceiverById(receiverId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
receiver_id*	String Required

Responses

Schema

Schema

listAlertMessages

List all alert messages

/api/v1/alert/message

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/alert/message?alert_type=alertType_example&status=status_example&severity=severity_example&start_time=startTime_example&end_time=endTime_example&limit=56"

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

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

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

        // Create an instance of the API class
        AlertApi apiInstance = new AlertApi();
        String alertType = alertType_example; // String | 
        String status = status_example; // String | 
        String severity = severity_example; // String | 
        String startTime = startTime_example; // String | format with "2023-02-21-11-56-30"
        String endTime = endTime_example; // String | format with "2023-02-21-11-56-30"
        Integer limit = 56; // Integer | 

        try {
            array[GetAlertMessageResponse] result = apiInstance.listAlertMessages(alertType, status, severity, startTime, endTime, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#listAlertMessages");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String alertType = new String(); // String | 
final String status = new String(); // String | 
final String severity = new String(); // String | 
final String startTime = new String(); // String | format with "2023-02-21-11-56-30"
final String endTime = new String(); // String | format with "2023-02-21-11-56-30"
final Integer limit = new Integer(); // Integer | 

try {
    final result = await api_instance.listAlertMessages(alertType, status, severity, startTime, endTime, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listAlertMessages: $e\n');
}

import org.openapitools.client.api.AlertApi;

public class AlertApiExample {
    public static void main(String[] args) {
        AlertApi apiInstance = new AlertApi();
        String alertType = alertType_example; // String | 
        String status = status_example; // String | 
        String severity = severity_example; // String | 
        String startTime = startTime_example; // String | format with "2023-02-21-11-56-30"
        String endTime = endTime_example; // String | format with "2023-02-21-11-56-30"
        Integer limit = 56; // Integer | 

        try {
            array[GetAlertMessageResponse] result = apiInstance.listAlertMessages(alertType, status, severity, startTime, endTime, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#listAlertMessages");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AlertApi *apiInstance = [[AlertApi alloc] init];
String *alertType = alertType_example; //  (optional) (default to null)
String *status = status_example; //  (optional) (default to null)
String *severity = severity_example; //  (optional) (default to null)
String *startTime = startTime_example; // format with "2023-02-21-11-56-30" (optional) (default to null)
String *endTime = endTime_example; // format with "2023-02-21-11-56-30" (optional) (default to null)
Integer *limit = 56; //  (optional) (default to null)

[apiInstance listAlertMessagesWith:alertType
    status:status
    severity:severity
    startTime:startTime
    endTime:endTime
    limit:limit
              completionHandler: ^(array[GetAlertMessageResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.AlertApi()
var opts = {
  'alertType': alertType_example, // {String} 
  'status': status_example, // {String} 
  'severity': severity_example, // {String} 
  'startTime': startTime_example, // {String} format with "2023-02-21-11-56-30"
  'endTime': endTime_example, // {String} format with "2023-02-21-11-56-30"
  'limit': 56 // {Integer} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AlertApi();
            var alertType = alertType_example;  // String |  (optional)  (default to null)
            var status = status_example;  // String |  (optional)  (default to null)
            var severity = severity_example;  // String |  (optional)  (default to null)
            var startTime = startTime_example;  // String | format with "2023-02-21-11-56-30" (optional)  (default to null)
            var endTime = endTime_example;  // String | format with "2023-02-21-11-56-30" (optional)  (default to null)
            var limit = 56;  // Integer |  (optional)  (default to null)

            try {
                array[GetAlertMessageResponse] result = apiInstance.listAlertMessages(alertType, status, severity, startTime, endTime, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AlertApi.listAlertMessages: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AlertApi();
$alertType = alertType_example; // String | 
$status = status_example; // String | 
$severity = severity_example; // String | 
$startTime = startTime_example; // String | format with "2023-02-21-11-56-30"
$endTime = endTime_example; // String | format with "2023-02-21-11-56-30"
$limit = 56; // Integer | 

try {
    $result = $api_instance->listAlertMessages($alertType, $status, $severity, $startTime, $endTime, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AlertApi->listAlertMessages: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AlertApi->new();
my $alertType = alertType_example; # String | 
my $status = status_example; # String | 
my $severity = severity_example; # String | 
my $startTime = startTime_example; # String | format with "2023-02-21-11-56-30"
my $endTime = endTime_example; # String | format with "2023-02-21-11-56-30"
my $limit = 56; # Integer | 

eval {
    my $result = $api_instance->listAlertMessages(alertType => $alertType, status => $status, severity => $severity, startTime => $startTime, endTime => $endTime, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AlertApi->listAlertMessages: $@\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.AlertApi()
alertType = alertType_example # String |  (optional) (default to null)
status = status_example # String |  (optional) (default to null)
severity = severity_example # String |  (optional) (default to null)
startTime = startTime_example # String | format with "2023-02-21-11-56-30" (optional) (default to null)
endTime = endTime_example # String | format with "2023-02-21-11-56-30" (optional) (default to null)
limit = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.list_alert_messages(alertType=alertType, status=status, severity=severity, startTime=startTime, endTime=endTime, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AlertApi->listAlertMessages: %s\n" % e)

extern crate AlertApi;

pub fn main() {
    let alertType = alertType_example; // String
    let status = status_example; // String
    let severity = severity_example; // String
    let startTime = startTime_example; // String
    let endTime = endTime_example; // String
    let limit = 56; // Integer

    let mut context = AlertApi::Context::default();
    let result = client.listAlertMessages(alertType, status, severity, startTime, endTime, limit, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
alert_type	String
status	String
severity	String
start_time	String format with "2023-02-21-11-56-30"
end_time	String format with "2023-02-21-11-56-30"
limit	Integer (int32)

Responses

Schema

Schema

listAlertReceivers

List all alert receivers

/api/v1/alert/receiver

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/alert/receiver"

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

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

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

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

        try {
            array[GetAlertReceiverResponse] result = apiInstance.listAlertReceivers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#listAlertReceivers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AlertApi;

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

        try {
            array[GetAlertReceiverResponse] result = apiInstance.listAlertReceivers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#listAlertReceivers");
            e.printStackTrace();
        }
    }
}



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

[apiInstance listAlertReceiversWithCompletionHandler: 
              ^(array[GetAlertReceiverResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.AlertApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listAlertReceivers(callback);

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

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

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

            try {
                array[GetAlertReceiverResponse] result = apiInstance.listAlertReceivers();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AlertApi.listAlertReceivers: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.list_alert_receivers()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AlertApi->listAlertReceivers: %s\n" % e)

extern crate AlertApi;

pub fn main() {

    let mut context = AlertApi::Context::default();
    let result = client.listAlertReceivers(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

listAlertRules

List all alert rules

/api/v1/alert/rule

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/alert/rule"

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

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

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

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

        try {
            array[GetAlertRuleResponse] result = apiInstance.listAlertRules();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#listAlertRules");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AlertApi;

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

        try {
            array[GetAlertRuleResponse] result = apiInstance.listAlertRules();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#listAlertRules");
            e.printStackTrace();
        }
    }
}



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

[apiInstance listAlertRulesWithCompletionHandler: 
              ^(array[GetAlertRuleResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.AlertApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listAlertRules(callback);

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

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

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

            try {
                array[GetAlertRuleResponse] result = apiInstance.listAlertRules();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AlertApi.listAlertRules: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.list_alert_rules()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AlertApi->listAlertRules: %s\n" % e)

extern crate AlertApi;

pub fn main() {

    let mut context = AlertApi::Context::default();
    let result = client.listAlertRules(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

update alert rule by ID

/api/v1/alert/rule/{rule_id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/alert/rule/{rule_id}" \
 -d '{
  "severity" : "warning",
  "conditions_description" : "conditions_description",
  "enable" : true,
  "name" : "name",
  "metric_type" : "node",
  "frequency" : 0
}'

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

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

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

        // Create an instance of the API class
        AlertApi apiInstance = new AlertApi();
        String ruleId = ruleId_example; // String | 
        CreateAlertRuleRequest createAlertRuleRequest = ; // CreateAlertRuleRequest | 

        try {
            'String' result = apiInstance.update alert rule by ID(ruleId, createAlertRuleRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#update alert rule by ID");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String ruleId = new String(); // String | 
final CreateAlertRuleRequest createAlertRuleRequest = new CreateAlertRuleRequest(); // CreateAlertRuleRequest | 

try {
    final result = await api_instance.update alert rule by ID(ruleId, createAlertRuleRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->update alert rule by ID: $e\n');
}

import org.openapitools.client.api.AlertApi;

public class AlertApiExample {
    public static void main(String[] args) {
        AlertApi apiInstance = new AlertApi();
        String ruleId = ruleId_example; // String | 
        CreateAlertRuleRequest createAlertRuleRequest = ; // CreateAlertRuleRequest | 

        try {
            'String' result = apiInstance.update alert rule by ID(ruleId, createAlertRuleRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#update alert rule by ID");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AlertApi *apiInstance = [[AlertApi alloc] init];
String *ruleId = ruleId_example; //  (default to null)
CreateAlertRuleRequest *createAlertRuleRequest = ; //  (optional)

[apiInstance update alert rule by IDWith:ruleId
    createAlertRuleRequest:createAlertRuleRequest
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.AlertApi()
var ruleId = ruleId_example; // {String} 
var opts = {
  'createAlertRuleRequest':  // {CreateAlertRuleRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.update alert rule by ID(ruleId, opts, callback);

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

namespace Example
{
    public class update alert rule by IDExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new AlertApi();
            var ruleId = ruleId_example;  // String |  (default to null)
            var createAlertRuleRequest = new CreateAlertRuleRequest(); // CreateAlertRuleRequest |  (optional) 

            try {
                'String' result = apiInstance.update alert rule by ID(ruleId, createAlertRuleRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AlertApi.update alert rule by ID: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AlertApi();
$ruleId = ruleId_example; // String | 
$createAlertRuleRequest = ; // CreateAlertRuleRequest | 

try {
    $result = $api_instance->update alert rule by ID($ruleId, $createAlertRuleRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AlertApi->update alert rule by ID: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AlertApi->new();
my $ruleId = ruleId_example; # String | 
my $createAlertRuleRequest = WWW::OPenAPIClient::Object::CreateAlertRuleRequest->new(); # CreateAlertRuleRequest | 

eval {
    my $result = $api_instance->update alert rule by ID(ruleId => $ruleId, createAlertRuleRequest => $createAlertRuleRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AlertApi->update alert rule by ID: $@\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.AlertApi()
ruleId = ruleId_example # String |  (default to null)
createAlertRuleRequest =  # CreateAlertRuleRequest |  (optional)

try:
    api_response = api_instance.update_alert_rule_by_id(ruleId, createAlertRuleRequest=createAlertRuleRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AlertApi->update alert rule by ID: %s\n" % e)

extern crate AlertApi;

pub fn main() {
    let ruleId = ruleId_example; // String
    let createAlertRuleRequest = ; // CreateAlertRuleRequest

    let mut context = AlertApi::Context::default();
    let result = client.update alert rule by ID(ruleId, createAlertRuleRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
rule_id*	String Required

Body parameters

Name	Description
createAlertRuleRequest

Responses

Schema

Schema

updateAlertMessageInBatch

Update the message status in batch

/api/v1/alert/message-collection/status

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/alert/message-collection/status" \
 -d '{
  "message_ids" : [ "message_ids", "message_ids" ],
  "status" : "unsolved"
}'

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

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

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

        // Create an instance of the API class
        AlertApi apiInstance = new AlertApi();
        UpdateAlertMessageStatusRequest updateAlertMessageStatusRequest = ; // UpdateAlertMessageStatusRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpdateAlertMessageStatusRequest updateAlertMessageStatusRequest = new UpdateAlertMessageStatusRequest(); // UpdateAlertMessageStatusRequest | 

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

import org.openapitools.client.api.AlertApi;

public class AlertApiExample {
    public static void main(String[] args) {
        AlertApi apiInstance = new AlertApi();
        UpdateAlertMessageStatusRequest updateAlertMessageStatusRequest = ; // UpdateAlertMessageStatusRequest | 

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



// Create an instance of the API class
AlertApi *apiInstance = [[AlertApi alloc] init];
UpdateAlertMessageStatusRequest *updateAlertMessageStatusRequest = ; //  (optional)

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.AlertApi()
var opts = {
  'updateAlertMessageStatusRequest':  // {UpdateAlertMessageStatusRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AlertApi();
            var updateAlertMessageStatusRequest = new UpdateAlertMessageStatusRequest(); // UpdateAlertMessageStatusRequest |  (optional) 

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AlertApi();
$updateAlertMessageStatusRequest = ; // UpdateAlertMessageStatusRequest | 

try {
    $result = $api_instance->updateAlertMessageInBatch($updateAlertMessageStatusRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AlertApi->updateAlertMessageInBatch: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AlertApi->new();
my $updateAlertMessageStatusRequest = WWW::OPenAPIClient::Object::UpdateAlertMessageStatusRequest->new(); # UpdateAlertMessageStatusRequest | 

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

try:
    api_response = api_instance.update_alert_message_in_batch(updateAlertMessageStatusRequest=updateAlertMessageStatusRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AlertApi->updateAlertMessageInBatch: %s\n" % e)

extern crate AlertApi;

pub fn main() {
    let updateAlertMessageStatusRequest = ; // UpdateAlertMessageStatusRequest

    let mut context = AlertApi::Context::default();
    let result = client.updateAlertMessageInBatch(updateAlertMessageStatusRequest, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
updateAlertMessageStatusRequest

Responses

Schema

Schema

updateAlertReceiverById

Update alert receiver by ID

/api/v1/alert/receiver/{receiver_id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/alert/receiver/{receiver_id}" \
 -d '{
  "webhook_url" : "webhook_url",
  "is_at_all" : true,
  "enable" : true,
  "at_user_ids" : [ "at_user_ids", "at_user_ids" ],
  "type" : "webhook"
}'

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

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

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

        // Create an instance of the API class
        AlertApi apiInstance = new AlertApi();
        String receiverId = receiverId_example; // String | 
        CreateAlertReceiverRequest createAlertReceiverRequest = ; // CreateAlertReceiverRequest | 

        try {
            'String' result = apiInstance.updateAlertReceiverById(receiverId, createAlertReceiverRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#updateAlertReceiverById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String receiverId = new String(); // String | 
final CreateAlertReceiverRequest createAlertReceiverRequest = new CreateAlertReceiverRequest(); // CreateAlertReceiverRequest | 

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

import org.openapitools.client.api.AlertApi;

public class AlertApiExample {
    public static void main(String[] args) {
        AlertApi apiInstance = new AlertApi();
        String receiverId = receiverId_example; // String | 
        CreateAlertReceiverRequest createAlertReceiverRequest = ; // CreateAlertReceiverRequest | 

        try {
            'String' result = apiInstance.updateAlertReceiverById(receiverId, createAlertReceiverRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AlertApi#updateAlertReceiverById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AlertApi *apiInstance = [[AlertApi alloc] init];
String *receiverId = receiverId_example; //  (default to null)
CreateAlertReceiverRequest *createAlertReceiverRequest = ; //  (optional)

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.AlertApi()
var receiverId = receiverId_example; // {String} 
var opts = {
  'createAlertReceiverRequest':  // {CreateAlertReceiverRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AlertApi();
            var receiverId = receiverId_example;  // String |  (default to null)
            var createAlertReceiverRequest = new CreateAlertReceiverRequest(); // CreateAlertReceiverRequest |  (optional) 

            try {
                'String' result = apiInstance.updateAlertReceiverById(receiverId, createAlertReceiverRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AlertApi.updateAlertReceiverById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AlertApi();
$receiverId = receiverId_example; // String | 
$createAlertReceiverRequest = ; // CreateAlertReceiverRequest | 

try {
    $result = $api_instance->updateAlertReceiverById($receiverId, $createAlertReceiverRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AlertApi->updateAlertReceiverById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AlertApi->new();
my $receiverId = receiverId_example; # String | 
my $createAlertReceiverRequest = WWW::OPenAPIClient::Object::CreateAlertReceiverRequest->new(); # CreateAlertReceiverRequest | 

eval {
    my $result = $api_instance->updateAlertReceiverById(receiverId => $receiverId, createAlertReceiverRequest => $createAlertReceiverRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AlertApi->updateAlertReceiverById: $@\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.AlertApi()
receiverId = receiverId_example # String |  (default to null)
createAlertReceiverRequest =  # CreateAlertReceiverRequest |  (optional)

try:
    api_response = api_instance.update_alert_receiver_by_id(receiverId, createAlertReceiverRequest=createAlertReceiverRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AlertApi->updateAlertReceiverById: %s\n" % e)

extern crate AlertApi;

pub fn main() {
    let receiverId = receiverId_example; // String
    let createAlertReceiverRequest = ; // CreateAlertReceiverRequest

    let mut context = AlertApi::Context::default();
    let result = client.updateAlertReceiverById(receiverId, createAlertReceiverRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
receiver_id*	String Required

Body parameters

Name	Description
createAlertReceiverRequest

Responses

Schema

Schema

DataSource

bindDatasourceInBatch

Bind data sources in batches

/api/v1/graph/{graph_id}/datasource

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/datasource" \
 -d '{
  "edge_mappings" : [ {
    "inputs" : [ "inputs", "inputs" ],
    "source_vertex_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    }, {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    } ],
    "destination_vertex_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    }, {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    } ],
    "column_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    }, {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    } ],
    "type_triplet" : {
      "edge" : "edge",
      "source_vertex" : "source_vertex",
      "destination_vertex" : "destination_vertex"
    }
  }, {
    "inputs" : [ "inputs", "inputs" ],
    "source_vertex_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    }, {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    } ],
    "destination_vertex_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    }, {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    } ],
    "column_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    }, {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    } ],
    "type_triplet" : {
      "edge" : "edge",
      "source_vertex" : "source_vertex",
      "destination_vertex" : "destination_vertex"
    }
  } ],
  "vertex_mappings" : [ {
    "type_name" : "type_name",
    "inputs" : [ "file:///path/to/file.csv", "file:///path/to/file.csv" ],
    "column_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    }, {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    } ]
  }, {
    "type_name" : "type_name",
    "inputs" : [ "file:///path/to/file.csv", "file:///path/to/file.csv" ],
    "column_mappings" : [ {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    }, {
      "column" : {
        "name" : "name",
        "index" : 0
      },
      "property" : "property"
    } ]
  } ]
}'

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

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

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

        // Create an instance of the API class
        DataSourceApi apiInstance = new DataSourceApi();
        String graphId = graphId_example; // String | 
        SchemaMapping schemaMapping = ; // SchemaMapping | 

        try {
            'String' result = apiInstance.bindDatasourceInBatch(graphId, schemaMapping);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceApi#bindDatasourceInBatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final SchemaMapping schemaMapping = new SchemaMapping(); // SchemaMapping | 

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

import org.openapitools.client.api.DataSourceApi;

public class DataSourceApiExample {
    public static void main(String[] args) {
        DataSourceApi apiInstance = new DataSourceApi();
        String graphId = graphId_example; // String | 
        SchemaMapping schemaMapping = ; // SchemaMapping | 

        try {
            'String' result = apiInstance.bindDatasourceInBatch(graphId, schemaMapping);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceApi#bindDatasourceInBatch");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DataSourceApi *apiInstance = [[DataSourceApi alloc] init];
String *graphId = graphId_example; //  (default to null)
SchemaMapping *schemaMapping = ; // 

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.DataSourceApi()
var graphId = graphId_example; // {String} 
var schemaMapping = ; // {SchemaMapping} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataSourceApi();
            var graphId = graphId_example;  // String |  (default to null)
            var schemaMapping = new SchemaMapping(); // SchemaMapping | 

            try {
                'String' result = apiInstance.bindDatasourceInBatch(graphId, schemaMapping);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataSourceApi.bindDatasourceInBatch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataSourceApi();
$graphId = graphId_example; // String | 
$schemaMapping = ; // SchemaMapping | 

try {
    $result = $api_instance->bindDatasourceInBatch($graphId, $schemaMapping);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataSourceApi->bindDatasourceInBatch: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataSourceApi->new();
my $graphId = graphId_example; # String | 
my $schemaMapping = WWW::OPenAPIClient::Object::SchemaMapping->new(); # SchemaMapping | 

eval {
    my $result = $api_instance->bindDatasourceInBatch(graphId => $graphId, schemaMapping => $schemaMapping);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceApi->bindDatasourceInBatch: $@\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.DataSourceApi()
graphId = graphId_example # String |  (default to null)
schemaMapping =  # SchemaMapping | 

try:
    api_response = api_instance.bind_datasource_in_batch(graphId, schemaMapping)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceApi->bindDatasourceInBatch: %s\n" % e)

extern crate DataSourceApi;

pub fn main() {
    let graphId = graphId_example; // String
    let schemaMapping = ; // SchemaMapping

    let mut context = DataSourceApi::Context::default();
    let result = client.bindDatasourceInBatch(graphId, schemaMapping, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
schemaMapping *

Responses

Schema

Schema

Schema

getDatasourceById

Get data source by ID

/api/v1/graph/{graph_id}/datasource

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/datasource"

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

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

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

        // Create an instance of the API class
        DataSourceApi apiInstance = new DataSourceApi();
        String graphId = graphId_example; // String | 

        try {
            SchemaMapping result = apiInstance.getDatasourceById(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceApi#getDatasourceById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.DataSourceApi;

public class DataSourceApiExample {
    public static void main(String[] args) {
        DataSourceApi apiInstance = new DataSourceApi();
        String graphId = graphId_example; // String | 

        try {
            SchemaMapping result = apiInstance.getDatasourceById(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceApi#getDatasourceById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DataSourceApi *apiInstance = [[DataSourceApi alloc] init];
String *graphId = graphId_example; //  (default to null)

[apiInstance getDatasourceByIdWith:graphId
              completionHandler: ^(SchemaMapping output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.DataSourceApi()
var graphId = graphId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataSourceApi();
            var graphId = graphId_example;  // String |  (default to null)

            try {
                SchemaMapping result = apiInstance.getDatasourceById(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataSourceApi.getDatasourceById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataSourceApi();
$graphId = graphId_example; // String | 

try {
    $result = $api_instance->getDatasourceById($graphId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataSourceApi->getDatasourceById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataSourceApi->new();
my $graphId = graphId_example; # String | 

eval {
    my $result = $api_instance->getDatasourceById(graphId => $graphId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceApi->getDatasourceById: $@\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.DataSourceApi()
graphId = graphId_example # String |  (default to null)

try:
    api_response = api_instance.get_datasource_by_id(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceApi->getDatasourceById: %s\n" % e)

extern crate DataSourceApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = DataSourceApi::Context::default();
    let result = client.getDatasourceById(graphId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Responses

Schema

Schema

unbindEdgeDatasource

Unbind datas ource on an edge type

/api/v1/graph/{graph_id}/datasource/edge/{type_name}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/datasource/edge/{type_name}?source_vertex_type=sourceVertexType_example&destination_vertex_type=destinationVertexType_example"

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

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

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

        // Create an instance of the API class
        DataSourceApi apiInstance = new DataSourceApi();
        String graphId = graphId_example; // String | 
        String typeName = typeName_example; // String | 
        String sourceVertexType = sourceVertexType_example; // String | 
        String destinationVertexType = destinationVertexType_example; // String | 

        try {
            'String' result = apiInstance.unbindEdgeDatasource(graphId, typeName, sourceVertexType, destinationVertexType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceApi#unbindEdgeDatasource");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String typeName = new String(); // String | 
final String sourceVertexType = new String(); // String | 
final String destinationVertexType = new String(); // String | 

try {
    final result = await api_instance.unbindEdgeDatasource(graphId, typeName, sourceVertexType, destinationVertexType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->unbindEdgeDatasource: $e\n');
}

import org.openapitools.client.api.DataSourceApi;

public class DataSourceApiExample {
    public static void main(String[] args) {
        DataSourceApi apiInstance = new DataSourceApi();
        String graphId = graphId_example; // String | 
        String typeName = typeName_example; // String | 
        String sourceVertexType = sourceVertexType_example; // String | 
        String destinationVertexType = destinationVertexType_example; // String | 

        try {
            'String' result = apiInstance.unbindEdgeDatasource(graphId, typeName, sourceVertexType, destinationVertexType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceApi#unbindEdgeDatasource");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DataSourceApi *apiInstance = [[DataSourceApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *typeName = typeName_example; //  (default to null)
String *sourceVertexType = sourceVertexType_example; //  (default to null)
String *destinationVertexType = destinationVertexType_example; //  (default to null)

[apiInstance unbindEdgeDatasourceWith:graphId
    typeName:typeName
    sourceVertexType:sourceVertexType
    destinationVertexType:destinationVertexType
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.DataSourceApi()
var graphId = graphId_example; // {String} 
var typeName = typeName_example; // {String} 
var sourceVertexType = sourceVertexType_example; // {String} 
var destinationVertexType = destinationVertexType_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.unbindEdgeDatasource(graphId, typeName, sourceVertexType, destinationVertexType, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DataSourceApi();
            var graphId = graphId_example;  // String |  (default to null)
            var typeName = typeName_example;  // String |  (default to null)
            var sourceVertexType = sourceVertexType_example;  // String |  (default to null)
            var destinationVertexType = destinationVertexType_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.unbindEdgeDatasource(graphId, typeName, sourceVertexType, destinationVertexType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataSourceApi.unbindEdgeDatasource: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataSourceApi();
$graphId = graphId_example; // String | 
$typeName = typeName_example; // String | 
$sourceVertexType = sourceVertexType_example; // String | 
$destinationVertexType = destinationVertexType_example; // String | 

try {
    $result = $api_instance->unbindEdgeDatasource($graphId, $typeName, $sourceVertexType, $destinationVertexType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataSourceApi->unbindEdgeDatasource: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataSourceApi->new();
my $graphId = graphId_example; # String | 
my $typeName = typeName_example; # String | 
my $sourceVertexType = sourceVertexType_example; # String | 
my $destinationVertexType = destinationVertexType_example; # String | 

eval {
    my $result = $api_instance->unbindEdgeDatasource(graphId => $graphId, typeName => $typeName, sourceVertexType => $sourceVertexType, destinationVertexType => $destinationVertexType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceApi->unbindEdgeDatasource: $@\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.DataSourceApi()
graphId = graphId_example # String |  (default to null)
typeName = typeName_example # String |  (default to null)
sourceVertexType = sourceVertexType_example # String |  (default to null)
destinationVertexType = destinationVertexType_example # String |  (default to null)

try:
    api_response = api_instance.unbind_edge_datasource(graphId, typeName, sourceVertexType, destinationVertexType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceApi->unbindEdgeDatasource: %s\n" % e)

extern crate DataSourceApi;

pub fn main() {
    let graphId = graphId_example; // String
    let typeName = typeName_example; // String
    let sourceVertexType = sourceVertexType_example; // String
    let destinationVertexType = destinationVertexType_example; // String

    let mut context = DataSourceApi::Context::default();
    let result = client.unbindEdgeDatasource(graphId, typeName, sourceVertexType, destinationVertexType, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required
type_name*	String Required

Query parameters

Name	Description
source_vertex_type*	String Required
destination_vertex_type*	String Required

Responses

Schema

Schema

unbindVertexDatasource

Unbind data source on a vertex type

/api/v1/graph/{graph_id}/datasource/vertex/{type_name}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/datasource/vertex/{type_name}"

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

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

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

        // Create an instance of the API class
        DataSourceApi apiInstance = new DataSourceApi();
        String graphId = graphId_example; // String | 
        String typeName = typeName_example; // String | 

        try {
            'String' result = apiInstance.unbindVertexDatasource(graphId, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceApi#unbindVertexDatasource");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String typeName = new String(); // String | 

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

import org.openapitools.client.api.DataSourceApi;

public class DataSourceApiExample {
    public static void main(String[] args) {
        DataSourceApi apiInstance = new DataSourceApi();
        String graphId = graphId_example; // String | 
        String typeName = typeName_example; // String | 

        try {
            'String' result = apiInstance.unbindVertexDatasource(graphId, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataSourceApi#unbindVertexDatasource");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DataSourceApi *apiInstance = [[DataSourceApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *typeName = typeName_example; //  (default to null)

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.DataSourceApi()
var graphId = graphId_example; // {String} 
var typeName = typeName_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DataSourceApi();
            var graphId = graphId_example;  // String |  (default to null)
            var typeName = typeName_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.unbindVertexDatasource(graphId, typeName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataSourceApi.unbindVertexDatasource: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataSourceApi();
$graphId = graphId_example; // String | 
$typeName = typeName_example; // String | 

try {
    $result = $api_instance->unbindVertexDatasource($graphId, $typeName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataSourceApi->unbindVertexDatasource: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataSourceApi->new();
my $graphId = graphId_example; # String | 
my $typeName = typeName_example; # String | 

eval {
    my $result = $api_instance->unbindVertexDatasource(graphId => $graphId, typeName => $typeName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataSourceApi->unbindVertexDatasource: $@\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.DataSourceApi()
graphId = graphId_example # String |  (default to null)
typeName = typeName_example # String |  (default to null)

try:
    api_response = api_instance.unbind_vertex_datasource(graphId, typeName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataSourceApi->unbindVertexDatasource: %s\n" % e)

extern crate DataSourceApi;

pub fn main() {
    let graphId = graphId_example; // String
    let typeName = typeName_example; // String

    let mut context = DataSourceApi::Context::default();
    let result = client.unbindVertexDatasource(graphId, typeName, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required
type_name*	String Required

Responses

Schema

Schema

Deployment

getDeploymentInfo

Deployment information

/api/v1/deployment

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/deployment"

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

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

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

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

        try {
            RunningDeploymentInfo result = apiInstance.getDeploymentInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getDeploymentInfo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DeploymentApi;

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

        try {
            RunningDeploymentInfo result = apiInstance.getDeploymentInfo();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getDeploymentInfo");
            e.printStackTrace();
        }
    }
}



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

[apiInstance getDeploymentInfoWithCompletionHandler: 
              ^(RunningDeploymentInfo output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.DeploymentApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDeploymentInfo(callback);

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

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

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

            try {
                RunningDeploymentInfo result = apiInstance.getDeploymentInfo();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DeploymentApi.getDeploymentInfo: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.get_deployment_info()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DeploymentApi->getDeploymentInfo: %s\n" % e)

extern crate DeploymentApi;

pub fn main() {

    let mut context = DeploymentApi::Context::default();
    let result = client.getDeploymentInfo(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

getDeploymentPodLog

[Deprecated] Get kubernetes pod's log

/api/v1/deployment/log

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/deployment/log?pod_name=podName_example&component=component_example&from_cache=true"

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

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

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

        // Create an instance of the API class
        DeploymentApi apiInstance = new DeploymentApi();
        String podName = podName_example; // String | 
        String component = component_example; // String | 
        Boolean fromCache = true; // Boolean | 

        try {
            GetPodLogResponse result = apiInstance.getDeploymentPodLog(podName, component, fromCache);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getDeploymentPodLog");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String podName = new String(); // String | 
final String component = new String(); // String | 
final Boolean fromCache = new Boolean(); // Boolean | 

try {
    final result = await api_instance.getDeploymentPodLog(podName, component, fromCache);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getDeploymentPodLog: $e\n');
}

import org.openapitools.client.api.DeploymentApi;

public class DeploymentApiExample {
    public static void main(String[] args) {
        DeploymentApi apiInstance = new DeploymentApi();
        String podName = podName_example; // String | 
        String component = component_example; // String | 
        Boolean fromCache = true; // Boolean | 

        try {
            GetPodLogResponse result = apiInstance.getDeploymentPodLog(podName, component, fromCache);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getDeploymentPodLog");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DeploymentApi *apiInstance = [[DeploymentApi alloc] init];
String *podName = podName_example; //  (default to null)
String *component = component_example; //  (default to null)
Boolean *fromCache = true; //  (default to null)

[apiInstance getDeploymentPodLogWith:podName
    component:component
    fromCache:fromCache
              completionHandler: ^(GetPodLogResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.DeploymentApi()
var podName = podName_example; // {String} 
var component = component_example; // {String} 
var fromCache = true; // {Boolean} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DeploymentApi();
            var podName = podName_example;  // String |  (default to null)
            var component = component_example;  // String |  (default to null)
            var fromCache = true;  // Boolean |  (default to null)

            try {
                GetPodLogResponse result = apiInstance.getDeploymentPodLog(podName, component, fromCache);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DeploymentApi.getDeploymentPodLog: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DeploymentApi();
$podName = podName_example; // String | 
$component = component_example; // String | 
$fromCache = true; // Boolean | 

try {
    $result = $api_instance->getDeploymentPodLog($podName, $component, $fromCache);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DeploymentApi->getDeploymentPodLog: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DeploymentApi->new();
my $podName = podName_example; # String | 
my $component = component_example; # String | 
my $fromCache = true; # Boolean | 

eval {
    my $result = $api_instance->getDeploymentPodLog(podName => $podName, component => $component, fromCache => $fromCache);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DeploymentApi->getDeploymentPodLog: $@\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.DeploymentApi()
podName = podName_example # String |  (default to null)
component = component_example # String |  (default to null)
fromCache = true # Boolean |  (default to null)

try:
    api_response = api_instance.get_deployment_pod_log(podName, component, fromCache)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DeploymentApi->getDeploymentPodLog: %s\n" % e)

extern crate DeploymentApi;

pub fn main() {
    let podName = podName_example; // String
    let component = component_example; // String
    let fromCache = true; // Boolean

    let mut context = DeploymentApi::Context::default();
    let result = client.getDeploymentPodLog(podName, component, fromCache, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
pod_name*	String Required
component*	String Required
from_cache*	Boolean Required

Responses

Schema

Schema

getDeploymentResourceUsage

[Deprecated] Get resource usage(cpu/memory) of cluster

/api/v1/deployment/resource/usage

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/deployment/resource/usage"

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

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

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

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

        try {
            GetResourceUsageResponse result = apiInstance.getDeploymentResourceUsage();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getDeploymentResourceUsage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DeploymentApi;

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

        try {
            GetResourceUsageResponse result = apiInstance.getDeploymentResourceUsage();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getDeploymentResourceUsage");
            e.printStackTrace();
        }
    }
}



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

[apiInstance getDeploymentResourceUsageWithCompletionHandler: 
              ^(GetResourceUsageResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.DeploymentApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDeploymentResourceUsage(callback);

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

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

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

            try {
                GetResourceUsageResponse result = apiInstance.getDeploymentResourceUsage();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DeploymentApi.getDeploymentResourceUsage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.get_deployment_resource_usage()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DeploymentApi->getDeploymentResourceUsage: %s\n" % e)

extern crate DeploymentApi;

pub fn main() {

    let mut context = DeploymentApi::Context::default();
    let result = client.getDeploymentResourceUsage(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

getDeploymentStatus

Get deployment status of cluster

/api/v1/deployment/status

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/deployment/status"

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

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

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

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

        try {
            RunningDeploymentStatus result = apiInstance.getDeploymentStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getDeploymentStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DeploymentApi;

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

        try {
            RunningDeploymentStatus result = apiInstance.getDeploymentStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getDeploymentStatus");
            e.printStackTrace();
        }
    }
}



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

[apiInstance getDeploymentStatusWithCompletionHandler: 
              ^(RunningDeploymentStatus output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.DeploymentApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getDeploymentStatus(callback);

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

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

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

            try {
                RunningDeploymentStatus result = apiInstance.getDeploymentStatus();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DeploymentApi.getDeploymentStatus: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.get_deployment_status()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DeploymentApi->getDeploymentStatus: %s\n" % e)

extern crate DeploymentApi;

pub fn main() {

    let mut context = DeploymentApi::Context::default();
    let result = client.getDeploymentStatus(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

getStorageUsage

[Deprecated] Get storage usage of Groot

/api/v1/deployment/storage/usage

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/deployment/storage/usage"

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

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

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

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

        try {
            GetStorageUsageResponse result = apiInstance.getStorageUsage();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getStorageUsage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.DeploymentApi;

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

        try {
            GetStorageUsageResponse result = apiInstance.getStorageUsage();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DeploymentApi#getStorageUsage");
            e.printStackTrace();
        }
    }
}



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

[apiInstance getStorageUsageWithCompletionHandler: 
              ^(GetStorageUsageResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.DeploymentApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getStorageUsage(callback);

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

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

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

            try {
                GetStorageUsageResponse result = apiInstance.getStorageUsage();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DeploymentApi.getStorageUsage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.get_storage_usage()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DeploymentApi->getStorageUsage: %s\n" % e)

extern crate DeploymentApi;

pub fn main() {

    let mut context = DeploymentApi::Context::default();
    let result = client.getStorageUsage(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

Graph

createEdgeType

Create a edge type

/api/v1/graph/{graph_id}/schema/edge

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/schema/edge" \
 -d '{
  "type_name" : "type_name",
  "directed" : true,
  "primary_keys" : [ "primary_keys", "primary_keys" ],
  "vertex_type_pair_relations" : [ {
    "source_vertex" : "source_vertex",
    "destination_vertex" : "destination_vertex",
    "x_csr_params" : {
      "edge_storage_strategy" : "ONLY_IN"
    },
    "relation" : "MANY_TO_MANY"
  }, {
    "source_vertex" : "source_vertex",
    "destination_vertex" : "destination_vertex",
    "x_csr_params" : {
      "edge_storage_strategy" : "ONLY_IN"
    },
    "relation" : "MANY_TO_MANY"
  } ],
  "description" : "description",
  "properties" : [ {
    "nullable" : true,
    "property_type" : {
      "primitive_type" : "DT_SIGNED_INT32"
    },
    "description" : "description",
    "default_value" : "",
    "property_name" : "property_name"
  }, {
    "nullable" : true,
    "property_type" : {
      "primitive_type" : "DT_SIGNED_INT32"
    },
    "description" : "description",
    "default_value" : "",
    "property_name" : "property_name"
  } ]
}'

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

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

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

        // Create an instance of the API class
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 
        CreateEdgeType createEdgeType = ; // CreateEdgeType | 

        try {
            'String' result = apiInstance.createEdgeType(graphId, createEdgeType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#createEdgeType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final CreateEdgeType createEdgeType = new CreateEdgeType(); // CreateEdgeType | 

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

import org.openapitools.client.api.GraphApi;

public class GraphApiExample {
    public static void main(String[] args) {
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 
        CreateEdgeType createEdgeType = ; // CreateEdgeType | 

        try {
            'String' result = apiInstance.createEdgeType(graphId, createEdgeType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#createEdgeType");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphApi *apiInstance = [[GraphApi alloc] init];
String *graphId = graphId_example; //  (default to null)
CreateEdgeType *createEdgeType = ; //  (optional)

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.GraphApi()
var graphId = graphId_example; // {String} 
var opts = {
  'createEdgeType':  // {CreateEdgeType} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphApi();
            var graphId = graphId_example;  // String |  (default to null)
            var createEdgeType = new CreateEdgeType(); // CreateEdgeType |  (optional) 

            try {
                'String' result = apiInstance.createEdgeType(graphId, createEdgeType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphApi.createEdgeType: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphApi();
$graphId = graphId_example; // String | 
$createEdgeType = ; // CreateEdgeType | 

try {
    $result = $api_instance->createEdgeType($graphId, $createEdgeType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphApi->createEdgeType: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphApi->new();
my $graphId = graphId_example; # String | 
my $createEdgeType = WWW::OPenAPIClient::Object::CreateEdgeType->new(); # CreateEdgeType | 

eval {
    my $result = $api_instance->createEdgeType(graphId => $graphId, createEdgeType => $createEdgeType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphApi->createEdgeType: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphApi()
graphId = graphId_example # String |  (default to null)
createEdgeType =  # CreateEdgeType |  (optional)

try:
    api_response = api_instance.create_edge_type(graphId, createEdgeType=createEdgeType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphApi->createEdgeType: %s\n" % e)

extern crate GraphApi;

pub fn main() {
    let graphId = graphId_example; // String
    let createEdgeType = ; // CreateEdgeType

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

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
createEdgeType

Responses

Schema

Schema

Schema

createGraph

Create a new graph

/api/v1/graph

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/graph" \
 -d '{
  "schema" : {
    "vertex_types" : [ {
      "type_name" : "type_name",
      "primary_keys" : [ "primary_keys", "primary_keys" ],
      "x_csr_params" : {
        "max_vertex_num" : 0
      },
      "description" : "description",
      "properties" : [ {
        "nullable" : true,
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "description" : "description",
        "default_value" : "",
        "property_name" : "property_name"
      }, {
        "nullable" : true,
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "description" : "description",
        "default_value" : "",
        "property_name" : "property_name"
      } ]
    }, {
      "type_name" : "type_name",
      "primary_keys" : [ "primary_keys", "primary_keys" ],
      "x_csr_params" : {
        "max_vertex_num" : 0
      },
      "description" : "description",
      "properties" : [ {
        "nullable" : true,
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "description" : "description",
        "default_value" : "",
        "property_name" : "property_name"
      }, {
        "nullable" : true,
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "description" : "description",
        "default_value" : "",
        "property_name" : "property_name"
      } ]
    } ],
    "edge_types" : [ {
      "type_name" : "type_name",
      "directed" : true,
      "primary_keys" : [ "primary_keys", "primary_keys" ],
      "vertex_type_pair_relations" : [ {
        "source_vertex" : "source_vertex",
        "destination_vertex" : "destination_vertex",
        "x_csr_params" : {
          "edge_storage_strategy" : "ONLY_IN"
        },
        "relation" : "MANY_TO_MANY"
      }, {
        "source_vertex" : "source_vertex",
        "destination_vertex" : "destination_vertex",
        "x_csr_params" : {
          "edge_storage_strategy" : "ONLY_IN"
        },
        "relation" : "MANY_TO_MANY"
      } ],
      "description" : "description",
      "properties" : [ {
        "nullable" : true,
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "description" : "description",
        "default_value" : "",
        "property_name" : "property_name"
      }, {
        "nullable" : true,
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "description" : "description",
        "default_value" : "",
        "property_name" : "property_name"
      } ]
    }, {
      "type_name" : "type_name",
      "directed" : true,
      "primary_keys" : [ "primary_keys", "primary_keys" ],
      "vertex_type_pair_relations" : [ {
        "source_vertex" : "source_vertex",
        "destination_vertex" : "destination_vertex",
        "x_csr_params" : {
          "edge_storage_strategy" : "ONLY_IN"
        },
        "relation" : "MANY_TO_MANY"
      }, {
        "source_vertex" : "source_vertex",
        "destination_vertex" : "destination_vertex",
        "x_csr_params" : {
          "edge_storage_strategy" : "ONLY_IN"
        },
        "relation" : "MANY_TO_MANY"
      } ],
      "description" : "description",
      "properties" : [ {
        "nullable" : true,
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "description" : "description",
        "default_value" : "",
        "property_name" : "property_name"
      }, {
        "nullable" : true,
        "property_type" : {
          "primitive_type" : "DT_SIGNED_INT32"
        },
        "description" : "description",
        "default_value" : "",
        "property_name" : "property_name"
      } ]
    } ]
  },
  "stored_procedures" : [ {
    "query" : "query",
    "name" : "name",
    "description" : "description",
    "type" : "cpp"
  }, {
    "query" : "query",
    "name" : "name",
    "description" : "description",
    "type" : "cpp"
  } ],
  "name" : "name",
  "description" : "description"
}'

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

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

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

        // Create an instance of the API class
        GraphApi apiInstance = new GraphApi();
        CreateGraphRequest createGraphRequest = ; // CreateGraphRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateGraphRequest createGraphRequest = new CreateGraphRequest(); // CreateGraphRequest | 

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

import org.openapitools.client.api.GraphApi;

public class GraphApiExample {
    public static void main(String[] args) {
        GraphApi apiInstance = new GraphApi();
        CreateGraphRequest createGraphRequest = ; // CreateGraphRequest | 

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



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

[apiInstance createGraphWith:createGraphRequest
              completionHandler: ^(CreateGraphResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.GraphApi()
var createGraphRequest = ; // {CreateGraphRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphApi();
            var createGraphRequest = new CreateGraphRequest(); // CreateGraphRequest | 

            try {
                CreateGraphResponse result = apiInstance.createGraph(createGraphRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphApi.createGraph: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphApi();
$createGraphRequest = ; // CreateGraphRequest | 

try {
    $result = $api_instance->createGraph($createGraphRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphApi->createGraph: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphApi->new();
my $createGraphRequest = WWW::OPenAPIClient::Object::CreateGraphRequest->new(); # CreateGraphRequest | 

eval {
    my $result = $api_instance->createGraph(createGraphRequest => $createGraphRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphApi->createGraph: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphApi()
createGraphRequest =  # CreateGraphRequest | 

try:
    api_response = api_instance.create_graph(createGraphRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphApi->createGraph: %s\n" % e)

extern crate GraphApi;

pub fn main() {
    let createGraphRequest = ; // CreateGraphRequest

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

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

Scopes

Parameters

Body parameters

Name	Description
createGraphRequest *

Responses

Schema

Schema

Schema

createVertexType

Create a vertex type

/api/v1/graph/{graph_id}/schema/vertex

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/schema/vertex" \
 -d '{
  "type_name" : "type_name",
  "primary_keys" : [ "primary_keys", "primary_keys" ],
  "x_csr_params" : {
    "max_vertex_num" : 0
  },
  "description" : "description",
  "properties" : [ {
    "nullable" : true,
    "property_type" : {
      "primitive_type" : "DT_SIGNED_INT32"
    },
    "description" : "description",
    "default_value" : "",
    "property_name" : "property_name"
  }, {
    "nullable" : true,
    "property_type" : {
      "primitive_type" : "DT_SIGNED_INT32"
    },
    "description" : "description",
    "default_value" : "",
    "property_name" : "property_name"
  } ]
}'

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

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

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

        // Create an instance of the API class
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 
        CreateVertexType createVertexType = ; // CreateVertexType | 

        try {
            'String' result = apiInstance.createVertexType(graphId, createVertexType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#createVertexType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final CreateVertexType createVertexType = new CreateVertexType(); // CreateVertexType | 

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

import org.openapitools.client.api.GraphApi;

public class GraphApiExample {
    public static void main(String[] args) {
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 
        CreateVertexType createVertexType = ; // CreateVertexType | 

        try {
            'String' result = apiInstance.createVertexType(graphId, createVertexType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#createVertexType");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphApi *apiInstance = [[GraphApi alloc] init];
String *graphId = graphId_example; //  (default to null)
CreateVertexType *createVertexType = ; // 

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.GraphApi()
var graphId = graphId_example; // {String} 
var createVertexType = ; // {CreateVertexType} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphApi();
            var graphId = graphId_example;  // String |  (default to null)
            var createVertexType = new CreateVertexType(); // CreateVertexType | 

            try {
                'String' result = apiInstance.createVertexType(graphId, createVertexType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphApi.createVertexType: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphApi();
$graphId = graphId_example; // String | 
$createVertexType = ; // CreateVertexType | 

try {
    $result = $api_instance->createVertexType($graphId, $createVertexType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphApi->createVertexType: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphApi->new();
my $graphId = graphId_example; # String | 
my $createVertexType = WWW::OPenAPIClient::Object::CreateVertexType->new(); # CreateVertexType | 

eval {
    my $result = $api_instance->createVertexType(graphId => $graphId, createVertexType => $createVertexType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphApi->createVertexType: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphApi()
graphId = graphId_example # String |  (default to null)
createVertexType =  # CreateVertexType | 

try:
    api_response = api_instance.create_vertex_type(graphId, createVertexType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphApi->createVertexType: %s\n" % e)

extern crate GraphApi;

pub fn main() {
    let graphId = graphId_example; // String
    let createVertexType = ; // CreateVertexType

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

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
createVertexType *

Responses

Schema

Schema

Schema

deleteEdgeTypeByName

Delete edge type by name

/api/v1/graph/{graph_id}/schema/edge/{type_name}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/schema/edge/{type_name}?source_vertex_type=sourceVertexType_example&destination_vertex_type=destinationVertexType_example"

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

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

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

        // Create an instance of the API class
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 
        String typeName = typeName_example; // String | 
        String sourceVertexType = sourceVertexType_example; // String | 
        String destinationVertexType = destinationVertexType_example; // String | 

        try {
            'String' result = apiInstance.deleteEdgeTypeByName(graphId, typeName, sourceVertexType, destinationVertexType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#deleteEdgeTypeByName");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String typeName = new String(); // String | 
final String sourceVertexType = new String(); // String | 
final String destinationVertexType = new String(); // String | 

try {
    final result = await api_instance.deleteEdgeTypeByName(graphId, typeName, sourceVertexType, destinationVertexType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteEdgeTypeByName: $e\n');
}

import org.openapitools.client.api.GraphApi;

public class GraphApiExample {
    public static void main(String[] args) {
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 
        String typeName = typeName_example; // String | 
        String sourceVertexType = sourceVertexType_example; // String | 
        String destinationVertexType = destinationVertexType_example; // String | 

        try {
            'String' result = apiInstance.deleteEdgeTypeByName(graphId, typeName, sourceVertexType, destinationVertexType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#deleteEdgeTypeByName");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphApi *apiInstance = [[GraphApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *typeName = typeName_example; //  (default to null)
String *sourceVertexType = sourceVertexType_example; //  (default to null)
String *destinationVertexType = destinationVertexType_example; //  (default to null)

[apiInstance deleteEdgeTypeByNameWith:graphId
    typeName:typeName
    sourceVertexType:sourceVertexType
    destinationVertexType:destinationVertexType
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.GraphApi()
var graphId = graphId_example; // {String} 
var typeName = typeName_example; // {String} 
var sourceVertexType = sourceVertexType_example; // {String} 
var destinationVertexType = destinationVertexType_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteEdgeTypeByName(graphId, typeName, sourceVertexType, destinationVertexType, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new GraphApi();
            var graphId = graphId_example;  // String |  (default to null)
            var typeName = typeName_example;  // String |  (default to null)
            var sourceVertexType = sourceVertexType_example;  // String |  (default to null)
            var destinationVertexType = destinationVertexType_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.deleteEdgeTypeByName(graphId, typeName, sourceVertexType, destinationVertexType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphApi.deleteEdgeTypeByName: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphApi();
$graphId = graphId_example; // String | 
$typeName = typeName_example; // String | 
$sourceVertexType = sourceVertexType_example; // String | 
$destinationVertexType = destinationVertexType_example; // String | 

try {
    $result = $api_instance->deleteEdgeTypeByName($graphId, $typeName, $sourceVertexType, $destinationVertexType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphApi->deleteEdgeTypeByName: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphApi->new();
my $graphId = graphId_example; # String | 
my $typeName = typeName_example; # String | 
my $sourceVertexType = sourceVertexType_example; # String | 
my $destinationVertexType = destinationVertexType_example; # String | 

eval {
    my $result = $api_instance->deleteEdgeTypeByName(graphId => $graphId, typeName => $typeName, sourceVertexType => $sourceVertexType, destinationVertexType => $destinationVertexType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphApi->deleteEdgeTypeByName: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphApi()
graphId = graphId_example # String |  (default to null)
typeName = typeName_example # String |  (default to null)
sourceVertexType = sourceVertexType_example # String |  (default to null)
destinationVertexType = destinationVertexType_example # String |  (default to null)

try:
    api_response = api_instance.delete_edge_type_by_name(graphId, typeName, sourceVertexType, destinationVertexType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphApi->deleteEdgeTypeByName: %s\n" % e)

extern crate GraphApi;

pub fn main() {
    let graphId = graphId_example; // String
    let typeName = typeName_example; // String
    let sourceVertexType = sourceVertexType_example; // String
    let destinationVertexType = destinationVertexType_example; // String

    let mut context = GraphApi::Context::default();
    let result = client.deleteEdgeTypeByName(graphId, typeName, sourceVertexType, destinationVertexType, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required
type_name*	String Required

Query parameters

Name	Description
source_vertex_type*	String Required
destination_vertex_type*	String Required

Responses

Schema

Schema

deleteGraphById

Delete graph by ID

/api/v1/graph/{graph_id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph/{graph_id}"

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

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

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

        // Create an instance of the API class
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.GraphApi;

public class GraphApiExample {
    public static void main(String[] args) {
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 

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



// Create an instance of the API class
GraphApi *apiInstance = [[GraphApi alloc] init];
String *graphId = graphId_example; //  (default to null)

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.GraphApi()
var graphId = graphId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphApi();
            var graphId = graphId_example;  // String |  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphApi();
$graphId = graphId_example; // String | 

try {
    $result = $api_instance->deleteGraphById($graphId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphApi->deleteGraphById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphApi->new();
my $graphId = graphId_example; # String | 

eval {
    my $result = $api_instance->deleteGraphById(graphId => $graphId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphApi->deleteGraphById: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphApi()
graphId = graphId_example # String |  (default to null)

try:
    api_response = api_instance.delete_graph_by_id(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphApi->deleteGraphById: %s\n" % e)

extern crate GraphApi;

pub fn main() {
    let graphId = graphId_example; // String

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

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Responses

Schema

Schema

deleteVertexTypeByName

Delete vertex type by name

/api/v1/graph/{graph_id}/schema/vertex/{type_name}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/schema/vertex/{type_name}"

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

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

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

        // Create an instance of the API class
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 
        String typeName = typeName_example; // String | 

        try {
            'String' result = apiInstance.deleteVertexTypeByName(graphId, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#deleteVertexTypeByName");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String typeName = new String(); // String | 

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

import org.openapitools.client.api.GraphApi;

public class GraphApiExample {
    public static void main(String[] args) {
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 
        String typeName = typeName_example; // String | 

        try {
            'String' result = apiInstance.deleteVertexTypeByName(graphId, typeName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#deleteVertexTypeByName");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphApi *apiInstance = [[GraphApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *typeName = typeName_example; //  (default to null)

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.GraphApi()
var graphId = graphId_example; // {String} 
var typeName = typeName_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphApi();
            var graphId = graphId_example;  // String |  (default to null)
            var typeName = typeName_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.deleteVertexTypeByName(graphId, typeName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphApi.deleteVertexTypeByName: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphApi();
$graphId = graphId_example; // String | 
$typeName = typeName_example; // String | 

try {
    $result = $api_instance->deleteVertexTypeByName($graphId, $typeName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphApi->deleteVertexTypeByName: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphApi->new();
my $graphId = graphId_example; # String | 
my $typeName = typeName_example; # String | 

eval {
    my $result = $api_instance->deleteVertexTypeByName(graphId => $graphId, typeName => $typeName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphApi->deleteVertexTypeByName: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphApi()
graphId = graphId_example # String |  (default to null)
typeName = typeName_example # String |  (default to null)

try:
    api_response = api_instance.delete_vertex_type_by_name(graphId, typeName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphApi->deleteVertexTypeByName: %s\n" % e)

extern crate GraphApi;

pub fn main() {
    let graphId = graphId_example; // String
    let typeName = typeName_example; // String

    let mut context = GraphApi::Context::default();
    let result = client.deleteVertexTypeByName(graphId, typeName, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required
type_name*	String Required

Responses

Schema

Schema

getGraphById

Get graph by ID

/api/v1/graph/{graph_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph/{graph_id}"

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

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

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

        // Create an instance of the API class
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.GraphApi;

public class GraphApiExample {
    public static void main(String[] args) {
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 

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



// Create an instance of the API class
GraphApi *apiInstance = [[GraphApi alloc] init];
String *graphId = graphId_example; //  (default to null)

[apiInstance getGraphByIdWith:graphId
              completionHandler: ^(GetGraphResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.GraphApi()
var graphId = graphId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphApi();
            var graphId = graphId_example;  // String |  (default to null)

            try {
                GetGraphResponse result = apiInstance.getGraphById(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphApi.getGraphById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphApi();
$graphId = graphId_example; // String | 

try {
    $result = $api_instance->getGraphById($graphId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphApi->getGraphById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphApi->new();
my $graphId = graphId_example; # String | 

eval {
    my $result = $api_instance->getGraphById(graphId => $graphId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphApi->getGraphById: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphApi()
graphId = graphId_example # String |  (default to null)

try:
    api_response = api_instance.get_graph_by_id(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphApi->getGraphById: %s\n" % e)

extern crate GraphApi;

pub fn main() {
    let graphId = graphId_example; // String

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

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Responses

Schema

Schema

getSchemaById

Get graph schema by ID

/api/v1/graph/{graph_id}/schema

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/schema"

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

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

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

        // Create an instance of the API class
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.GraphApi;

public class GraphApiExample {
    public static void main(String[] args) {
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 

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



// Create an instance of the API class
GraphApi *apiInstance = [[GraphApi alloc] init];
String *graphId = graphId_example; //  (default to null)

[apiInstance getSchemaByIdWith:graphId
              completionHandler: ^(GetGraphSchemaResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.GraphApi()
var graphId = graphId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphApi();
            var graphId = graphId_example;  // String |  (default to null)

            try {
                GetGraphSchemaResponse result = apiInstance.getSchemaById(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphApi.getSchemaById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphApi();
$graphId = graphId_example; // String | 

try {
    $result = $api_instance->getSchemaById($graphId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphApi->getSchemaById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphApi->new();
my $graphId = graphId_example; # String | 

eval {
    my $result = $api_instance->getSchemaById(graphId => $graphId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphApi->getSchemaById: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphApi()
graphId = graphId_example # String |  (default to null)

try:
    api_response = api_instance.get_schema_by_id(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphApi->getSchemaById: %s\n" % e)

extern crate GraphApi;

pub fn main() {
    let graphId = graphId_example; // String

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

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Responses

Schema

Schema

importSchemaById

Import graph schema

/api/v1/graph/{graph_id}/schema

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/schema" \
 -d '{
  "vertex_types" : [ {
    "type_name" : "type_name",
    "primary_keys" : [ "primary_keys", "primary_keys" ],
    "x_csr_params" : {
      "max_vertex_num" : 0
    },
    "description" : "description",
    "properties" : [ {
      "nullable" : true,
      "property_type" : {
        "primitive_type" : "DT_SIGNED_INT32"
      },
      "description" : "description",
      "default_value" : "",
      "property_name" : "property_name"
    }, {
      "nullable" : true,
      "property_type" : {
        "primitive_type" : "DT_SIGNED_INT32"
      },
      "description" : "description",
      "default_value" : "",
      "property_name" : "property_name"
    } ]
  }, {
    "type_name" : "type_name",
    "primary_keys" : [ "primary_keys", "primary_keys" ],
    "x_csr_params" : {
      "max_vertex_num" : 0
    },
    "description" : "description",
    "properties" : [ {
      "nullable" : true,
      "property_type" : {
        "primitive_type" : "DT_SIGNED_INT32"
      },
      "description" : "description",
      "default_value" : "",
      "property_name" : "property_name"
    }, {
      "nullable" : true,
      "property_type" : {
        "primitive_type" : "DT_SIGNED_INT32"
      },
      "description" : "description",
      "default_value" : "",
      "property_name" : "property_name"
    } ]
  } ],
  "edge_types" : [ {
    "type_name" : "type_name",
    "directed" : true,
    "primary_keys" : [ "primary_keys", "primary_keys" ],
    "vertex_type_pair_relations" : [ {
      "source_vertex" : "source_vertex",
      "destination_vertex" : "destination_vertex",
      "x_csr_params" : {
        "edge_storage_strategy" : "ONLY_IN"
      },
      "relation" : "MANY_TO_MANY"
    }, {
      "source_vertex" : "source_vertex",
      "destination_vertex" : "destination_vertex",
      "x_csr_params" : {
        "edge_storage_strategy" : "ONLY_IN"
      },
      "relation" : "MANY_TO_MANY"
    } ],
    "description" : "description",
    "properties" : [ {
      "nullable" : true,
      "property_type" : {
        "primitive_type" : "DT_SIGNED_INT32"
      },
      "description" : "description",
      "default_value" : "",
      "property_name" : "property_name"
    }, {
      "nullable" : true,
      "property_type" : {
        "primitive_type" : "DT_SIGNED_INT32"
      },
      "description" : "description",
      "default_value" : "",
      "property_name" : "property_name"
    } ]
  }, {
    "type_name" : "type_name",
    "directed" : true,
    "primary_keys" : [ "primary_keys", "primary_keys" ],
    "vertex_type_pair_relations" : [ {
      "source_vertex" : "source_vertex",
      "destination_vertex" : "destination_vertex",
      "x_csr_params" : {
        "edge_storage_strategy" : "ONLY_IN"
      },
      "relation" : "MANY_TO_MANY"
    }, {
      "source_vertex" : "source_vertex",
      "destination_vertex" : "destination_vertex",
      "x_csr_params" : {
        "edge_storage_strategy" : "ONLY_IN"
      },
      "relation" : "MANY_TO_MANY"
    } ],
    "description" : "description",
    "properties" : [ {
      "nullable" : true,
      "property_type" : {
        "primitive_type" : "DT_SIGNED_INT32"
      },
      "description" : "description",
      "default_value" : "",
      "property_name" : "property_name"
    }, {
      "nullable" : true,
      "property_type" : {
        "primitive_type" : "DT_SIGNED_INT32"
      },
      "description" : "description",
      "default_value" : "",
      "property_name" : "property_name"
    } ]
  } ]
}'

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

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

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

        // Create an instance of the API class
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 
        CreateGraphSchemaRequest createGraphSchemaRequest = ; // CreateGraphSchemaRequest | 

        try {
            'String' result = apiInstance.importSchemaById(graphId, createGraphSchemaRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#importSchemaById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final CreateGraphSchemaRequest createGraphSchemaRequest = new CreateGraphSchemaRequest(); // CreateGraphSchemaRequest | 

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

import org.openapitools.client.api.GraphApi;

public class GraphApiExample {
    public static void main(String[] args) {
        GraphApi apiInstance = new GraphApi();
        String graphId = graphId_example; // String | 
        CreateGraphSchemaRequest createGraphSchemaRequest = ; // CreateGraphSchemaRequest | 

        try {
            'String' result = apiInstance.importSchemaById(graphId, createGraphSchemaRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#importSchemaById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GraphApi *apiInstance = [[GraphApi alloc] init];
String *graphId = graphId_example; //  (default to null)
CreateGraphSchemaRequest *createGraphSchemaRequest = ; // 

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.GraphApi()
var graphId = graphId_example; // {String} 
var createGraphSchemaRequest = ; // {CreateGraphSchemaRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new GraphApi();
            var graphId = graphId_example;  // String |  (default to null)
            var createGraphSchemaRequest = new CreateGraphSchemaRequest(); // CreateGraphSchemaRequest | 

            try {
                'String' result = apiInstance.importSchemaById(graphId, createGraphSchemaRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphApi.importSchemaById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GraphApi();
$graphId = graphId_example; // String | 
$createGraphSchemaRequest = ; // CreateGraphSchemaRequest | 

try {
    $result = $api_instance->importSchemaById($graphId, $createGraphSchemaRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GraphApi->importSchemaById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GraphApi->new();
my $graphId = graphId_example; # String | 
my $createGraphSchemaRequest = WWW::OPenAPIClient::Object::CreateGraphSchemaRequest->new(); # CreateGraphSchemaRequest | 

eval {
    my $result = $api_instance->importSchemaById(graphId => $graphId, createGraphSchemaRequest => $createGraphSchemaRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphApi->importSchemaById: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphApi()
graphId = graphId_example # String |  (default to null)
createGraphSchemaRequest =  # CreateGraphSchemaRequest | 

try:
    api_response = api_instance.import_schema_by_id(graphId, createGraphSchemaRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphApi->importSchemaById: %s\n" % e)

extern crate GraphApi;

pub fn main() {
    let graphId = graphId_example; // String
    let createGraphSchemaRequest = ; // CreateGraphSchemaRequest

    let mut context = GraphApi::Context::default();
    let result = client.importSchemaById(graphId, createGraphSchemaRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
createGraphSchemaRequest *

Responses

Schema

Schema

Schema

listGraphs

List all graphs

/api/v1/graph

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph"

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

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

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

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

        try {
            array[GetGraphResponse] result = apiInstance.listGraphs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#listGraphs");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.GraphApi;

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

        try {
            array[GetGraphResponse] result = apiInstance.listGraphs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GraphApi#listGraphs");
            e.printStackTrace();
        }
    }
}



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

[apiInstance listGraphsWithCompletionHandler: 
              ^(array[GetGraphResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.GraphApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listGraphs(callback);

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

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

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

            try {
                array[GetGraphResponse] result = apiInstance.listGraphs();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GraphApi.listGraphs: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->listGraphs();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GraphApi->listGraphs: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.GraphApi()

try:
    api_response = api_instance.list_graphs()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GraphApi->listGraphs: %s\n" % e)

extern crate GraphApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

Schema

Job

deleteJobById

Delete job by ID

/api/v1/job/{job_id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/api/v1/job/{job_id}?delete_scheduler=true"

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

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

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

        // Create an instance of the API class
        JobApi apiInstance = new JobApi();
        String jobId = jobId_example; // String | 
        Boolean deleteScheduler = true; // Boolean | 

        try {
            'String' result = apiInstance.deleteJobById(jobId, deleteScheduler);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#deleteJobById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String jobId = new String(); // String | 
final Boolean deleteScheduler = new Boolean(); // Boolean | 

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

import org.openapitools.client.api.JobApi;

public class JobApiExample {
    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String jobId = jobId_example; // String | 
        Boolean deleteScheduler = true; // Boolean | 

        try {
            'String' result = apiInstance.deleteJobById(jobId, deleteScheduler);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#deleteJobById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
JobApi *apiInstance = [[JobApi alloc] init];
String *jobId = jobId_example; //  (default to null)
Boolean *deleteScheduler = true; //  (optional) (default to null)

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.JobApi()
var jobId = jobId_example; // {String} 
var opts = {
  'deleteScheduler': true // {Boolean} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new JobApi();
            var jobId = jobId_example;  // String |  (default to null)
            var deleteScheduler = true;  // Boolean |  (optional)  (default to null)

            try {
                'String' result = apiInstance.deleteJobById(jobId, deleteScheduler);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling JobApi.deleteJobById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\JobApi();
$jobId = jobId_example; // String | 
$deleteScheduler = true; // Boolean | 

try {
    $result = $api_instance->deleteJobById($jobId, $deleteScheduler);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->deleteJobById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::JobApi->new();
my $jobId = jobId_example; # String | 
my $deleteScheduler = true; # Boolean | 

eval {
    my $result = $api_instance->deleteJobById(jobId => $jobId, deleteScheduler => $deleteScheduler);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->deleteJobById: $@\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.JobApi()
jobId = jobId_example # String |  (default to null)
deleteScheduler = true # Boolean |  (optional) (default to null)

try:
    api_response = api_instance.delete_job_by_id(jobId, deleteScheduler=deleteScheduler)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->deleteJobById: %s\n" % e)

extern crate JobApi;

pub fn main() {
    let jobId = jobId_example; // String
    let deleteScheduler = true; // Boolean

    let mut context = JobApi::Context::default();
    let result = client.deleteJobById(jobId, deleteScheduler, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
job_id*	String Required

Query parameters

Name	Description
delete_scheduler	Boolean

Responses

Schema

Schema

getDataloadingJobConfig

Post to get the data loading configuration for MapReduce Task

/api/v1/graph/{graph_id}/dataloading/config

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/dataloading/config" \
 -d '{
  "schedule" : "schedule",
  "loading_config" : {
    "format" : {
      "metadata" : {
        "key" : ""
      },
      "type" : "type"
    },
    "import_option" : "overwrite"
  },
  "vertices" : [ {
    "type_name" : "type_name"
  }, {
    "type_name" : "type_name"
  } ],
  "repeat" : "once",
  "edges" : [ {
    "type_name" : "type_name",
    "source_vertex" : "source_vertex",
    "destination_vertex" : "destination_vertex"
  }, {
    "type_name" : "type_name",
    "source_vertex" : "source_vertex",
    "destination_vertex" : "destination_vertex"
  } ]
}'

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

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

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

        // Create an instance of the API class
        JobApi apiInstance = new JobApi();
        String graphId = graphId_example; // String | 
        DataloadingJobConfig dataloadingJobConfig = ; // DataloadingJobConfig | 

        try {
            DataloadingMRJobConfig result = apiInstance.getDataloadingJobConfig(graphId, dataloadingJobConfig);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#getDataloadingJobConfig");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final DataloadingJobConfig dataloadingJobConfig = new DataloadingJobConfig(); // DataloadingJobConfig | 

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

import org.openapitools.client.api.JobApi;

public class JobApiExample {
    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String graphId = graphId_example; // String | 
        DataloadingJobConfig dataloadingJobConfig = ; // DataloadingJobConfig | 

        try {
            DataloadingMRJobConfig result = apiInstance.getDataloadingJobConfig(graphId, dataloadingJobConfig);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#getDataloadingJobConfig");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
JobApi *apiInstance = [[JobApi alloc] init];
String *graphId = graphId_example; //  (default to null)
DataloadingJobConfig *dataloadingJobConfig = ; // 

[apiInstance getDataloadingJobConfigWith:graphId
    dataloadingJobConfig:dataloadingJobConfig
              completionHandler: ^(DataloadingMRJobConfig output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.JobApi()
var graphId = graphId_example; // {String} 
var dataloadingJobConfig = ; // {DataloadingJobConfig} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new JobApi();
            var graphId = graphId_example;  // String |  (default to null)
            var dataloadingJobConfig = new DataloadingJobConfig(); // DataloadingJobConfig | 

            try {
                DataloadingMRJobConfig result = apiInstance.getDataloadingJobConfig(graphId, dataloadingJobConfig);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling JobApi.getDataloadingJobConfig: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\JobApi();
$graphId = graphId_example; // String | 
$dataloadingJobConfig = ; // DataloadingJobConfig | 

try {
    $result = $api_instance->getDataloadingJobConfig($graphId, $dataloadingJobConfig);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->getDataloadingJobConfig: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::JobApi->new();
my $graphId = graphId_example; # String | 
my $dataloadingJobConfig = WWW::OPenAPIClient::Object::DataloadingJobConfig->new(); # DataloadingJobConfig | 

eval {
    my $result = $api_instance->getDataloadingJobConfig(graphId => $graphId, dataloadingJobConfig => $dataloadingJobConfig);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->getDataloadingJobConfig: $@\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.JobApi()
graphId = graphId_example # String |  (default to null)
dataloadingJobConfig =  # DataloadingJobConfig | 

try:
    api_response = api_instance.get_dataloading_job_config(graphId, dataloadingJobConfig)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->getDataloadingJobConfig: %s\n" % e)

extern crate JobApi;

pub fn main() {
    let graphId = graphId_example; // String
    let dataloadingJobConfig = ; // DataloadingJobConfig

    let mut context = JobApi::Context::default();
    let result = client.getDataloadingJobConfig(graphId, dataloadingJobConfig, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
dataloadingJobConfig *

Responses

Schema

Schema

getJobById

Get job status by ID

/api/v1/job/{job_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/job/{job_id}"

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

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

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

        // Create an instance of the API class
        JobApi apiInstance = new JobApi();
        String jobId = jobId_example; // String | 

        try {
            JobStatus result = apiInstance.getJobById(jobId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#getJobById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.JobApi;

public class JobApiExample {
    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String jobId = jobId_example; // String | 

        try {
            JobStatus result = apiInstance.getJobById(jobId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#getJobById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
JobApi *apiInstance = [[JobApi alloc] init];
String *jobId = jobId_example; //  (default to null)

[apiInstance getJobByIdWith:jobId
              completionHandler: ^(JobStatus output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.JobApi()
var jobId = jobId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new JobApi();
            var jobId = jobId_example;  // String |  (default to null)

            try {
                JobStatus result = apiInstance.getJobById(jobId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling JobApi.getJobById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\JobApi();
$jobId = jobId_example; // String | 

try {
    $result = $api_instance->getJobById($jobId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->getJobById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::JobApi->new();
my $jobId = jobId_example; # String | 

eval {
    my $result = $api_instance->getJobById(jobId => $jobId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->getJobById: $@\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.JobApi()
jobId = jobId_example # String |  (default to null)

try:
    api_response = api_instance.get_job_by_id(jobId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->getJobById: %s\n" % e)

extern crate JobApi;

pub fn main() {
    let jobId = jobId_example; // String

    let mut context = JobApi::Context::default();
    let result = client.getJobById(jobId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
job_id*	String Required

Responses

Schema

Schema

listJobs

List all jobs

/api/v1/job

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/job"

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

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

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

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

        try {
            array[JobStatus] result = apiInstance.listJobs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#listJobs");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.JobApi;

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

        try {
            array[JobStatus] result = apiInstance.listJobs();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#listJobs");
            e.printStackTrace();
        }
    }
}



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

[apiInstance listJobsWithCompletionHandler: 
              ^(array[JobStatus] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.JobApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listJobs(callback);

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

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

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

            try {
                array[JobStatus] result = apiInstance.listJobs();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling JobApi.listJobs: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.list_jobs()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->listJobs: %s\n" % e)

extern crate JobApi;

pub fn main() {

    let mut context = JobApi::Context::default();
    let result = client.listJobs(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

submitDataloadingJob

Submit a dataloading job

/api/v1/graph/{graph_id}/dataloading

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/dataloading" \
 -d '{
  "schedule" : "schedule",
  "loading_config" : {
    "format" : {
      "metadata" : {
        "key" : ""
      },
      "type" : "type"
    },
    "import_option" : "overwrite"
  },
  "vertices" : [ {
    "type_name" : "type_name"
  }, {
    "type_name" : "type_name"
  } ],
  "repeat" : "once",
  "edges" : [ {
    "type_name" : "type_name",
    "source_vertex" : "source_vertex",
    "destination_vertex" : "destination_vertex"
  }, {
    "type_name" : "type_name",
    "source_vertex" : "source_vertex",
    "destination_vertex" : "destination_vertex"
  } ]
}'

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

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

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

        // Create an instance of the API class
        JobApi apiInstance = new JobApi();
        String graphId = graphId_example; // String | 
        DataloadingJobConfig dataloadingJobConfig = ; // DataloadingJobConfig | 

        try {
            CreateDataloadingJobResponse result = apiInstance.submitDataloadingJob(graphId, dataloadingJobConfig);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#submitDataloadingJob");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final DataloadingJobConfig dataloadingJobConfig = new DataloadingJobConfig(); // DataloadingJobConfig | 

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

import org.openapitools.client.api.JobApi;

public class JobApiExample {
    public static void main(String[] args) {
        JobApi apiInstance = new JobApi();
        String graphId = graphId_example; // String | 
        DataloadingJobConfig dataloadingJobConfig = ; // DataloadingJobConfig | 

        try {
            CreateDataloadingJobResponse result = apiInstance.submitDataloadingJob(graphId, dataloadingJobConfig);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobApi#submitDataloadingJob");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
JobApi *apiInstance = [[JobApi alloc] init];
String *graphId = graphId_example; //  (default to null)
DataloadingJobConfig *dataloadingJobConfig = ; // 

[apiInstance submitDataloadingJobWith:graphId
    dataloadingJobConfig:dataloadingJobConfig
              completionHandler: ^(CreateDataloadingJobResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.JobApi()
var graphId = graphId_example; // {String} 
var dataloadingJobConfig = ; // {DataloadingJobConfig} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new JobApi();
            var graphId = graphId_example;  // String |  (default to null)
            var dataloadingJobConfig = new DataloadingJobConfig(); // DataloadingJobConfig | 

            try {
                CreateDataloadingJobResponse result = apiInstance.submitDataloadingJob(graphId, dataloadingJobConfig);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling JobApi.submitDataloadingJob: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\JobApi();
$graphId = graphId_example; // String | 
$dataloadingJobConfig = ; // DataloadingJobConfig | 

try {
    $result = $api_instance->submitDataloadingJob($graphId, $dataloadingJobConfig);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling JobApi->submitDataloadingJob: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::JobApi->new();
my $graphId = graphId_example; # String | 
my $dataloadingJobConfig = WWW::OPenAPIClient::Object::DataloadingJobConfig->new(); # DataloadingJobConfig | 

eval {
    my $result = $api_instance->submitDataloadingJob(graphId => $graphId, dataloadingJobConfig => $dataloadingJobConfig);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling JobApi->submitDataloadingJob: $@\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.JobApi()
graphId = graphId_example # String |  (default to null)
dataloadingJobConfig =  # DataloadingJobConfig | 

try:
    api_response = api_instance.submit_dataloading_job(graphId, dataloadingJobConfig)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling JobApi->submitDataloadingJob: %s\n" % e)

extern crate JobApi;

pub fn main() {
    let graphId = graphId_example; // String
    let dataloadingJobConfig = ; // DataloadingJobConfig

    let mut context = JobApi::Context::default();
    let result = client.submitDataloadingJob(graphId, dataloadingJobConfig, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
dataloadingJobConfig *

Responses

Schema

Schema

Schema

Service

getServiceStatusById

Get service status by graph ID

/api/v1/graph/{graph_id}/service

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/service"

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

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

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

        // Create an instance of the API class
        ServiceApi apiInstance = new ServiceApi();
        String graphId = graphId_example; // String | 

        try {
            ServiceStatus result = apiInstance.getServiceStatusById(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#getServiceStatusById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ServiceApi;

public class ServiceApiExample {
    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        String graphId = graphId_example; // String | 

        try {
            ServiceStatus result = apiInstance.getServiceStatusById(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#getServiceStatusById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ServiceApi *apiInstance = [[ServiceApi alloc] init];
String *graphId = graphId_example; //  (default to null)

[apiInstance getServiceStatusByIdWith:graphId
              completionHandler: ^(ServiceStatus output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.ServiceApi()
var graphId = graphId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ServiceApi();
            var graphId = graphId_example;  // String |  (default to null)

            try {
                ServiceStatus result = apiInstance.getServiceStatusById(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServiceApi.getServiceStatusById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServiceApi();
$graphId = graphId_example; // String | 

try {
    $result = $api_instance->getServiceStatusById($graphId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServiceApi->getServiceStatusById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServiceApi->new();
my $graphId = graphId_example; # String | 

eval {
    my $result = $api_instance->getServiceStatusById(graphId => $graphId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServiceApi->getServiceStatusById: $@\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.ServiceApi()
graphId = graphId_example # String |  (default to null)

try:
    api_response = api_instance.get_service_status_by_id(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServiceApi->getServiceStatusById: %s\n" % e)

extern crate ServiceApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = ServiceApi::Context::default();
    let result = client.getServiceStatusById(graphId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Responses

Schema

Schema

listServiceStatus

List all service status

/api/v1/service

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/service"

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

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

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

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

        try {
            array[ServiceStatus] result = apiInstance.listServiceStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#listServiceStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ServiceApi;

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

        try {
            array[ServiceStatus] result = apiInstance.listServiceStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServiceApi#listServiceStatus");
            e.printStackTrace();
        }
    }
}



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

[apiInstance listServiceStatusWithCompletionHandler: 
              ^(array[ServiceStatus] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.ServiceApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listServiceStatus(callback);

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

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

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

            try {
                array[ServiceStatus] result = apiInstance.listServiceStatus();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServiceApi.listServiceStatus: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.list_service_status()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServiceApi->listServiceStatus: %s\n" % e)

extern crate ServiceApi;

pub fn main() {

    let mut context = ServiceApi::Context::default();
    let result = client.listServiceStatus(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

restartService

Restart current service

/api/v1/service/restart

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost/api/v1/service/restart"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ServiceApi;

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

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



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

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.ServiceApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.restartService(callback);

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.restart_service()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServiceApi->restartService: %s\n" % e)

extern crate ServiceApi;

pub fn main() {

    let mut context = ServiceApi::Context::default();
    let result = client.restartService(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

startService

Start service

/api/v1/service/start

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/service/start" \
 -d '{
  "graph_id" : "graph_id"
}'

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

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

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

        // Create an instance of the API class
        ServiceApi apiInstance = new ServiceApi();
        StartServiceRequest startServiceRequest = ; // StartServiceRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final StartServiceRequest startServiceRequest = new StartServiceRequest(); // StartServiceRequest | 

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

import org.openapitools.client.api.ServiceApi;

public class ServiceApiExample {
    public static void main(String[] args) {
        ServiceApi apiInstance = new ServiceApi();
        StartServiceRequest startServiceRequest = ; // StartServiceRequest | 

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



// Create an instance of the API class
ServiceApi *apiInstance = [[ServiceApi alloc] init];
StartServiceRequest *startServiceRequest = ; //  (optional)

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.ServiceApi()
var opts = {
  'startServiceRequest':  // {StartServiceRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ServiceApi();
            var startServiceRequest = new StartServiceRequest(); // StartServiceRequest |  (optional) 

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServiceApi();
$startServiceRequest = ; // StartServiceRequest | 

try {
    $result = $api_instance->startService($startServiceRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServiceApi->startService: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServiceApi->new();
my $startServiceRequest = WWW::OPenAPIClient::Object::StartServiceRequest->new(); # StartServiceRequest | 

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

try:
    api_response = api_instance.start_service(startServiceRequest=startServiceRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServiceApi->startService: %s\n" % e)

extern crate ServiceApi;

pub fn main() {
    let startServiceRequest = ; // StartServiceRequest

    let mut context = ServiceApi::Context::default();
    let result = client.startService(startServiceRequest, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
startServiceRequest

Responses

Schema

Schema

Schema

stopService

Stop current service

/api/v1/service/stop

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost/api/v1/service/stop"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ServiceApi;

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

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



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

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.ServiceApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.stopService(callback);

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.stop_service()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServiceApi->stopService: %s\n" % e)

extern crate ServiceApi;

pub fn main() {

    let mut context = ServiceApi::Context::default();
    let result = client.stopService(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

StoredProcedure

createStoredProcedure

Create a new stored procedure on a certain graph

/api/v1/graph/{graph_id}/storedproc

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/storedproc" \
 -d '{
  "query" : "query",
  "name" : "name",
  "description" : "description",
  "type" : "cpp"
}'

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

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

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

        // Create an instance of the API class
        StoredProcedureApi apiInstance = new StoredProcedureApi();
        String graphId = graphId_example; // String | 
        CreateStoredProcRequest createStoredProcRequest = ; // CreateStoredProcRequest | 

        try {
            CreateStoredProcResponse result = apiInstance.createStoredProcedure(graphId, createStoredProcRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StoredProcedureApi#createStoredProcedure");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final CreateStoredProcRequest createStoredProcRequest = new CreateStoredProcRequest(); // CreateStoredProcRequest | 

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

import org.openapitools.client.api.StoredProcedureApi;

public class StoredProcedureApiExample {
    public static void main(String[] args) {
        StoredProcedureApi apiInstance = new StoredProcedureApi();
        String graphId = graphId_example; // String | 
        CreateStoredProcRequest createStoredProcRequest = ; // CreateStoredProcRequest | 

        try {
            CreateStoredProcResponse result = apiInstance.createStoredProcedure(graphId, createStoredProcRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StoredProcedureApi#createStoredProcedure");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
StoredProcedureApi *apiInstance = [[StoredProcedureApi alloc] init];
String *graphId = graphId_example; //  (default to null)
CreateStoredProcRequest *createStoredProcRequest = ; // 

[apiInstance createStoredProcedureWith:graphId
    createStoredProcRequest:createStoredProcRequest
              completionHandler: ^(CreateStoredProcResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.StoredProcedureApi()
var graphId = graphId_example; // {String} 
var createStoredProcRequest = ; // {CreateStoredProcRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new StoredProcedureApi();
            var graphId = graphId_example;  // String |  (default to null)
            var createStoredProcRequest = new CreateStoredProcRequest(); // CreateStoredProcRequest | 

            try {
                CreateStoredProcResponse result = apiInstance.createStoredProcedure(graphId, createStoredProcRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling StoredProcedureApi.createStoredProcedure: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\StoredProcedureApi();
$graphId = graphId_example; // String | 
$createStoredProcRequest = ; // CreateStoredProcRequest | 

try {
    $result = $api_instance->createStoredProcedure($graphId, $createStoredProcRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling StoredProcedureApi->createStoredProcedure: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::StoredProcedureApi->new();
my $graphId = graphId_example; # String | 
my $createStoredProcRequest = WWW::OPenAPIClient::Object::CreateStoredProcRequest->new(); # CreateStoredProcRequest | 

eval {
    my $result = $api_instance->createStoredProcedure(graphId => $graphId, createStoredProcRequest => $createStoredProcRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling StoredProcedureApi->createStoredProcedure: $@\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.StoredProcedureApi()
graphId = graphId_example # String |  (default to null)
createStoredProcRequest =  # CreateStoredProcRequest | 

try:
    api_response = api_instance.create_stored_procedure(graphId, createStoredProcRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StoredProcedureApi->createStoredProcedure: %s\n" % e)

extern crate StoredProcedureApi;

pub fn main() {
    let graphId = graphId_example; // String
    let createStoredProcRequest = ; // CreateStoredProcRequest

    let mut context = StoredProcedureApi::Context::default();
    let result = client.createStoredProcedure(graphId, createStoredProcRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Body parameters

Name	Description
createStoredProcRequest *

Responses

Schema

Schema

Schema

deleteStoredProcedureById

Delete a stored procedure by ID

/api/v1/graph/{graph_id}/storedproc/{stored_procedure_id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/storedproc/{stored_procedure_id}"

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

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

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

        // Create an instance of the API class
        StoredProcedureApi apiInstance = new StoredProcedureApi();
        String graphId = graphId_example; // String | 
        String storedProcedureId = storedProcedureId_example; // String | 

        try {
            'String' result = apiInstance.deleteStoredProcedureById(graphId, storedProcedureId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StoredProcedureApi#deleteStoredProcedureById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String storedProcedureId = new String(); // String | 

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

import org.openapitools.client.api.StoredProcedureApi;

public class StoredProcedureApiExample {
    public static void main(String[] args) {
        StoredProcedureApi apiInstance = new StoredProcedureApi();
        String graphId = graphId_example; // String | 
        String storedProcedureId = storedProcedureId_example; // String | 

        try {
            'String' result = apiInstance.deleteStoredProcedureById(graphId, storedProcedureId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StoredProcedureApi#deleteStoredProcedureById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
StoredProcedureApi *apiInstance = [[StoredProcedureApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *storedProcedureId = storedProcedureId_example; //  (default to null)

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.StoredProcedureApi()
var graphId = graphId_example; // {String} 
var storedProcedureId = storedProcedureId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new StoredProcedureApi();
            var graphId = graphId_example;  // String |  (default to null)
            var storedProcedureId = storedProcedureId_example;  // String |  (default to null)

            try {
                'String' result = apiInstance.deleteStoredProcedureById(graphId, storedProcedureId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling StoredProcedureApi.deleteStoredProcedureById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\StoredProcedureApi();
$graphId = graphId_example; // String | 
$storedProcedureId = storedProcedureId_example; // String | 

try {
    $result = $api_instance->deleteStoredProcedureById($graphId, $storedProcedureId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling StoredProcedureApi->deleteStoredProcedureById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::StoredProcedureApi->new();
my $graphId = graphId_example; # String | 
my $storedProcedureId = storedProcedureId_example; # String | 

eval {
    my $result = $api_instance->deleteStoredProcedureById(graphId => $graphId, storedProcedureId => $storedProcedureId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling StoredProcedureApi->deleteStoredProcedureById: $@\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.StoredProcedureApi()
graphId = graphId_example # String |  (default to null)
storedProcedureId = storedProcedureId_example # String |  (default to null)

try:
    api_response = api_instance.delete_stored_procedure_by_id(graphId, storedProcedureId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StoredProcedureApi->deleteStoredProcedureById: %s\n" % e)

extern crate StoredProcedureApi;

pub fn main() {
    let graphId = graphId_example; // String
    let storedProcedureId = storedProcedureId_example; // String

    let mut context = StoredProcedureApi::Context::default();
    let result = client.deleteStoredProcedureById(graphId, storedProcedureId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required
stored_procedure_id*	String Required

Responses

Schema

Schema

getStoredProcedureById

Get a stored procedure by ID

/api/v1/graph/{graph_id}/storedproc/{stored_procedure_id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/storedproc/{stored_procedure_id}"

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

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

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

        // Create an instance of the API class
        StoredProcedureApi apiInstance = new StoredProcedureApi();
        String graphId = graphId_example; // String | 
        String storedProcedureId = storedProcedureId_example; // String | 

        try {
            GetStoredProcResponse result = apiInstance.getStoredProcedureById(graphId, storedProcedureId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StoredProcedureApi#getStoredProcedureById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String storedProcedureId = new String(); // String | 

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

import org.openapitools.client.api.StoredProcedureApi;

public class StoredProcedureApiExample {
    public static void main(String[] args) {
        StoredProcedureApi apiInstance = new StoredProcedureApi();
        String graphId = graphId_example; // String | 
        String storedProcedureId = storedProcedureId_example; // String | 

        try {
            GetStoredProcResponse result = apiInstance.getStoredProcedureById(graphId, storedProcedureId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StoredProcedureApi#getStoredProcedureById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
StoredProcedureApi *apiInstance = [[StoredProcedureApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *storedProcedureId = storedProcedureId_example; //  (default to null)

[apiInstance getStoredProcedureByIdWith:graphId
    storedProcedureId:storedProcedureId
              completionHandler: ^(GetStoredProcResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.StoredProcedureApi()
var graphId = graphId_example; // {String} 
var storedProcedureId = storedProcedureId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new StoredProcedureApi();
            var graphId = graphId_example;  // String |  (default to null)
            var storedProcedureId = storedProcedureId_example;  // String |  (default to null)

            try {
                GetStoredProcResponse result = apiInstance.getStoredProcedureById(graphId, storedProcedureId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling StoredProcedureApi.getStoredProcedureById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\StoredProcedureApi();
$graphId = graphId_example; // String | 
$storedProcedureId = storedProcedureId_example; // String | 

try {
    $result = $api_instance->getStoredProcedureById($graphId, $storedProcedureId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling StoredProcedureApi->getStoredProcedureById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::StoredProcedureApi->new();
my $graphId = graphId_example; # String | 
my $storedProcedureId = storedProcedureId_example; # String | 

eval {
    my $result = $api_instance->getStoredProcedureById(graphId => $graphId, storedProcedureId => $storedProcedureId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling StoredProcedureApi->getStoredProcedureById: $@\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.StoredProcedureApi()
graphId = graphId_example # String |  (default to null)
storedProcedureId = storedProcedureId_example # String |  (default to null)

try:
    api_response = api_instance.get_stored_procedure_by_id(graphId, storedProcedureId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StoredProcedureApi->getStoredProcedureById: %s\n" % e)

extern crate StoredProcedureApi;

pub fn main() {
    let graphId = graphId_example; // String
    let storedProcedureId = storedProcedureId_example; // String

    let mut context = StoredProcedureApi::Context::default();
    let result = client.getStoredProcedureById(graphId, storedProcedureId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required
stored_procedure_id*	String Required

Responses

Schema

Schema

listStoredProcedures

List all stored procedures on a certain graph

/api/v1/graph/{graph_id}/storedproc

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/storedproc"

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

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

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

        // Create an instance of the API class
        StoredProcedureApi apiInstance = new StoredProcedureApi();
        String graphId = graphId_example; // String | 

        try {
            array[GetStoredProcResponse] result = apiInstance.listStoredProcedures(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StoredProcedureApi#listStoredProcedures");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.StoredProcedureApi;

public class StoredProcedureApiExample {
    public static void main(String[] args) {
        StoredProcedureApi apiInstance = new StoredProcedureApi();
        String graphId = graphId_example; // String | 

        try {
            array[GetStoredProcResponse] result = apiInstance.listStoredProcedures(graphId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StoredProcedureApi#listStoredProcedures");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
StoredProcedureApi *apiInstance = [[StoredProcedureApi alloc] init];
String *graphId = graphId_example; //  (default to null)

[apiInstance listStoredProceduresWith:graphId
              completionHandler: ^(array[GetStoredProcResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.StoredProcedureApi()
var graphId = graphId_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new StoredProcedureApi();
            var graphId = graphId_example;  // String |  (default to null)

            try {
                array[GetStoredProcResponse] result = apiInstance.listStoredProcedures(graphId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling StoredProcedureApi.listStoredProcedures: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\StoredProcedureApi();
$graphId = graphId_example; // String | 

try {
    $result = $api_instance->listStoredProcedures($graphId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling StoredProcedureApi->listStoredProcedures: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::StoredProcedureApi->new();
my $graphId = graphId_example; # String | 

eval {
    my $result = $api_instance->listStoredProcedures(graphId => $graphId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling StoredProcedureApi->listStoredProcedures: $@\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.StoredProcedureApi()
graphId = graphId_example # String |  (default to null)

try:
    api_response = api_instance.list_stored_procedures(graphId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StoredProcedureApi->listStoredProcedures: %s\n" % e)

extern crate StoredProcedureApi;

pub fn main() {
    let graphId = graphId_example; // String

    let mut context = StoredProcedureApi::Context::default();
    let result = client.listStoredProcedures(graphId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required

Responses

Schema

Schema

Schema

updateStoredProcedureById

Update a stored procedure by ID

/api/v1/graph/{graph_id}/storedproc/{stored_procedure_id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/api/v1/graph/{graph_id}/storedproc/{stored_procedure_id}" \
 -d '{
  "description" : "description"
}'

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

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

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

        // Create an instance of the API class
        StoredProcedureApi apiInstance = new StoredProcedureApi();
        String graphId = graphId_example; // String | 
        String storedProcedureId = storedProcedureId_example; // String | 
        UpdateStoredProcRequest updateStoredProcRequest = ; // UpdateStoredProcRequest | 

        try {
            'String' result = apiInstance.updateStoredProcedureById(graphId, storedProcedureId, updateStoredProcRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StoredProcedureApi#updateStoredProcedureById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String graphId = new String(); // String | 
final String storedProcedureId = new String(); // String | 
final UpdateStoredProcRequest updateStoredProcRequest = new UpdateStoredProcRequest(); // UpdateStoredProcRequest | 

try {
    final result = await api_instance.updateStoredProcedureById(graphId, storedProcedureId, updateStoredProcRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateStoredProcedureById: $e\n');
}

import org.openapitools.client.api.StoredProcedureApi;

public class StoredProcedureApiExample {
    public static void main(String[] args) {
        StoredProcedureApi apiInstance = new StoredProcedureApi();
        String graphId = graphId_example; // String | 
        String storedProcedureId = storedProcedureId_example; // String | 
        UpdateStoredProcRequest updateStoredProcRequest = ; // UpdateStoredProcRequest | 

        try {
            'String' result = apiInstance.updateStoredProcedureById(graphId, storedProcedureId, updateStoredProcRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StoredProcedureApi#updateStoredProcedureById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
StoredProcedureApi *apiInstance = [[StoredProcedureApi alloc] init];
String *graphId = graphId_example; //  (default to null)
String *storedProcedureId = storedProcedureId_example; //  (default to null)
UpdateStoredProcRequest *updateStoredProcRequest = ; //  (optional)

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

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.StoredProcedureApi()
var graphId = graphId_example; // {String} 
var storedProcedureId = storedProcedureId_example; // {String} 
var opts = {
  'updateStoredProcRequest':  // {UpdateStoredProcRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new StoredProcedureApi();
            var graphId = graphId_example;  // String |  (default to null)
            var storedProcedureId = storedProcedureId_example;  // String |  (default to null)
            var updateStoredProcRequest = new UpdateStoredProcRequest(); // UpdateStoredProcRequest |  (optional) 

            try {
                'String' result = apiInstance.updateStoredProcedureById(graphId, storedProcedureId, updateStoredProcRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling StoredProcedureApi.updateStoredProcedureById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\StoredProcedureApi();
$graphId = graphId_example; // String | 
$storedProcedureId = storedProcedureId_example; // String | 
$updateStoredProcRequest = ; // UpdateStoredProcRequest | 

try {
    $result = $api_instance->updateStoredProcedureById($graphId, $storedProcedureId, $updateStoredProcRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling StoredProcedureApi->updateStoredProcedureById: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::StoredProcedureApi->new();
my $graphId = graphId_example; # String | 
my $storedProcedureId = storedProcedureId_example; # String | 
my $updateStoredProcRequest = WWW::OPenAPIClient::Object::UpdateStoredProcRequest->new(); # UpdateStoredProcRequest | 

eval {
    my $result = $api_instance->updateStoredProcedureById(graphId => $graphId, storedProcedureId => $storedProcedureId, updateStoredProcRequest => $updateStoredProcRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling StoredProcedureApi->updateStoredProcedureById: $@\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.StoredProcedureApi()
graphId = graphId_example # String |  (default to null)
storedProcedureId = storedProcedureId_example # String |  (default to null)
updateStoredProcRequest =  # UpdateStoredProcRequest |  (optional)

try:
    api_response = api_instance.update_stored_procedure_by_id(graphId, storedProcedureId, updateStoredProcRequest=updateStoredProcRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StoredProcedureApi->updateStoredProcedureById: %s\n" % e)

extern crate StoredProcedureApi;

pub fn main() {
    let graphId = graphId_example; // String
    let storedProcedureId = storedProcedureId_example; // String
    let updateStoredProcRequest = ; // UpdateStoredProcRequest

    let mut context = StoredProcedureApi::Context::default();
    let result = client.updateStoredProcedureById(graphId, storedProcedureId, updateStoredProcRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
graph_id*	String Required
stored_procedure_id*	String Required

Body parameters

Name	Description
updateStoredProcRequest

Responses

Schema

Schema

Utils

uploadFile

/api/v1/file/uploading

Usage and SDK Samples

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

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

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

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

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

        try {
            UploadFileResponse result = apiInstance.uploadFile(filestorage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilsApi#uploadFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.UtilsApi;

public class UtilsApiExample {
    public static void main(String[] args) {
        UtilsApi apiInstance = new UtilsApi();
        File filestorage = BINARY_DATA_HERE; // File | 

        try {
            UploadFileResponse result = apiInstance.uploadFile(filestorage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilsApi#uploadFile");
            e.printStackTrace();
        }
    }
}



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

[apiInstance uploadFileWith:filestorage
              completionHandler: ^(UploadFileResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var GraphScopeFlexHttpServiceApi = require('graph_scope_flex_http_service_api');

// Create an instance of the API class
var api = new GraphScopeFlexHttpServiceApi.UtilsApi()
var opts = {
  'filestorage': BINARY_DATA_HERE // {File} 
};

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

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

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

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

            try {
                UploadFileResponse result = apiInstance.uploadFile(filestorage);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UtilsApi.uploadFile: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->uploadFile($filestorage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UtilsApi->uploadFile: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    my $result = $api_instance->uploadFile(filestorage => $filestorage);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UtilsApi->uploadFile: $@\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.UtilsApi()
filestorage = BINARY_DATA_HERE # File |  (optional) (default to null)

try:
    api_response = api_instance.upload_file(filestorage=filestorage)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UtilsApi->uploadFile: %s\n" % e)

extern crate UtilsApi;

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

    let mut context = UtilsApi::Context::default();
    let result = client.uploadFile(filestorage, &context).wait();

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

Scopes

Parameters

Form parameters

Name	Description
filestorage	File (binary)

Responses

Schema

Schema

GraphScope FLEX HTTP SERVICE API

API and SDK Documentation

Alert

createAlertReceiver

Usage and SDK Samples

Scopes

Parameters

Responses

delete alert rule by ID

Usage and SDK Samples

Scopes

Parameters

Responses

deleteAlertMessageInBatch

Usage and SDK Samples

Scopes

Parameters

Responses

deleteAlertReceiverById

Usage and SDK Samples

Scopes

Parameters

Responses

listAlertMessages

Usage and SDK Samples

Scopes

Parameters

Responses

listAlertReceivers

Usage and SDK Samples

Scopes

Parameters

Responses

listAlertRules

Usage and SDK Samples

Scopes

Parameters

Responses

update alert rule by ID

Usage and SDK Samples

Scopes

Parameters

Responses

updateAlertMessageInBatch

Usage and SDK Samples

Scopes

Parameters

Responses

updateAlertReceiverById

Usage and SDK Samples

Scopes

Parameters

Responses

DataSource

bindDatasourceInBatch

Usage and SDK Samples

Scopes

Parameters

Responses

getDatasourceById

Usage and SDK Samples

Scopes

Parameters

Responses

unbindEdgeDatasource

Usage and SDK Samples

Scopes

Parameters

Responses

unbindVertexDatasource

Usage and SDK Samples

Scopes

Parameters

Responses

Deployment

getDeploymentInfo

Usage and SDK Samples

Scopes

Parameters

Responses