All URIs are relative to https://api.korewireless.com
| Method | HTTP request | Description |
|---|---|---|
| bind_device | POST /omnicore/subscriptions/{subscriptionId}/registries/{registryId}/bindDeviceToGateway | |
| bind_devices | POST /omnicore/subscriptions/{subscriptionId}/registries/{registryId}/bindDevicesToGateway | |
| block_device_communcation | PUT /omnicore/subscriptions/{subscriptionid}/registries/{registryId}/devices/{deviceId}/communication | |
| create_device | POST /omnicore/subscriptions/{subscriptionId}/registries/{registryId}/devices | |
| delete_device | DELETE /omnicore/subscriptions/{subscriptionId}/registries/{registryId}/devices/{deviceId} | |
| get_config | GET /omnicore/subscriptions/{subscriptionid}/registries/{registryId}/devices/{deviceId}/configVersions | |
| get_device | GET /omnicore/subscriptions/{subscriptionId}/registries/{registryId}/devices/{deviceId} | |
| get_devices | GET /omnicore/subscriptions/{subscriptionId}/registries/{registryId}/devices | |
| get_devices_last_seen | GET /omnicore/subscriptions/{subscriptionId}/devices | |
| get_states | GET /omnicore/subscriptions/{subscriptionid}/registries/{registryId}/devices/{deviceId}/states | |
| send_command_to_device | POST /omnicore/subscriptions/{subscriptionid}/registries/{registryId}/devices/{deviceId}/sendCommandToDevice | |
| un_bind_device | POST /omnicore/subscriptions/{subscriptionId}/registries/{registryId}/unbindDeviceFromGateway | |
| un_bind_devices | POST /omnicore/subscriptions/{subscriptionId}/registries/{registryId}/unbindDevicesFromGateway | |
| update_configuration_to_device | POST /omnicore/subscriptions/{subscriptionid}/registries/{registryId}/devices/{deviceId}/updateConfigurationToDevice | |
| update_custom_onboard_request | POST /omnicore/subscriptions/{subscriptionid}/registries/{registryId}/devices/{deviceId}/updateCustomOnboardRequest | |
| update_device | PATCH /omnicore/subscriptions/{subscriptionId}/registries/{registryId}/devices/{deviceId} |
Info bind_device(subscription_id, registry_id, bind)
Bind a device to a gateway under a registry
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
bind = OmniCore.BindRequest() # BindRequest | application/json
try:
api_response = api_instance.bind_device(subscription_id, registry_id, bind)
print("The response of DeviceApi->bind_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->bind_device: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
bind = OmniCore.BindRequest() # BindRequest | application/json
try:
api_response = api_instance.bind_device(subscription_id, registry_id, bind)
print("The response of DeviceApi->bind_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->bind_device: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscription_id | str | Subscription ID | |
| registry_id | str | Registry ID | |
| bind | BindRequest | application/json |
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
Info bind_devices(subscription_id, registry_id, bind)
Bind devices to a gateway under a registry
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
bind = OmniCore.BindRequestIdsGateway() # BindRequestIdsGateway | application/json
try:
api_response = api_instance.bind_devices(subscription_id, registry_id, bind)
print("The response of DeviceApi->bind_devices:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->bind_devices: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
bind = OmniCore.BindRequestIdsGateway() # BindRequestIdsGateway | application/json
try:
api_response = api_instance.bind_devices(subscription_id, registry_id, bind)
print("The response of DeviceApi->bind_devices:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->bind_devices: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscription_id | str | Subscription ID | |
| registry_id | str | Registry ID | |
| bind | BindRequestIdsGateway | application/json |
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
object block_device_communcation(subscriptionid, registry_id, device_id, block)
Blocks All Communication From A Device
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscriptionid = 'subscriptionid_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
block = OmniCore.BlockCommunicationBody() # BlockCommunicationBody | application/json
try:
api_response = api_instance.block_device_communcation(subscriptionid, registry_id, device_id, block)
print("The response of DeviceApi->block_device_communcation:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->block_device_communcation: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscriptionid = 'subscriptionid_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
block = OmniCore.BlockCommunicationBody() # BlockCommunicationBody | application/json
try:
api_response = api_instance.block_device_communcation(subscriptionid, registry_id, device_id, block)
print("The response of DeviceApi->block_device_communcation:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->block_device_communcation: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscriptionid | str | Subscription ID | |
| registry_id | str | Registry ID | |
| device_id | str | Device ID | |
| block | BlockCommunicationBody | application/json |
object
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
Device create_device(subscription_id, registry_id, device)
Create a device under a registry
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device = OmniCore.Device() # Device | application/json
try:
api_response = api_instance.create_device(subscription_id, registry_id, device)
print("The response of DeviceApi->create_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->create_device: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device = OmniCore.Device() # Device | application/json
try:
api_response = api_instance.create_device(subscription_id, registry_id, device)
print("The response of DeviceApi->create_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->create_device: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscription_id | str | Subscription ID | |
| registry_id | str | Registry ID | |
| device | Device | application/json |
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
object delete_device(subscription_id, registry_id, device_id)
Delete a device under a registry
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
try:
api_response = api_instance.delete_device(subscription_id, registry_id, device_id)
print("The response of DeviceApi->delete_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->delete_device: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
try:
api_response = api_instance.delete_device(subscription_id, registry_id, device_id)
print("The response of DeviceApi->delete_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->delete_device: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscription_id | str | Subscription ID | |
| registry_id | str | Registry ID | |
| device_id | str | Device ID |
object
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
ListDeviceConfigVersionsResponse get_config(subscriptionid, registry_id, device_id, num_versions=num_versions)
Get Configs Of Devices
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscriptionid = 'subscriptionid_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
num_versions = 56 # int | The number of versions to list. Versions are listed in decreasing order of the version number. The maximum number of versions retained is 10. If this value is zero, it will return all the versions available. (optional)
try:
api_response = api_instance.get_config(subscriptionid, registry_id, device_id, num_versions=num_versions)
print("The response of DeviceApi->get_config:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->get_config: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscriptionid = 'subscriptionid_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
num_versions = 56 # int | The number of versions to list. Versions are listed in decreasing order of the version number. The maximum number of versions retained is 10. If this value is zero, it will return all the versions available. (optional)
try:
api_response = api_instance.get_config(subscriptionid, registry_id, device_id, num_versions=num_versions)
print("The response of DeviceApi->get_config:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->get_config: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscriptionid | str | Subscription ID | |
| registry_id | str | Registry ID | |
| device_id | str | Device ID | |
| num_versions | int | The number of versions to list. Versions are listed in decreasing order of the version number. The maximum number of versions retained is 10. If this value is zero, it will return all the versions available. | [optional] |
ListDeviceConfigVersionsResponse
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
Device get_device(subscription_id, registry_id, device_id)
Get a device under a registry
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
try:
api_response = api_instance.get_device(subscription_id, registry_id, device_id)
print("The response of DeviceApi->get_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->get_device: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
try:
api_response = api_instance.get_device(subscription_id, registry_id, device_id)
print("The response of DeviceApi->get_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->get_device: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscription_id | str | Subscription ID | |
| registry_id | str | Registry ID | |
| device_id | str | Device ID |
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
ListDevicesResponse get_devices(subscription_id, registry_id, page_number=page_number, page_size=page_size, field_mask=field_mask, device_ids=device_ids, device_num_ids=device_num_ids, gateway_list_options_associations_device_id=gateway_list_options_associations_device_id, gateway_list_options_associations_gateway_id=gateway_list_options_associations_gateway_id, gateway_list_options_gateway_type=gateway_list_options_gateway_type)
Get all devices under a registry
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
page_number = 56 # int | Page Number (optional)
page_size = 56 # int | The maximum number of devices to return in the response. If this value is zero, the service will select a default size. (optional)
field_mask = 'field_mask_example' # str | The fields of the Device resource to be returned to the response. The fields id and numId are always returned, along with any other fields specified. A comma-separated list of fully qualified names of fields. Example: (optional)
device_ids = ['device_ids_example'] # List[str] | A list of device string IDs. For example, ['device0', 'device12']. If empty, this field is ignored. Maximum IDs: 10,000 (optional)
device_num_ids = ['device_num_ids_example'] # List[str] | A list of device numeric IDs. If empty, this field is ignored. Maximum IDs: 10,000. (optional)
gateway_list_options_associations_device_id = 'gateway_list_options_associations_device_id_example' # str | If set, returns only the gateways with which the specified device is associated. The device ID can be numeric (num_id) or the user-defined string (id). For example, if 456 is specified, returns only the gateways to which the device with num_id 456 is bound. (optional)
gateway_list_options_associations_gateway_id = 'gateway_list_options_associations_gateway_id_example' # str | If set, only devices associated with the specified gateway are returned. The gateway ID can be numeric (num_id) or the user-defined string (id). For example, if 123 is specified, only devices bound to the gateway with num_id 123 are returned (optional)
gateway_list_options_gateway_type = 'gateway_list_options_gateway_type_example' # str | If GATEWAY is specified, only gateways are returned. If NON_GATEWAY is specified, only non-gateway devices are returned. If GATEWAY_TYPE_UNSPECIFIED is specified, all devices are returned. (optional)
try:
api_response = api_instance.get_devices(subscription_id, registry_id, page_number=page_number, page_size=page_size, field_mask=field_mask, device_ids=device_ids, device_num_ids=device_num_ids, gateway_list_options_associations_device_id=gateway_list_options_associations_device_id, gateway_list_options_associations_gateway_id=gateway_list_options_associations_gateway_id, gateway_list_options_gateway_type=gateway_list_options_gateway_type)
print("The response of DeviceApi->get_devices:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->get_devices: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
page_number = 56 # int | Page Number (optional)
page_size = 56 # int | The maximum number of devices to return in the response. If this value is zero, the service will select a default size. (optional)
field_mask = 'field_mask_example' # str | The fields of the Device resource to be returned to the response. The fields id and numId are always returned, along with any other fields specified. A comma-separated list of fully qualified names of fields. Example: (optional)
device_ids = ['device_ids_example'] # List[str] | A list of device string IDs. For example, ['device0', 'device12']. If empty, this field is ignored. Maximum IDs: 10,000 (optional)
device_num_ids = ['device_num_ids_example'] # List[str] | A list of device numeric IDs. If empty, this field is ignored. Maximum IDs: 10,000. (optional)
gateway_list_options_associations_device_id = 'gateway_list_options_associations_device_id_example' # str | If set, returns only the gateways with which the specified device is associated. The device ID can be numeric (num_id) or the user-defined string (id). For example, if 456 is specified, returns only the gateways to which the device with num_id 456 is bound. (optional)
gateway_list_options_associations_gateway_id = 'gateway_list_options_associations_gateway_id_example' # str | If set, only devices associated with the specified gateway are returned. The gateway ID can be numeric (num_id) or the user-defined string (id). For example, if 123 is specified, only devices bound to the gateway with num_id 123 are returned (optional)
gateway_list_options_gateway_type = 'gateway_list_options_gateway_type_example' # str | If GATEWAY is specified, only gateways are returned. If NON_GATEWAY is specified, only non-gateway devices are returned. If GATEWAY_TYPE_UNSPECIFIED is specified, all devices are returned. (optional)
try:
api_response = api_instance.get_devices(subscription_id, registry_id, page_number=page_number, page_size=page_size, field_mask=field_mask, device_ids=device_ids, device_num_ids=device_num_ids, gateway_list_options_associations_device_id=gateway_list_options_associations_device_id, gateway_list_options_associations_gateway_id=gateway_list_options_associations_gateway_id, gateway_list_options_gateway_type=gateway_list_options_gateway_type)
print("The response of DeviceApi->get_devices:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->get_devices: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscription_id | str | Subscription ID | |
| registry_id | str | Registry ID | |
| page_number | int | Page Number | [optional] |
| page_size | int | The maximum number of devices to return in the response. If this value is zero, the service will select a default size. | [optional] |
| field_mask | str | The fields of the Device resource to be returned to the response. The fields id and numId are always returned, along with any other fields specified. A comma-separated list of fully qualified names of fields. Example: | [optional] |
| device_ids | List[str] | A list of device string IDs. For example, ['device0', 'device12']. If empty, this field is ignored. Maximum IDs: 10,000 | [optional] |
| device_num_ids | List[str] | A list of device numeric IDs. If empty, this field is ignored. Maximum IDs: 10,000. | [optional] |
| gateway_list_options_associations_device_id | str | If set, returns only the gateways with which the specified device is associated. The device ID can be numeric (num_id) or the user-defined string (id). For example, if 456 is specified, returns only the gateways to which the device with num_id 456 is bound. | [optional] |
| gateway_list_options_associations_gateway_id | str | If set, only devices associated with the specified gateway are returned. The gateway ID can be numeric (num_id) or the user-defined string (id). For example, if 123 is specified, only devices bound to the gateway with num_id 123 are returned | [optional] |
| gateway_list_options_gateway_type | str | If GATEWAY is specified, only gateways are returned. If NON_GATEWAY is specified, only non-gateway devices are returned. If GATEWAY_TYPE_UNSPECIFIED is specified, all devices are returned. | [optional] |
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
ListDevicesOnlineResponse get_devices_last_seen(subscription_id, page_number=page_number, page_size=page_size, field_mask=field_mask, sort_by_client_online=sort_by_client_online, device_ids=device_ids, device_num_ids=device_num_ids, gateway_list_options_associations_device_id=gateway_list_options_associations_device_id, gateway_list_options_associations_gateway_id=gateway_list_options_associations_gateway_id, gateway_list_options_gateway_type=gateway_list_options_gateway_type)
Get devices under a subscription sorted by last seen
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
page_number = 56 # int | Page Number (optional)
page_size = 56 # int | The maximum number of devices to return in the response. If this value is zero, the service will select a default size. (optional)
field_mask = 'field_mask_example' # str | The fields of the Device resource to be returned to the response. The fields id and numId are always returned, along with any other fields specified. A comma-separated list of fully qualified names of fields. Example: (optional)
sort_by_client_online = True # bool | Set to true to return devices sorted by last heartbeat (optional)
device_ids = ['device_ids_example'] # List[str] | A list of device string IDs. For example, ['device0', 'device12']. If empty, this field is ignored. Maximum IDs: 10,000 (optional)
device_num_ids = ['device_num_ids_example'] # List[str] | A list of device numeric IDs. If empty, this field is ignored. Maximum IDs: 10,000. (optional)
gateway_list_options_associations_device_id = 'gateway_list_options_associations_device_id_example' # str | If set, returns only the gateways with which the specified device is associated. The device ID can be numeric (num_id) or the user-defined string (id). For example, if 456 is specified, returns only the gateways to which the device with num_id 456 is bound. (optional)
gateway_list_options_associations_gateway_id = 'gateway_list_options_associations_gateway_id_example' # str | If set, only devices associated with the specified gateway are returned. The gateway ID can be numeric (num_id) or the user-defined string (id). For example, if 123 is specified, only devices bound to the gateway with num_id 123 are returned (optional)
gateway_list_options_gateway_type = 'gateway_list_options_gateway_type_example' # str | If GATEWAY is specified, only gateways are returned. If NON_GATEWAY is specified, only non-gateway devices are returned. If GATEWAY_TYPE_UNSPECIFIED is specified, all devices are returned. (optional)
try:
api_response = api_instance.get_devices_last_seen(subscription_id, page_number=page_number, page_size=page_size, field_mask=field_mask, sort_by_client_online=sort_by_client_online, device_ids=device_ids, device_num_ids=device_num_ids, gateway_list_options_associations_device_id=gateway_list_options_associations_device_id, gateway_list_options_associations_gateway_id=gateway_list_options_associations_gateway_id, gateway_list_options_gateway_type=gateway_list_options_gateway_type)
print("The response of DeviceApi->get_devices_last_seen:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->get_devices_last_seen: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
page_number = 56 # int | Page Number (optional)
page_size = 56 # int | The maximum number of devices to return in the response. If this value is zero, the service will select a default size. (optional)
field_mask = 'field_mask_example' # str | The fields of the Device resource to be returned to the response. The fields id and numId are always returned, along with any other fields specified. A comma-separated list of fully qualified names of fields. Example: (optional)
sort_by_client_online = True # bool | Set to true to return devices sorted by last heartbeat (optional)
device_ids = ['device_ids_example'] # List[str] | A list of device string IDs. For example, ['device0', 'device12']. If empty, this field is ignored. Maximum IDs: 10,000 (optional)
device_num_ids = ['device_num_ids_example'] # List[str] | A list of device numeric IDs. If empty, this field is ignored. Maximum IDs: 10,000. (optional)
gateway_list_options_associations_device_id = 'gateway_list_options_associations_device_id_example' # str | If set, returns only the gateways with which the specified device is associated. The device ID can be numeric (num_id) or the user-defined string (id). For example, if 456 is specified, returns only the gateways to which the device with num_id 456 is bound. (optional)
gateway_list_options_associations_gateway_id = 'gateway_list_options_associations_gateway_id_example' # str | If set, only devices associated with the specified gateway are returned. The gateway ID can be numeric (num_id) or the user-defined string (id). For example, if 123 is specified, only devices bound to the gateway with num_id 123 are returned (optional)
gateway_list_options_gateway_type = 'gateway_list_options_gateway_type_example' # str | If GATEWAY is specified, only gateways are returned. If NON_GATEWAY is specified, only non-gateway devices are returned. If GATEWAY_TYPE_UNSPECIFIED is specified, all devices are returned. (optional)
try:
api_response = api_instance.get_devices_last_seen(subscription_id, page_number=page_number, page_size=page_size, field_mask=field_mask, sort_by_client_online=sort_by_client_online, device_ids=device_ids, device_num_ids=device_num_ids, gateway_list_options_associations_device_id=gateway_list_options_associations_device_id, gateway_list_options_associations_gateway_id=gateway_list_options_associations_gateway_id, gateway_list_options_gateway_type=gateway_list_options_gateway_type)
print("The response of DeviceApi->get_devices_last_seen:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->get_devices_last_seen: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscription_id | str | Subscription ID | |
| page_number | int | Page Number | [optional] |
| page_size | int | The maximum number of devices to return in the response. If this value is zero, the service will select a default size. | [optional] |
| field_mask | str | The fields of the Device resource to be returned to the response. The fields id and numId are always returned, along with any other fields specified. A comma-separated list of fully qualified names of fields. Example: | [optional] |
| sort_by_client_online | bool | Set to true to return devices sorted by last heartbeat | [optional] |
| device_ids | List[str] | A list of device string IDs. For example, ['device0', 'device12']. If empty, this field is ignored. Maximum IDs: 10,000 | [optional] |
| device_num_ids | List[str] | A list of device numeric IDs. If empty, this field is ignored. Maximum IDs: 10,000. | [optional] |
| gateway_list_options_associations_device_id | str | If set, returns only the gateways with which the specified device is associated. The device ID can be numeric (num_id) or the user-defined string (id). For example, if 456 is specified, returns only the gateways to which the device with num_id 456 is bound. | [optional] |
| gateway_list_options_associations_gateway_id | str | If set, only devices associated with the specified gateway are returned. The gateway ID can be numeric (num_id) or the user-defined string (id). For example, if 123 is specified, only devices bound to the gateway with num_id 123 are returned | [optional] |
| gateway_list_options_gateway_type | str | If GATEWAY is specified, only gateways are returned. If NON_GATEWAY is specified, only non-gateway devices are returned. If GATEWAY_TYPE_UNSPECIFIED is specified, all devices are returned. | [optional] |
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
ListDeviceStatesResponse get_states(subscriptionid, registry_id, device_id, num_states=num_states)
Get States Of Devices
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscriptionid = 'subscriptionid_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
num_states = 56 # int | The number of states to list. States are listed in descending order of update time. The maximum number of states retained is 10. If this value is zero, it will return all the states available. (optional)
try:
api_response = api_instance.get_states(subscriptionid, registry_id, device_id, num_states=num_states)
print("The response of DeviceApi->get_states:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->get_states: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscriptionid = 'subscriptionid_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
num_states = 56 # int | The number of states to list. States are listed in descending order of update time. The maximum number of states retained is 10. If this value is zero, it will return all the states available. (optional)
try:
api_response = api_instance.get_states(subscriptionid, registry_id, device_id, num_states=num_states)
print("The response of DeviceApi->get_states:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->get_states: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscriptionid | str | Subscription ID | |
| registry_id | str | Registry ID | |
| device_id | str | Device ID | |
| num_states | int | The number of states to list. States are listed in descending order of update time. The maximum number of states retained is 10. If this value is zero, it will return all the states available. | [optional] |
- Content-Type: Not defined
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
object send_command_to_device(subscriptionid, registry_id, device_id, command)
Send A Command To A Device
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscriptionid = 'subscriptionid_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
command = OmniCore.DeviceCommand() # DeviceCommand | application/json
try:
api_response = api_instance.send_command_to_device(subscriptionid, registry_id, device_id, command)
print("The response of DeviceApi->send_command_to_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->send_command_to_device: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscriptionid = 'subscriptionid_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
command = OmniCore.DeviceCommand() # DeviceCommand | application/json
try:
api_response = api_instance.send_command_to_device(subscriptionid, registry_id, device_id, command)
print("The response of DeviceApi->send_command_to_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->send_command_to_device: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscriptionid | str | Subscription ID | |
| registry_id | str | Registry ID | |
| device_id | str | Device ID | |
| command | DeviceCommand | application/json |
object
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
Info un_bind_device(subscription_id, registry_id, unbind)
UnBind a device from a gateway under a registry
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
unbind = OmniCore.BindRequest() # BindRequest | application/json
try:
api_response = api_instance.un_bind_device(subscription_id, registry_id, unbind)
print("The response of DeviceApi->un_bind_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->un_bind_device: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
unbind = OmniCore.BindRequest() # BindRequest | application/json
try:
api_response = api_instance.un_bind_device(subscription_id, registry_id, unbind)
print("The response of DeviceApi->un_bind_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->un_bind_device: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscription_id | str | Subscription ID | |
| registry_id | str | Registry ID | |
| unbind | BindRequest | application/json |
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
Info un_bind_devices(subscription_id, registry_id, unbind)
UnBind devices from a gateway under a registry
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
unbind = OmniCore.BindRequestIdsGateway() # BindRequestIdsGateway | application/json
try:
api_response = api_instance.un_bind_devices(subscription_id, registry_id, unbind)
print("The response of DeviceApi->un_bind_devices:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->un_bind_devices: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
unbind = OmniCore.BindRequestIdsGateway() # BindRequestIdsGateway | application/json
try:
api_response = api_instance.un_bind_devices(subscription_id, registry_id, unbind)
print("The response of DeviceApi->un_bind_devices:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->un_bind_devices: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscription_id | str | Subscription ID | |
| registry_id | str | Registry ID | |
| unbind | BindRequestIdsGateway | application/json |
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
DeviceConfig update_configuration_to_device(subscriptionid, registry_id, device_id, configuration)
Update A Configuration Of A Device
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscriptionid = 'subscriptionid_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
configuration = OmniCore.DeviceConfiguration() # DeviceConfiguration | application/json
try:
api_response = api_instance.update_configuration_to_device(subscriptionid, registry_id, device_id, configuration)
print("The response of DeviceApi->update_configuration_to_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->update_configuration_to_device: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscriptionid = 'subscriptionid_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
configuration = OmniCore.DeviceConfiguration() # DeviceConfiguration | application/json
try:
api_response = api_instance.update_configuration_to_device(subscriptionid, registry_id, device_id, configuration)
print("The response of DeviceApi->update_configuration_to_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->update_configuration_to_device: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscriptionid | str | Subscription ID | |
| registry_id | str | Registry ID | |
| device_id | str | Device ID | |
| configuration | DeviceConfiguration | application/json |
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
Info update_custom_onboard_request(subscriptionid, registry_id, device_id, custom_onboard)
Approve/Reject a Custom Onboard Request
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscriptionid = 'subscriptionid_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
custom_onboard = OmniCore.CustomOnboard() # CustomOnboard | application/json
try:
api_response = api_instance.update_custom_onboard_request(subscriptionid, registry_id, device_id, custom_onboard)
print("The response of DeviceApi->update_custom_onboard_request:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->update_custom_onboard_request: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscriptionid = 'subscriptionid_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
custom_onboard = OmniCore.CustomOnboard() # CustomOnboard | application/json
try:
api_response = api_instance.update_custom_onboard_request(subscriptionid, registry_id, device_id, custom_onboard)
print("The response of DeviceApi->update_custom_onboard_request:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->update_custom_onboard_request: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscriptionid | str | Subscription ID | |
| registry_id | str | Registry ID | |
| device_id | str | Device ID | |
| custom_onboard | CustomOnboard | application/json |
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]
Device update_device(subscription_id, registry_id, device_id, update_mask, device)
Modify device under a registry
- Api Key Authentication (apiKey):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
update_mask = 'update_mask_example' # str | Required. Only updates the device fields indicated by this mask. The field mask must not be empty, and it must not contain fields that are immutable or only set by the server. Mutable top-level fields: credentials,logLevel, blocked,policy and metadata
device = OmniCore.Device() # Device | application/json
try:
api_response = api_instance.update_device(subscription_id, registry_id, device_id, update_mask, device)
print("The response of DeviceApi->update_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->update_device: %s\n" % e)- Bearer (JWT) Authentication (bearerAuth):
from __future__ import print_function
import time
import os
import OmniCore
from OmniCore.rest import ApiException
from pprint import pprint
# Defining the host is optional and defaults to https://api.korewireless.com
# See configuration.py for a list of all supported configuration parameters.
configuration = OmniCore.Configuration(
host = "https://api.korewireless.com"
)
# The client must configure the authentication and authorization parameters
# in accordance with the API server security policy.
# Examples for each auth method are provided below, use the example that
# satisfies your auth use case.
# Configure API key authorization: apiKey
configuration.api_key['apiKey'] = os.environ["API_KEY"]
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# configuration.api_key_prefix['apiKey'] = 'Bearer'
# Configure Bearer authorization (JWT): bearerAuth
configuration = OmniCore.Configuration(
access_token = os.environ["BEARER_TOKEN"]
)
# Enter a context with an instance of the API client
with OmniCore.ApiClient(configuration) as api_client:
# Create an instance of the API class
api_instance = OmniCore.DeviceApi(api_client)
subscription_id = 'subscription_id_example' # str | Subscription ID
registry_id = 'registry_id_example' # str | Registry ID
device_id = 'device_id_example' # str | Device ID
update_mask = 'update_mask_example' # str | Required. Only updates the device fields indicated by this mask. The field mask must not be empty, and it must not contain fields that are immutable or only set by the server. Mutable top-level fields: credentials,logLevel, blocked,policy and metadata
device = OmniCore.Device() # Device | application/json
try:
api_response = api_instance.update_device(subscription_id, registry_id, device_id, update_mask, device)
print("The response of DeviceApi->update_device:\n")
pprint(api_response)
except Exception as e:
print("Exception when calling DeviceApi->update_device: %s\n" % e)| Name | Type | Description | Notes |
|---|---|---|---|
| subscription_id | str | Subscription ID | |
| registry_id | str | Registry ID | |
| device_id | str | Device ID | |
| update_mask | str | Required. Only updates the device fields indicated by this mask. The field mask must not be empty, and it must not contain fields that are immutable or only set by the server. Mutable top-level fields: credentials,logLevel, blocked,policy and metadata | |
| device | Device | application/json |
- Content-Type: application/json
- Accept: application/json
| Status code | Description | Response headers |
|---|---|---|
| 200 | OK | - |
| 400 | Bad Request | - |
| 404 | Not Found | - |
| 500 | Internal Server Error | - |
[Back to top] [Back to API list] [Back to Model list] [Back to README]