X-Content-Type-Options: nosniff

Scout Web API

Missions

missionsGet

Retrieves a complete list of mission information on the sitehub.


/missions

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/missions"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MissionsApi;

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

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

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

        try {
            array[Mission] result = apiInstance.missionsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionsApi#missionsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MissionsApi;

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

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


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

// Retrieves a complete list of mission information on the sitehub.
[apiInstance missionsGetWithCompletionHandler: 
              ^(array[Mission] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

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

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

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

            try {
                // Retrieves a complete list of mission information on the sitehub.
                array[Mission] result = apiInstance.missionsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MissionsApi.missionsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Retrieves a complete list of mission information on the sitehub.
    api_response = api_instance.missions_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MissionsApi->missionsGet: %s\n" % e)
extern crate MissionsApi;

pub fn main() {

    let mut context = MissionsApi::Context::default();
    let result = client.missionsGet(&context).wait();

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

Scopes

Parameters

Responses


missionsMissionIdDelete

Removes the specified mission.


/missions/{missionId}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost/missions/{missionId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MissionsApi;

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

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

        // Create an instance of the API class
        MissionsApi apiInstance = new MissionsApi();
        String missionId = missionId_example; // String | ID of the mission. This should match the uuid field of the mission resource.

        try {
            apiInstance.missionsMissionIdDelete(missionId);
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionsApi#missionsMissionIdDelete");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.MissionsApi;

public class MissionsApiExample {
    public static void main(String[] args) {
        MissionsApi apiInstance = new MissionsApi();
        String missionId = missionId_example; // String | ID of the mission. This should match the uuid field of the mission resource.

        try {
            apiInstance.missionsMissionIdDelete(missionId);
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionsApi#missionsMissionIdDelete");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
MissionsApi *apiInstance = [[MissionsApi alloc] init];
String *missionId = missionId_example; // ID of the mission. This should match the uuid field of the mission resource. (default to null)

// Removes the specified mission.
[apiInstance missionsMissionIdDeleteWith:missionId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

// Create an instance of the API class
var api = new ScoutWebApi.MissionsApi()
var missionId = missionId_example; // {String} ID of the mission. This should match the uuid field of the mission resource.

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

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

            // Create an instance of the API class
            var apiInstance = new MissionsApi();
            var missionId = missionId_example;  // String | ID of the mission. This should match the uuid field of the mission resource. (default to null)

            try {
                // Removes the specified mission.
                apiInstance.missionsMissionIdDelete(missionId);
            } catch (Exception e) {
                Debug.Print("Exception when calling MissionsApi.missionsMissionIdDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MissionsApi();
$missionId = missionId_example; // String | ID of the mission. This should match the uuid field of the mission resource.

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MissionsApi->new();
my $missionId = missionId_example; # String | ID of the mission. This should match the uuid field of the mission resource.

eval {
    $api_instance->missionsMissionIdDelete(missionId => $missionId);
};
if ($@) {
    warn "Exception when calling MissionsApi->missionsMissionIdDelete: $@\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.MissionsApi()
missionId = missionId_example # String | ID of the mission. This should match the uuid field of the mission resource. (default to null)

try:
    # Removes the specified mission.
    api_instance.missions_mission_id_delete(missionId)
except ApiException as e:
    print("Exception when calling MissionsApi->missionsMissionIdDelete: %s\n" % e)
extern crate MissionsApi;

pub fn main() {
    let missionId = missionId_example; // String

    let mut context = MissionsApi::Context::default();
    let result = client.missionsMissionIdDelete(missionId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
missionId*
String
ID of the mission. This should match the uuid field of the mission resource.
Required

Responses


missionsMissionIdGet

Retrieves information about a single mission.


/missions/{missionId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/missions/{missionId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MissionsApi;

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

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

        // Create an instance of the API class
        MissionsApi apiInstance = new MissionsApi();
        String missionId = missionId_example; // String | ID of the mission. This should match the uuid field of the mission resource.

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

public class MissionsApiExample {
    public static void main(String[] args) {
        MissionsApi apiInstance = new MissionsApi();
        String missionId = missionId_example; // String | ID of the mission. This should match the uuid field of the mission resource.

        try {
            Mission result = apiInstance.missionsMissionIdGet(missionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MissionsApi#missionsMissionIdGet");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
MissionsApi *apiInstance = [[MissionsApi alloc] init];
String *missionId = missionId_example; // ID of the mission. This should match the uuid field of the mission resource. (default to null)

// Retrieves information about a single mission.
[apiInstance missionsMissionIdGetWith:missionId
              completionHandler: ^(Mission output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

// Create an instance of the API class
var api = new ScoutWebApi.MissionsApi()
var missionId = missionId_example; // {String} ID of the mission. This should match the uuid field of the mission resource.

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

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

            // Create an instance of the API class
            var apiInstance = new MissionsApi();
            var missionId = missionId_example;  // String | ID of the mission. This should match the uuid field of the mission resource. (default to null)

            try {
                // Retrieves information about a single mission.
                Mission result = apiInstance.missionsMissionIdGet(missionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MissionsApi.missionsMissionIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MissionsApi();
$missionId = missionId_example; // String | ID of the mission. This should match the uuid field of the mission resource.

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MissionsApi->new();
my $missionId = missionId_example; # String | ID of the mission. This should match the uuid field of the mission resource.

eval {
    my $result = $api_instance->missionsMissionIdGet(missionId => $missionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MissionsApi->missionsMissionIdGet: $@\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.MissionsApi()
missionId = missionId_example # String | ID of the mission. This should match the uuid field of the mission resource. (default to null)

try:
    # Retrieves information about a single mission.
    api_response = api_instance.missions_mission_id_get(missionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MissionsApi->missionsMissionIdGet: %s\n" % e)
extern crate MissionsApi;

pub fn main() {
    let missionId = missionId_example; // String

    let mut context = MissionsApi::Context::default();
    let result = client.missionsMissionIdGet(missionId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
missionId*
String
ID of the mission. This should match the uuid field of the mission resource.
Required

Responses


Robots

robotsGet

Retrieves a complete list of robot information on the sitehub. This includes which robot is assigned to each slot.


/robots

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/robots"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RobotsApi;

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

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

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

        try {
            array[Robot] result = apiInstance.robotsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RobotsApi#robotsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RobotsApi;

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

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


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

// Retrieves a complete list of robot information on the sitehub. This includes which robot is assigned to each slot.
[apiInstance robotsGetWithCompletionHandler: 
              ^(array[Robot] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

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

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

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

            try {
                // Retrieves a complete list of robot information on the sitehub. This includes which robot is assigned to each slot.
                array[Robot] result = apiInstance.robotsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RobotsApi.robotsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Retrieves a complete list of robot information on the sitehub. This includes which robot is assigned to each slot.
    api_response = api_instance.robots_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RobotsApi->robotsGet: %s\n" % e)
extern crate RobotsApi;

pub fn main() {

    let mut context = RobotsApi::Context::default();
    let result = client.robotsGet(&context).wait();

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

Scopes

Parameters

Responses


robotsPost

Adds a new robot to Scout.


/robots

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/robots" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RobotsApi;

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

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

        // Create an instance of the API class
        RobotsApi apiInstance = new RobotsApi();
        RobotsGetRequest robotsGetRequest = ; // RobotsGetRequest | 

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

public class RobotsApiExample {
    public static void main(String[] args) {
        RobotsApi apiInstance = new RobotsApi();
        RobotsGetRequest robotsGetRequest = ; // RobotsGetRequest | 

        try {
            _robots_get_200_response result = apiInstance.robotsPost(robotsGetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RobotsApi#robotsPost");
            e.printStackTrace();
        }
    }
}


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

// Adds a new robot to Scout.
[apiInstance robotsPostWith:robotsGetRequest
              completionHandler: ^(_robots_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

// Create an instance of the API class
var api = new ScoutWebApi.RobotsApi()
var robotsGetRequest = ; // {RobotsGetRequest} 

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

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

            // Create an instance of the API class
            var apiInstance = new RobotsApi();
            var robotsGetRequest = new RobotsGetRequest(); // RobotsGetRequest | 

            try {
                // Adds a new robot to Scout.
                _robots_get_200_response result = apiInstance.robotsPost(robotsGetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RobotsApi.robotsPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RobotsApi();
$robotsGetRequest = ; // RobotsGetRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RobotsApi->new();
my $robotsGetRequest = WWW::OPenAPIClient::Object::RobotsGetRequest->new(); # RobotsGetRequest | 

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

try:
    # Adds a new robot to Scout.
    api_response = api_instance.robots_post(robotsGetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RobotsApi->robotsPost: %s\n" % e)
extern crate RobotsApi;

pub fn main() {
    let robotsGetRequest = ; // RobotsGetRequest

    let mut context = RobotsApi::Context::default();
    let result = client.robotsPost(robotsGetRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
robotsGetRequest *

Information of a new robot in Scout.

Responses


robotsRobotHostnameDelete

Removes the specified robot.


/robots/{robotHostname}

Usage and SDK Samples

curl -X DELETE \
 "http://localhost/robots/{robotHostname}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RobotsApi;

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

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

        // Create an instance of the API class
        RobotsApi apiInstance = new RobotsApi();
        String robotHostname = robotHostname_example; // String | Hostname of the robot. This should match the hostname field of the robot resource.

        try {
            apiInstance.robotsRobotHostnameDelete(robotHostname);
        } catch (ApiException e) {
            System.err.println("Exception when calling RobotsApi#robotsRobotHostnameDelete");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RobotsApi;

public class RobotsApiExample {
    public static void main(String[] args) {
        RobotsApi apiInstance = new RobotsApi();
        String robotHostname = robotHostname_example; // String | Hostname of the robot. This should match the hostname field of the robot resource.

        try {
            apiInstance.robotsRobotHostnameDelete(robotHostname);
        } catch (ApiException e) {
            System.err.println("Exception when calling RobotsApi#robotsRobotHostnameDelete");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RobotsApi *apiInstance = [[RobotsApi alloc] init];
String *robotHostname = robotHostname_example; // Hostname of the robot. This should match the hostname field of the robot resource. (default to null)

// Removes the specified robot.
[apiInstance robotsRobotHostnameDeleteWith:robotHostname
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

// Create an instance of the API class
var api = new ScoutWebApi.RobotsApi()
var robotHostname = robotHostname_example; // {String} Hostname of the robot. This should match the hostname field of the robot resource.

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

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

            // Create an instance of the API class
            var apiInstance = new RobotsApi();
            var robotHostname = robotHostname_example;  // String | Hostname of the robot. This should match the hostname field of the robot resource. (default to null)

            try {
                // Removes the specified robot.
                apiInstance.robotsRobotHostnameDelete(robotHostname);
            } catch (Exception e) {
                Debug.Print("Exception when calling RobotsApi.robotsRobotHostnameDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RobotsApi();
$robotHostname = robotHostname_example; // String | Hostname of the robot. This should match the hostname field of the robot resource.

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RobotsApi->new();
my $robotHostname = robotHostname_example; # String | Hostname of the robot. This should match the hostname field of the robot resource.

eval {
    $api_instance->robotsRobotHostnameDelete(robotHostname => $robotHostname);
};
if ($@) {
    warn "Exception when calling RobotsApi->robotsRobotHostnameDelete: $@\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.RobotsApi()
robotHostname = robotHostname_example # String | Hostname of the robot. This should match the hostname field of the robot resource. (default to null)

try:
    # Removes the specified robot.
    api_instance.robots_robot_hostname_delete(robotHostname)
except ApiException as e:
    print("Exception when calling RobotsApi->robotsRobotHostnameDelete: %s\n" % e)
extern crate RobotsApi;

pub fn main() {
    let robotHostname = robotHostname_example; // String

    let mut context = RobotsApi::Context::default();
    let result = client.robotsRobotHostnameDelete(robotHostname, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
robotHostname*
String
Hostname of the robot. This should match the hostname field of the robot resource.
Required

Responses


robotsRobotHostnameGet

Retrieves information about a single robot.


/robots/{robotHostname}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/robots/{robotHostname}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RobotsApi;

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

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

        // Create an instance of the API class
        RobotsApi apiInstance = new RobotsApi();
        String robotHostname = robotHostname_example; // String | Hostname of the robot. This should match the hostname field of the robot resource.

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

public class RobotsApiExample {
    public static void main(String[] args) {
        RobotsApi apiInstance = new RobotsApi();
        String robotHostname = robotHostname_example; // String | Hostname of the robot. This should match the hostname field of the robot resource.

        try {
            Robot result = apiInstance.robotsRobotHostnameGet(robotHostname);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RobotsApi#robotsRobotHostnameGet");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RobotsApi *apiInstance = [[RobotsApi alloc] init];
String *robotHostname = robotHostname_example; // Hostname of the robot. This should match the hostname field of the robot resource. (default to null)

// Retrieves information about a single robot.
[apiInstance robotsRobotHostnameGetWith:robotHostname
              completionHandler: ^(Robot output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

// Create an instance of the API class
var api = new ScoutWebApi.RobotsApi()
var robotHostname = robotHostname_example; // {String} Hostname of the robot. This should match the hostname field of the robot resource.

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

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

            // Create an instance of the API class
            var apiInstance = new RobotsApi();
            var robotHostname = robotHostname_example;  // String | Hostname of the robot. This should match the hostname field of the robot resource. (default to null)

            try {
                // Retrieves information about a single robot.
                Robot result = apiInstance.robotsRobotHostnameGet(robotHostname);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RobotsApi.robotsRobotHostnameGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RobotsApi();
$robotHostname = robotHostname_example; // String | Hostname of the robot. This should match the hostname field of the robot resource.

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RobotsApi->new();
my $robotHostname = robotHostname_example; # String | Hostname of the robot. This should match the hostname field of the robot resource.

eval {
    my $result = $api_instance->robotsRobotHostnameGet(robotHostname => $robotHostname);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RobotsApi->robotsRobotHostnameGet: $@\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.RobotsApi()
robotHostname = robotHostname_example # String | Hostname of the robot. This should match the hostname field of the robot resource. (default to null)

try:
    # Retrieves information about a single robot.
    api_response = api_instance.robots_robot_hostname_get(robotHostname)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RobotsApi->robotsRobotHostnameGet: %s\n" % e)
extern crate RobotsApi;

pub fn main() {
    let robotHostname = robotHostname_example; // String

    let mut context = RobotsApi::Context::default();
    let result = client.robotsRobotHostnameGet(robotHostname, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
robotHostname*
String
Hostname of the robot. This should match the hostname field of the robot resource.
Required

Responses


RunArchives

runArchivesRunIdGet

Downloads a zip file containing a run's data.

All run events, images, and metadata for the given run are packaged into a zip file and downloaded upon this request. The result is similar to what can be downloaded from the tablet after mission execution.


/run_archives/{runId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/zip" \
 "http://localhost/run_archives/{runId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RunArchivesApi;

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

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

        // Create an instance of the API class
        RunArchivesApi apiInstance = new RunArchivesApi();
        String runId = runId_example; // String | ID of run

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

public class RunArchivesApiExample {
    public static void main(String[] args) {
        RunArchivesApi apiInstance = new RunArchivesApi();
        String runId = runId_example; // String | ID of run

        try {
            File result = apiInstance.runArchivesRunIdGet(runId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RunArchivesApi#runArchivesRunIdGet");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RunArchivesApi *apiInstance = [[RunArchivesApi alloc] init];
String *runId = runId_example; // ID of run (default to null)

// Downloads a zip file containing a run's data.
[apiInstance runArchivesRunIdGetWith:runId
              completionHandler: ^(File output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

// Create an instance of the API class
var api = new ScoutWebApi.RunArchivesApi()
var runId = runId_example; // {String} ID of run

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

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

            // Create an instance of the API class
            var apiInstance = new RunArchivesApi();
            var runId = runId_example;  // String | ID of run (default to null)

            try {
                // Downloads a zip file containing a run's data.
                File result = apiInstance.runArchivesRunIdGet(runId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RunArchivesApi.runArchivesRunIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RunArchivesApi();
$runId = runId_example; // String | ID of run

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RunArchivesApi->new();
my $runId = runId_example; # String | ID of run

eval {
    my $result = $api_instance->runArchivesRunIdGet(runId => $runId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RunArchivesApi->runArchivesRunIdGet: $@\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.RunArchivesApi()
runId = runId_example # String | ID of run (default to null)

try:
    # Downloads a zip file containing a run's data.
    api_response = api_instance.run_archives_run_id_get(runId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RunArchivesApi->runArchivesRunIdGet: %s\n" % e)
extern crate RunArchivesApi;

pub fn main() {
    let runId = runId_example; // String

    let mut context = RunArchivesApi::Context::default();
    let result = client.runArchivesRunIdGet(runId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
runId*
String
ID of run
Required

Responses


RunEvents

runEventsGet

Retrieve a collection of run events.

Returns a list of run events which match the provided query parameters. A run event describes a data collection action which took place during a run.


/run_events/

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/run_events/?uuid=uuid_example&runUuid=runUuid_example&actionUuid=actionUuid_example&missionName=missionName_example&startTime=2013-10-20T19:20:30+01:00&endTime=2013-10-20T19:20:30+01:00&startCreatedAt=2013-10-20T19:20:30+01:00&endCreatedAt=2013-10-20T19:20:30+01:00&limit=56&orderBy=orderBy_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RunEventsApi;

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

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

        // Create an instance of the API class
        RunEventsApi apiInstance = new RunEventsApi();
        String uuid = uuid_example; // String | Include run_events with this uuid.
        String runUuid = runUuid_example; // String | Include run_events which occurred during the run with this uuid.
        String actionUuid = actionUuid_example; // String | Include run_events which represent playback of actions with this uuid.
        String missionName = missionName_example; // String | Include run_events which occurred during playback of a mission with this name.
        Date startTime = 2013-10-20T19:20:30+01:00; // Date | Include run_events with a time greater than this value.
        Date endTime = 2013-10-20T19:20:30+01:00; // Date | Include run_events with a time less than this value.
        Date startCreatedAt = 2013-10-20T19:20:30+01:00; // Date | Include run_events with a created_at greater than this value.
        Date endCreatedAt = 2013-10-20T19:20:30+01:00; // Date | Include run_events with a created_at less than this value.
        Integer limit = 56; // Integer | Only return a number of resources up to this value.
        String orderBy = orderBy_example; // String | Criteria for ordering results.

        try {
            _run_events__get_200_response result = apiInstance.runEventsGet(uuid, runUuid, actionUuid, missionName, startTime, endTime, startCreatedAt, endCreatedAt, limit, orderBy);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RunEventsApi#runEventsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RunEventsApi;

public class RunEventsApiExample {
    public static void main(String[] args) {
        RunEventsApi apiInstance = new RunEventsApi();
        String uuid = uuid_example; // String | Include run_events with this uuid.
        String runUuid = runUuid_example; // String | Include run_events which occurred during the run with this uuid.
        String actionUuid = actionUuid_example; // String | Include run_events which represent playback of actions with this uuid.
        String missionName = missionName_example; // String | Include run_events which occurred during playback of a mission with this name.
        Date startTime = 2013-10-20T19:20:30+01:00; // Date | Include run_events with a time greater than this value.
        Date endTime = 2013-10-20T19:20:30+01:00; // Date | Include run_events with a time less than this value.
        Date startCreatedAt = 2013-10-20T19:20:30+01:00; // Date | Include run_events with a created_at greater than this value.
        Date endCreatedAt = 2013-10-20T19:20:30+01:00; // Date | Include run_events with a created_at less than this value.
        Integer limit = 56; // Integer | Only return a number of resources up to this value.
        String orderBy = orderBy_example; // String | Criteria for ordering results.

        try {
            _run_events__get_200_response result = apiInstance.runEventsGet(uuid, runUuid, actionUuid, missionName, startTime, endTime, startCreatedAt, endCreatedAt, limit, orderBy);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RunEventsApi#runEventsGet");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RunEventsApi *apiInstance = [[RunEventsApi alloc] init];
String *uuid = uuid_example; // Include run_events with this uuid. (optional) (default to null)
String *runUuid = runUuid_example; // Include run_events which occurred during the run with this uuid. (optional) (default to null)
String *actionUuid = actionUuid_example; // Include run_events which represent playback of actions with this uuid. (optional) (default to null)
String *missionName = missionName_example; // Include run_events which occurred during playback of a mission with this name. (optional) (default to null)
Date *startTime = 2013-10-20T19:20:30+01:00; // Include run_events with a time greater than this value. (optional) (default to null)
Date *endTime = 2013-10-20T19:20:30+01:00; // Include run_events with a time less than this value. (optional) (default to null)
Date *startCreatedAt = 2013-10-20T19:20:30+01:00; // Include run_events with a created_at greater than this value. (optional) (default to null)
Date *endCreatedAt = 2013-10-20T19:20:30+01:00; // Include run_events with a created_at less than this value. (optional) (default to null)
Integer *limit = 56; // Only return a number of resources up to this value. (optional) (default to 20)
String *orderBy = orderBy_example; // Criteria for ordering results. (optional) (default to null)

// Retrieve a collection of run events.
[apiInstance runEventsGetWith:uuid
    runUuid:runUuid
    actionUuid:actionUuid
    missionName:missionName
    startTime:startTime
    endTime:endTime
    startCreatedAt:startCreatedAt
    endCreatedAt:endCreatedAt
    limit:limit
    orderBy:orderBy
              completionHandler: ^(_run_events__get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

// Create an instance of the API class
var api = new ScoutWebApi.RunEventsApi()
var opts = {
  'uuid': uuid_example, // {String} Include run_events with this uuid.
  'runUuid': runUuid_example, // {String} Include run_events which occurred during the run with this uuid.
  'actionUuid': actionUuid_example, // {String} Include run_events which represent playback of actions with this uuid.
  'missionName': missionName_example, // {String} Include run_events which occurred during playback of a mission with this name.
  'startTime': 2013-10-20T19:20:30+01:00, // {Date} Include run_events with a time greater than this value.
  'endTime': 2013-10-20T19:20:30+01:00, // {Date} Include run_events with a time less than this value.
  'startCreatedAt': 2013-10-20T19:20:30+01:00, // {Date} Include run_events with a created_at greater than this value.
  'endCreatedAt': 2013-10-20T19:20:30+01:00, // {Date} Include run_events with a created_at less than this value.
  'limit': 56, // {Integer} Only return a number of resources up to this value.
  'orderBy': orderBy_example // {String} Criteria for ordering results.
};

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

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

            // Create an instance of the API class
            var apiInstance = new RunEventsApi();
            var uuid = uuid_example;  // String | Include run_events with this uuid. (optional)  (default to null)
            var runUuid = runUuid_example;  // String | Include run_events which occurred during the run with this uuid. (optional)  (default to null)
            var actionUuid = actionUuid_example;  // String | Include run_events which represent playback of actions with this uuid. (optional)  (default to null)
            var missionName = missionName_example;  // String | Include run_events which occurred during playback of a mission with this name. (optional)  (default to null)
            var startTime = 2013-10-20T19:20:30+01:00;  // Date | Include run_events with a time greater than this value. (optional)  (default to null)
            var endTime = 2013-10-20T19:20:30+01:00;  // Date | Include run_events with a time less than this value. (optional)  (default to null)
            var startCreatedAt = 2013-10-20T19:20:30+01:00;  // Date | Include run_events with a created_at greater than this value. (optional)  (default to null)
            var endCreatedAt = 2013-10-20T19:20:30+01:00;  // Date | Include run_events with a created_at less than this value. (optional)  (default to null)
            var limit = 56;  // Integer | Only return a number of resources up to this value. (optional)  (default to 20)
            var orderBy = orderBy_example;  // String | Criteria for ordering results. (optional)  (default to null)

            try {
                // Retrieve a collection of run events.
                _run_events__get_200_response result = apiInstance.runEventsGet(uuid, runUuid, actionUuid, missionName, startTime, endTime, startCreatedAt, endCreatedAt, limit, orderBy);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RunEventsApi.runEventsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RunEventsApi();
$uuid = uuid_example; // String | Include run_events with this uuid.
$runUuid = runUuid_example; // String | Include run_events which occurred during the run with this uuid.
$actionUuid = actionUuid_example; // String | Include run_events which represent playback of actions with this uuid.
$missionName = missionName_example; // String | Include run_events which occurred during playback of a mission with this name.
$startTime = 2013-10-20T19:20:30+01:00; // Date | Include run_events with a time greater than this value.
$endTime = 2013-10-20T19:20:30+01:00; // Date | Include run_events with a time less than this value.
$startCreatedAt = 2013-10-20T19:20:30+01:00; // Date | Include run_events with a created_at greater than this value.
$endCreatedAt = 2013-10-20T19:20:30+01:00; // Date | Include run_events with a created_at less than this value.
$limit = 56; // Integer | Only return a number of resources up to this value.
$orderBy = orderBy_example; // String | Criteria for ordering results.

try {
    $result = $api_instance->runEventsGet($uuid, $runUuid, $actionUuid, $missionName, $startTime, $endTime, $startCreatedAt, $endCreatedAt, $limit, $orderBy);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RunEventsApi->runEventsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RunEventsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RunEventsApi->new();
my $uuid = uuid_example; # String | Include run_events with this uuid.
my $runUuid = runUuid_example; # String | Include run_events which occurred during the run with this uuid.
my $actionUuid = actionUuid_example; # String | Include run_events which represent playback of actions with this uuid.
my $missionName = missionName_example; # String | Include run_events which occurred during playback of a mission with this name.
my $startTime = 2013-10-20T19:20:30+01:00; # Date | Include run_events with a time greater than this value.
my $endTime = 2013-10-20T19:20:30+01:00; # Date | Include run_events with a time less than this value.
my $startCreatedAt = 2013-10-20T19:20:30+01:00; # Date | Include run_events with a created_at greater than this value.
my $endCreatedAt = 2013-10-20T19:20:30+01:00; # Date | Include run_events with a created_at less than this value.
my $limit = 56; # Integer | Only return a number of resources up to this value.
my $orderBy = orderBy_example; # String | Criteria for ordering results.

eval {
    my $result = $api_instance->runEventsGet(uuid => $uuid, runUuid => $runUuid, actionUuid => $actionUuid, missionName => $missionName, startTime => $startTime, endTime => $endTime, startCreatedAt => $startCreatedAt, endCreatedAt => $endCreatedAt, limit => $limit, orderBy => $orderBy);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RunEventsApi->runEventsGet: $@\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.RunEventsApi()
uuid = uuid_example # String | Include run_events with this uuid. (optional) (default to null)
runUuid = runUuid_example # String | Include run_events which occurred during the run with this uuid. (optional) (default to null)
actionUuid = actionUuid_example # String | Include run_events which represent playback of actions with this uuid. (optional) (default to null)
missionName = missionName_example # String | Include run_events which occurred during playback of a mission with this name. (optional) (default to null)
startTime = 2013-10-20T19:20:30+01:00 # Date | Include run_events with a time greater than this value. (optional) (default to null)
endTime = 2013-10-20T19:20:30+01:00 # Date | Include run_events with a time less than this value. (optional) (default to null)
startCreatedAt = 2013-10-20T19:20:30+01:00 # Date | Include run_events with a created_at greater than this value. (optional) (default to null)
endCreatedAt = 2013-10-20T19:20:30+01:00 # Date | Include run_events with a created_at less than this value. (optional) (default to null)
limit = 56 # Integer | Only return a number of resources up to this value. (optional) (default to 20)
orderBy = orderBy_example # String | Criteria for ordering results. (optional) (default to null)

try:
    # Retrieve a collection of run events.
    api_response = api_instance.run_events_get(uuid=uuid, runUuid=runUuid, actionUuid=actionUuid, missionName=missionName, startTime=startTime, endTime=endTime, startCreatedAt=startCreatedAt, endCreatedAt=endCreatedAt, limit=limit, orderBy=orderBy)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RunEventsApi->runEventsGet: %s\n" % e)
extern crate RunEventsApi;

pub fn main() {
    let uuid = uuid_example; // String
    let runUuid = runUuid_example; // String
    let actionUuid = actionUuid_example; // String
    let missionName = missionName_example; // String
    let startTime = 2013-10-20T19:20:30+01:00; // Date
    let endTime = 2013-10-20T19:20:30+01:00; // Date
    let startCreatedAt = 2013-10-20T19:20:30+01:00; // Date
    let endCreatedAt = 2013-10-20T19:20:30+01:00; // Date
    let limit = 56; // Integer
    let orderBy = orderBy_example; // String

    let mut context = RunEventsApi::Context::default();
    let result = client.runEventsGet(uuid, runUuid, actionUuid, missionName, startTime, endTime, startCreatedAt, endCreatedAt, limit, orderBy, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
uuid
String
Include run_events with this uuid.
runUuid
String
Include run_events which occurred during the run with this uuid.
actionUuid
String
Include run_events which represent playback of actions with this uuid.
missionName
String
Include run_events which occurred during playback of a mission with this name.
startTime
Date (date-time)
Include run_events with a time greater than this value.
endTime
Date (date-time)
Include run_events with a time less than this value.
startCreatedAt
Date (date-time)
Include run_events with a created_at greater than this value.
endCreatedAt
Date (date-time)
Include run_events with a created_at less than this value.
limit
Integer
Only return a number of resources up to this value.
orderBy
String
Criteria for ordering results.

Responses


runEventsRunEventUuidGet

Retrieves a single run event resource by uuid.

A run event describes a data collection action which took place during a run.


/run_events/{runEventUuid}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/run_events/{runEventUuid}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RunEventsApi;

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

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

        // Create an instance of the API class
        RunEventsApi apiInstance = new RunEventsApi();
        String runEventUuid = runEventUuid_example; // String | ID of run

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

public class RunEventsApiExample {
    public static void main(String[] args) {
        RunEventsApi apiInstance = new RunEventsApi();
        String runEventUuid = runEventUuid_example; // String | ID of run

        try {
            RunEvent result = apiInstance.runEventsRunEventUuidGet(runEventUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RunEventsApi#runEventsRunEventUuidGet");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RunEventsApi *apiInstance = [[RunEventsApi alloc] init];
String *runEventUuid = runEventUuid_example; // ID of run (default to null)

// Retrieves a single run event resource by uuid.
[apiInstance runEventsRunEventUuidGetWith:runEventUuid
              completionHandler: ^(RunEvent output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

// Create an instance of the API class
var api = new ScoutWebApi.RunEventsApi()
var runEventUuid = runEventUuid_example; // {String} ID of run

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

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

            // Create an instance of the API class
            var apiInstance = new RunEventsApi();
            var runEventUuid = runEventUuid_example;  // String | ID of run (default to null)

            try {
                // Retrieves a single run event resource by uuid.
                RunEvent result = apiInstance.runEventsRunEventUuidGet(runEventUuid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RunEventsApi.runEventsRunEventUuidGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RunEventsApi();
$runEventUuid = runEventUuid_example; // String | ID of run

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RunEventsApi->new();
my $runEventUuid = runEventUuid_example; # String | ID of run

eval {
    my $result = $api_instance->runEventsRunEventUuidGet(runEventUuid => $runEventUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RunEventsApi->runEventsRunEventUuidGet: $@\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.RunEventsApi()
runEventUuid = runEventUuid_example # String | ID of run (default to null)

try:
    # Retrieves a single run event resource by uuid.
    api_response = api_instance.run_events_run_event_uuid_get(runEventUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RunEventsApi->runEventsRunEventUuidGet: %s\n" % e)
extern crate RunEventsApi;

pub fn main() {
    let runEventUuid = runEventUuid_example; // String

    let mut context = RunEventsApi::Context::default();
    let result = client.runEventsRunEventUuidGet(runEventUuid, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
runEventUuid*
String
ID of run
Required

Responses


RunFacets

runsFacetsActionsGet

Retrieves a list of action descriptions which match query params.


/runs/facets/actions

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/runs/facets/actions"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RunFacetsApi;

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

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

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

        try {
            array[_runs_facets_actions_get_200_response_inner] result = apiInstance.runsFacetsActionsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RunFacetsApi#runsFacetsActionsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RunFacetsApi;

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

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


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

// Retrieves a list of action descriptions which match query params.
[apiInstance runsFacetsActionsGetWithCompletionHandler: 
              ^(array[_runs_facets_actions_get_200_response_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

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

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

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

            try {
                // Retrieves a list of action descriptions which match query params.
                array[_runs_facets_actions_get_200_response_inner] result = apiInstance.runsFacetsActionsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RunFacetsApi.runsFacetsActionsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Retrieves a list of action descriptions which match query params.
    api_response = api_instance.runs_facets_actions_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RunFacetsApi->runsFacetsActionsGet: %s\n" % e)
extern crate RunFacetsApi;

pub fn main() {

    let mut context = RunFacetsApi::Context::default();
    let result = client.runsFacetsActionsGet(&context).wait();

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

Scopes

Parameters

Responses


runsFacetsMissionsGet

Retrieves a list of robot descriptions which match query params.


/runs/facets/missions

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/runs/facets/missions"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RunFacetsApi;

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

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

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

        try {
            array[_runs_facets_missions_get_200_response_inner] result = apiInstance.runsFacetsMissionsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RunFacetsApi#runsFacetsMissionsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RunFacetsApi;

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

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


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

// Retrieves a list of robot descriptions which match query params.
[apiInstance runsFacetsMissionsGetWithCompletionHandler: 
              ^(array[_runs_facets_missions_get_200_response_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

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

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

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

            try {
                // Retrieves a list of robot descriptions which match query params.
                array[_runs_facets_missions_get_200_response_inner] result = apiInstance.runsFacetsMissionsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RunFacetsApi.runsFacetsMissionsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Retrieves a list of robot descriptions which match query params.
    api_response = api_instance.runs_facets_missions_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RunFacetsApi->runsFacetsMissionsGet: %s\n" % e)
extern crate RunFacetsApi;

pub fn main() {

    let mut context = RunFacetsApi::Context::default();
    let result = client.runsFacetsMissionsGet(&context).wait();

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

Scopes

Parameters

Responses


runsFacetsRobotsGet

Retrieves a list of robot descriptions which match query params.


/runs/facets/robots

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/runs/facets/robots"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RunFacetsApi;

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

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

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

        try {
            array[_runs_facets_robots_get_200_response_inner] result = apiInstance.runsFacetsRobotsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RunFacetsApi#runsFacetsRobotsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RunFacetsApi;

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

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


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

// Retrieves a list of robot descriptions which match query params.
[apiInstance runsFacetsRobotsGetWithCompletionHandler: 
              ^(array[_runs_facets_robots_get_200_response_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

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

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

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

            try {
                // Retrieves a list of robot descriptions which match query params.
                array[_runs_facets_robots_get_200_response_inner] result = apiInstance.runsFacetsRobotsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RunFacetsApi.runsFacetsRobotsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Retrieves a list of robot descriptions which match query params.
    api_response = api_instance.runs_facets_robots_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RunFacetsApi->runsFacetsRobotsGet: %s\n" % e)
extern crate RunFacetsApi;

pub fn main() {

    let mut context = RunFacetsApi::Context::default();
    let result = client.runsFacetsRobotsGet(&context).wait();

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

Scopes

Parameters

Responses


Runs

runsGet

Query a collection of runs.

Returns a list of run resources based upon provided query parameters. A run describes a period of mission playback or teleoperation.


/runs/

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/runs/?startTime=2013-10-20T19:20:30+01:00&endTime=2013-10-20T19:20:30+01:00&missions=&robots=&types=&robotHostname=robotHostname_example&robotNickname=robotNickname_example&robotSerial=robotSerial_example&limit=56&offset=56&orderBy=orderBy_example&format=format_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RunsApi;

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

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

        // Create an instance of the API class
        RunsApi apiInstance = new RunsApi();
        Date startTime = 2013-10-20T19:20:30+01:00; // Date | Include runs with a start_time greater than this value.
        Date endTime = 2013-10-20T19:20:30+01:00; // Date | Include runs with a start_time less than this value.
        array[String] missions = ; // array[String] | Only include runs performing one of the provided missions.
        array[String] robots = ; // array[String] | Only include runs performed by the provided robots.
        array[BigDecimal] types = ; // array[BigDecimal] | Only include runs of this type.
        String robotHostname = robotHostname_example; // String | Include runs performed by a robot with this hostname
        String robotNickname = robotNickname_example; // String | Include runs performed by a robot with this nickname.
        String robotSerial = robotSerial_example; // String | Include runs performed by a robot with this serial.
        Integer limit = 56; // Integer | Only return a number of runs up to this value.
        Integer offset = 56; // Integer | Skip this number of runs before returning.
        String orderBy = orderBy_example; // String | Criteria for ordering results.
        String format = format_example; // String | The data format of the response.

        try {
            _runs__get_200_response result = apiInstance.runsGet(startTime, endTime, missions, robots, types, robotHostname, robotNickname, robotSerial, limit, offset, orderBy, format);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RunsApi#runsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RunsApi;

public class RunsApiExample {
    public static void main(String[] args) {
        RunsApi apiInstance = new RunsApi();
        Date startTime = 2013-10-20T19:20:30+01:00; // Date | Include runs with a start_time greater than this value.
        Date endTime = 2013-10-20T19:20:30+01:00; // Date | Include runs with a start_time less than this value.
        array[String] missions = ; // array[String] | Only include runs performing one of the provided missions.
        array[String] robots = ; // array[String] | Only include runs performed by the provided robots.
        array[BigDecimal] types = ; // array[BigDecimal] | Only include runs of this type.
        String robotHostname = robotHostname_example; // String | Include runs performed by a robot with this hostname
        String robotNickname = robotNickname_example; // String | Include runs performed by a robot with this nickname.
        String robotSerial = robotSerial_example; // String | Include runs performed by a robot with this serial.
        Integer limit = 56; // Integer | Only return a number of runs up to this value.
        Integer offset = 56; // Integer | Skip this number of runs before returning.
        String orderBy = orderBy_example; // String | Criteria for ordering results.
        String format = format_example; // String | The data format of the response.

        try {
            _runs__get_200_response result = apiInstance.runsGet(startTime, endTime, missions, robots, types, robotHostname, robotNickname, robotSerial, limit, offset, orderBy, format);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RunsApi#runsGet");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RunsApi *apiInstance = [[RunsApi alloc] init];
Date *startTime = 2013-10-20T19:20:30+01:00; // Include runs with a start_time greater than this value. (optional) (default to null)
Date *endTime = 2013-10-20T19:20:30+01:00; // Include runs with a start_time less than this value. (optional) (default to null)
array[String] *missions = ; // Only include runs performing one of the provided missions. (optional) (default to null)
array[String] *robots = ; // Only include runs performed by the provided robots. (optional) (default to null)
array[BigDecimal] *types = ; // Only include runs of this type. (optional) (default to null)
String *robotHostname = robotHostname_example; // Include runs performed by a robot with this hostname (optional) (default to null)
String *robotNickname = robotNickname_example; // Include runs performed by a robot with this nickname. (optional) (default to null)
String *robotSerial = robotSerial_example; // Include runs performed by a robot with this serial. (optional) (default to null)
Integer *limit = 56; // Only return a number of runs up to this value. (optional) (default to 20)
Integer *offset = 56; // Skip this number of runs before returning. (optional) (default to 0)
String *orderBy = orderBy_example; // Criteria for ordering results. (optional) (default to newest)
String *format = format_example; // The data format of the response. (optional) (default to json)

// Query a collection of runs.
[apiInstance runsGetWith:startTime
    endTime:endTime
    missions:missions
    robots:robots
    types:types
    robotHostname:robotHostname
    robotNickname:robotNickname
    robotSerial:robotSerial
    limit:limit
    offset:offset
    orderBy:orderBy
    format:format
              completionHandler: ^(_runs__get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

// Create an instance of the API class
var api = new ScoutWebApi.RunsApi()
var opts = {
  'startTime': 2013-10-20T19:20:30+01:00, // {Date} Include runs with a start_time greater than this value.
  'endTime': 2013-10-20T19:20:30+01:00, // {Date} Include runs with a start_time less than this value.
  'missions': , // {array[String]} Only include runs performing one of the provided missions.
  'robots': , // {array[String]} Only include runs performed by the provided robots.
  'types': , // {array[BigDecimal]} Only include runs of this type.
  'robotHostname': robotHostname_example, // {String} Include runs performed by a robot with this hostname
  'robotNickname': robotNickname_example, // {String} Include runs performed by a robot with this nickname.
  'robotSerial': robotSerial_example, // {String} Include runs performed by a robot with this serial.
  'limit': 56, // {Integer} Only return a number of runs up to this value.
  'offset': 56, // {Integer} Skip this number of runs before returning.
  'orderBy': orderBy_example, // {String} Criteria for ordering results.
  'format': format_example // {String} The data format of the response.
};

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

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

            // Create an instance of the API class
            var apiInstance = new RunsApi();
            var startTime = 2013-10-20T19:20:30+01:00;  // Date | Include runs with a start_time greater than this value. (optional)  (default to null)
            var endTime = 2013-10-20T19:20:30+01:00;  // Date | Include runs with a start_time less than this value. (optional)  (default to null)
            var missions = new array[String](); // array[String] | Only include runs performing one of the provided missions. (optional)  (default to null)
            var robots = new array[String](); // array[String] | Only include runs performed by the provided robots. (optional)  (default to null)
            var types = new array[BigDecimal](); // array[BigDecimal] | Only include runs of this type. (optional)  (default to null)
            var robotHostname = robotHostname_example;  // String | Include runs performed by a robot with this hostname (optional)  (default to null)
            var robotNickname = robotNickname_example;  // String | Include runs performed by a robot with this nickname. (optional)  (default to null)
            var robotSerial = robotSerial_example;  // String | Include runs performed by a robot with this serial. (optional)  (default to null)
            var limit = 56;  // Integer | Only return a number of runs up to this value. (optional)  (default to 20)
            var offset = 56;  // Integer | Skip this number of runs before returning. (optional)  (default to 0)
            var orderBy = orderBy_example;  // String | Criteria for ordering results. (optional)  (default to newest)
            var format = format_example;  // String | The data format of the response. (optional)  (default to json)

            try {
                // Query a collection of runs.
                _runs__get_200_response result = apiInstance.runsGet(startTime, endTime, missions, robots, types, robotHostname, robotNickname, robotSerial, limit, offset, orderBy, format);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RunsApi.runsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RunsApi();
$startTime = 2013-10-20T19:20:30+01:00; // Date | Include runs with a start_time greater than this value.
$endTime = 2013-10-20T19:20:30+01:00; // Date | Include runs with a start_time less than this value.
$missions = ; // array[String] | Only include runs performing one of the provided missions.
$robots = ; // array[String] | Only include runs performed by the provided robots.
$types = ; // array[BigDecimal] | Only include runs of this type.
$robotHostname = robotHostname_example; // String | Include runs performed by a robot with this hostname
$robotNickname = robotNickname_example; // String | Include runs performed by a robot with this nickname.
$robotSerial = robotSerial_example; // String | Include runs performed by a robot with this serial.
$limit = 56; // Integer | Only return a number of runs up to this value.
$offset = 56; // Integer | Skip this number of runs before returning.
$orderBy = orderBy_example; // String | Criteria for ordering results.
$format = format_example; // String | The data format of the response.

try {
    $result = $api_instance->runsGet($startTime, $endTime, $missions, $robots, $types, $robotHostname, $robotNickname, $robotSerial, $limit, $offset, $orderBy, $format);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RunsApi->runsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RunsApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RunsApi->new();
my $startTime = 2013-10-20T19:20:30+01:00; # Date | Include runs with a start_time greater than this value.
my $endTime = 2013-10-20T19:20:30+01:00; # Date | Include runs with a start_time less than this value.
my $missions = []; # array[String] | Only include runs performing one of the provided missions.
my $robots = []; # array[String] | Only include runs performed by the provided robots.
my $types = []; # array[BigDecimal] | Only include runs of this type.
my $robotHostname = robotHostname_example; # String | Include runs performed by a robot with this hostname
my $robotNickname = robotNickname_example; # String | Include runs performed by a robot with this nickname.
my $robotSerial = robotSerial_example; # String | Include runs performed by a robot with this serial.
my $limit = 56; # Integer | Only return a number of runs up to this value.
my $offset = 56; # Integer | Skip this number of runs before returning.
my $orderBy = orderBy_example; # String | Criteria for ordering results.
my $format = format_example; # String | The data format of the response.

eval {
    my $result = $api_instance->runsGet(startTime => $startTime, endTime => $endTime, missions => $missions, robots => $robots, types => $types, robotHostname => $robotHostname, robotNickname => $robotNickname, robotSerial => $robotSerial, limit => $limit, offset => $offset, orderBy => $orderBy, format => $format);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RunsApi->runsGet: $@\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.RunsApi()
startTime = 2013-10-20T19:20:30+01:00 # Date | Include runs with a start_time greater than this value. (optional) (default to null)
endTime = 2013-10-20T19:20:30+01:00 # Date | Include runs with a start_time less than this value. (optional) (default to null)
missions =  # array[String] | Only include runs performing one of the provided missions. (optional) (default to null)
robots =  # array[String] | Only include runs performed by the provided robots. (optional) (default to null)
types =  # array[BigDecimal] | Only include runs of this type. (optional) (default to null)
robotHostname = robotHostname_example # String | Include runs performed by a robot with this hostname (optional) (default to null)
robotNickname = robotNickname_example # String | Include runs performed by a robot with this nickname. (optional) (default to null)
robotSerial = robotSerial_example # String | Include runs performed by a robot with this serial. (optional) (default to null)
limit = 56 # Integer | Only return a number of runs up to this value. (optional) (default to 20)
offset = 56 # Integer | Skip this number of runs before returning. (optional) (default to 0)
orderBy = orderBy_example # String | Criteria for ordering results. (optional) (default to newest)
format = format_example # String | The data format of the response. (optional) (default to json)

try:
    # Query a collection of runs.
    api_response = api_instance.runs_get(startTime=startTime, endTime=endTime, missions=missions, robots=robots, types=types, robotHostname=robotHostname, robotNickname=robotNickname, robotSerial=robotSerial, limit=limit, offset=offset, orderBy=orderBy, format=format)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RunsApi->runsGet: %s\n" % e)
extern crate RunsApi;

pub fn main() {
    let startTime = 2013-10-20T19:20:30+01:00; // Date
    let endTime = 2013-10-20T19:20:30+01:00; // Date
    let missions = ; // array[String]
    let robots = ; // array[String]
    let types = ; // array[BigDecimal]
    let robotHostname = robotHostname_example; // String
    let robotNickname = robotNickname_example; // String
    let robotSerial = robotSerial_example; // String
    let limit = 56; // Integer
    let offset = 56; // Integer
    let orderBy = orderBy_example; // String
    let format = format_example; // String

    let mut context = RunsApi::Context::default();
    let result = client.runsGet(startTime, endTime, missions, robots, types, robotHostname, robotNickname, robotSerial, limit, offset, orderBy, format, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
startTime
Date (date-time)
Include runs with a start_time greater than this value.
endTime
Date (date-time)
Include runs with a start_time less than this value.
missions
array[String]
Only include runs performing one of the provided missions.
robots
array[String]
Only include runs performed by the provided robots.
types
array[BigDecimal]
Only include runs of this type.
robotHostname
String
Include runs performed by a robot with this hostname
robotNickname
String
Include runs performed by a robot with this nickname.
robotSerial
String
Include runs performed by a robot with this serial.
limit
Integer
Only return a number of runs up to this value.
offset
Integer
Skip this number of runs before returning.
orderBy
String
Criteria for ordering results.
format
String
The data format of the response.

Responses


runsRunUuidGet

Retrieve a run by its uuid.

A single run resource describing a period of robot mission playback or teleoperation.


/runs/{runUuid}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/runs/{runUuid}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RunsApi;

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

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

        // Create an instance of the API class
        RunsApi apiInstance = new RunsApi();
        String runUuid = runUuid_example; // String | A run's uuid

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

public class RunsApiExample {
    public static void main(String[] args) {
        RunsApi apiInstance = new RunsApi();
        String runUuid = runUuid_example; // String | A run's uuid

        try {
            Run result = apiInstance.runsRunUuidGet(runUuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RunsApi#runsRunUuidGet");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RunsApi *apiInstance = [[RunsApi alloc] init];
String *runUuid = runUuid_example; // A run's uuid (default to null)

// Retrieve a run by its uuid.
[apiInstance runsRunUuidGetWith:runUuid
              completionHandler: ^(Run output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var ScoutWebApi = require('scout_web_api');

// Create an instance of the API class
var api = new ScoutWebApi.RunsApi()
var runUuid = runUuid_example; // {String} A run's uuid

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

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

            // Create an instance of the API class
            var apiInstance = new RunsApi();
            var runUuid = runUuid_example;  // String | A run's uuid (default to null)

            try {
                // Retrieve a run by its uuid.
                Run result = apiInstance.runsRunUuidGet(runUuid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RunsApi.runsRunUuidGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RunsApi();
$runUuid = runUuid_example; // String | A run's uuid

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RunsApi->new();
my $runUuid = runUuid_example; # String | A run's uuid

eval {
    my $result = $api_instance->runsRunUuidGet(runUuid => $runUuid);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RunsApi->runsRunUuidGet: $@\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.RunsApi()
runUuid = runUuid_example # String | A run's uuid (default to null)

try:
    # Retrieve a run by its uuid.
    api_response = api_instance.runs_run_uuid_get(runUuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RunsApi->runsRunUuidGet: %s\n" % e)
extern crate RunsApi;

pub fn main() {
    let runUuid = runUuid_example; // String

    let mut context = RunsApi::Context::default();
    let result = client.runsRunUuidGet(runUuid, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
runUuid*
String
A run's uuid
Required

Responses