Python Lambda API Demo

Default

reportsColorColorGet

Get widgets by color


/reports/color/{color}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/reports/color/{color}"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String color = Red; // String | Color of the widget

        try {
            array[_widget_put_request] result = apiInstance.reportsColorColorGet(color);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#reportsColorColorGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String color = Red; // String | Color of the widget

        try {
            array[_widget_put_request] result = apiInstance.reportsColorColorGet(color);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#reportsColorColorGet");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *color = Red; // Color of the widget (default to null)

[apiInstance reportsColorColorGetWith:color
              completionHandler: ^(array[_widget_put_request] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PythonLambdaApiDemo = require('python_lambda_api_demo');

// Create an instance of the API class
var api = new PythonLambdaApiDemo.DefaultApi()
var color = Red; // {String} Color of the widget

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var color = Red;  // String | Color of the widget (default to null)

            try {
                array[_widget_put_request] result = apiInstance.reportsColorColorGet(color);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.reportsColorColorGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$color = Red; // String | Color of the widget

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $color = Red; # String | Color of the widget

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
color = Red # String | Color of the widget (default to null)

try:
    api_response = api_instance.reports_color_color_get(color)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->reportsColorColorGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let color = Red; // String

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

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

Scopes

Parameters

Path parameters
Name Description
color*
String
Color of the widget
Required

Responses

reportsFilterpageGet

Get the system preferences


/reports/filterpage

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/reports/filterpage?limit=20&lastKey=testKey&filter=widgetName"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 20; // Integer | The maximum number of records to return
        String lastKey = testKey; // String | The key returned by the last call in metadata.lastKey, to index to the next page
        String filter = widgetName; // String | Filter to use when retrieving data from the DB

        try {
            array[_widget_put_request] result = apiInstance.reportsFilterpageGet(limit, lastKey, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#reportsFilterpageGet");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 20; // Integer | The maximum number of records to return
        String lastKey = testKey; // String | The key returned by the last call in metadata.lastKey, to index to the next page
        String filter = widgetName; // String | Filter to use when retrieving data from the DB

        try {
            array[_widget_put_request] result = apiInstance.reportsFilterpageGet(limit, lastKey, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#reportsFilterpageGet");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Integer *limit = 20; // The maximum number of records to return (optional) (default to null)
String *lastKey = testKey; // The key returned by the last call in metadata.lastKey, to index to the next page (optional) (default to null)
String *filter = widgetName; // Filter to use when retrieving data from the DB (optional) (default to null)

[apiInstance reportsFilterpageGetWith:limit
    lastKey:lastKey
    filter:filter
              completionHandler: ^(array[_widget_put_request] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PythonLambdaApiDemo = require('python_lambda_api_demo');

// Create an instance of the API class
var api = new PythonLambdaApiDemo.DefaultApi()
var opts = {
  'limit': 20, // {Integer} The maximum number of records to return
  'lastKey': testKey, // {String} The key returned by the last call in metadata.lastKey, to index to the next page
  'filter': widgetName // {String} Filter to use when retrieving data from the DB
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var limit = 20;  // Integer | The maximum number of records to return (optional)  (default to null)
            var lastKey = testKey;  // String | The key returned by the last call in metadata.lastKey, to index to the next page (optional)  (default to null)
            var filter = widgetName;  // String | Filter to use when retrieving data from the DB (optional)  (default to null)

            try {
                array[_widget_put_request] result = apiInstance.reportsFilterpageGet(limit, lastKey, filter);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.reportsFilterpageGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$limit = 20; // Integer | The maximum number of records to return
$lastKey = testKey; // String | The key returned by the last call in metadata.lastKey, to index to the next page
$filter = widgetName; // String | Filter to use when retrieving data from the DB

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $limit = 20; # Integer | The maximum number of records to return
my $lastKey = testKey; # String | The key returned by the last call in metadata.lastKey, to index to the next page
my $filter = widgetName; # String | Filter to use when retrieving data from the DB

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
limit = 20 # Integer | The maximum number of records to return (optional) (default to null)
lastKey = testKey # String | The key returned by the last call in metadata.lastKey, to index to the next page (optional) (default to null)
filter = widgetName # String | Filter to use when retrieving data from the DB (optional) (default to null)

try:
    api_response = api_instance.reports_filterpage_get(limit=limit, lastKey=lastKey, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->reportsFilterpageGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let limit = 20; // Integer
    let lastKey = testKey; // String
    let filter = widgetName; // String

    let mut context = DefaultApi::Context::default();
    let result = client.reportsFilterpageGet(limit, lastKey, filter, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
limit
Integer
The maximum number of records to return
lastKey
String
The key returned by the last call in metadata.lastKey, to index to the next page
filter
String
Filter to use when retrieving data from the DB

Responses

widgetPut


/widget

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/widget" \
 -d ''

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

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

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

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

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

import org.openapitools.client.api.DefaultApi;

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

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


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

[apiInstance widgetPutWith:widgetPutRequest
              completionHandler: ^(_widget_put_request output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PythonLambdaApiDemo = require('python_lambda_api_demo');

// Create an instance of the API class
var api = new PythonLambdaApiDemo.DefaultApi()
var widgetPutRequest = ; // {WidgetPutRequest} 

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

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

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

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

            try {
                _widget_put_request result = apiInstance.widgetPut(widgetPutRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.widgetPut: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
widgetPutRequest =  # WidgetPutRequest | 

try:
    api_response = api_instance.widget_put(widgetPutRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->widgetPut: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let widgetPutRequest = ; // WidgetPutRequest

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

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

Scopes

Parameters

Body parameters
Name Description
widgetPutRequest *

Responses

widgetWidgetNameGet

Get a widget's name


/widget/{widgetName}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/widget/{widgetName}"

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

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

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

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String widgetName = widgetName_example; // String | Name of the widget

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String widgetName = widgetName_example; // String | Name of the widget

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *widgetName = widgetName_example; // Name of the widget (default to null)

[apiInstance widgetWidgetNameGetWith:widgetName
              completionHandler: ^(_widget_put_request output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var PythonLambdaApiDemo = require('python_lambda_api_demo');

// Create an instance of the API class
var api = new PythonLambdaApiDemo.DefaultApi()
var widgetName = widgetName_example; // {String} Name of the widget

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var widgetName = widgetName_example;  // String | Name of the widget (default to null)

            try {
                _widget_put_request result = apiInstance.widgetWidgetNameGet(widgetName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.widgetWidgetNameGet: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$widgetName = widgetName_example; // String | Name of the widget

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $widgetName = widgetName_example; # String | Name of the widget

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

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
widgetName = widgetName_example # String | Name of the widget (default to null)

try:
    api_response = api_instance.widget_widget_name_get(widgetName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->widgetWidgetNameGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let widgetName = widgetName_example; // String

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

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

Scopes

Parameters

Path parameters
Name Description
widgetName*
String
Name of the widget
Required

Responses