def test_get_and_set_resource_value(self):
# an example: get and set a resource value
from mbed_cloud.foundation import Device
from mbed_cloud import ApiFilter
from mbed_cloud.foundation.enums import DeviceStateEnum
from mbed_cloud import ConnectAPI
# Use the Foundation interface to find a registered device.
api_filter = ApiFilter()
api_filter.add_filter("state", "eq", DeviceStateEnum.REGISTERED)
device = Device().list(max_results=2, filter=api_filter).next()
# Use the Legacy interface to find resources
connect_api = ConnectAPI()
# Find an observable resource
for resource in connect_api.list_resources(device.id):
if resource.observable:
break
# Set a resource value
connect_api.set_resource_value(device.id, resource.path, "12")
# Get a resource value
value = connect_api.get_resource_value(device.id, resource.path)
print("Device %s, path %s, current value: %s" %(device.id, resource.path, value))
# end of example
connect_api.stop_notifications()
def test_list_entities_with_filters(self):
from mbed_cloud import SDK
pelion_dm_sdk = SDK()
# an example: list entities with filters
from mbed_cloud import ApiFilter
from mbed_cloud.foundation.enums import UserStatusEnum
api_filter = ApiFilter()
api_filter.add_filter("email", "eq", "*****@*****.**")
api_filter.add_filter(
"status", "in", [UserStatusEnum.ACTIVE, UserStatusEnum.ENROLLING])
for user in pelion_dm_sdk.foundation.user().list(filter=api_filter):
print("%s (%s): %s" % (user.full_name, user.id, user.email))
def test_firmware_update_campaign_launch(self):
from mbed_cloud.foundation import FirmwareManifest
firmware_manifest = FirmwareManifest().list().first()
my_manifest_id = firmware_manifest.id
# an example: firmware update campaign launch
from datetime import datetime
from pprint import pprint
from mbed_cloud import SDK
from mbed_cloud import ApiFilter
pelion_dm_sdk = SDK()
new_campaign = pelion_dm_sdk.foundation.update_campaign(
root_manifest_id=my_manifest_id,
name="campaign - " + str(datetime.now()),
description="Update campaign for prior 2019 devices")
# Create a filter for all devices created before the 1st of January 2019 so that these devices will have their
# firmware replaced by the one defined in the manifest.
api_filter = ApiFilter()
api_filter.add_filter("created_at", "lte", datetime(2019, 1, 1))
new_campaign.device_filter_helper = api_filter
# Create the campaign
new_campaign.create()
# Determine the phase of the campaign
print("Campaign Phase:", new_campaign.phase)
# Start the campaign
new_campaign.start()
# Determine the phase of the campaign
new_campaign.read()
print("Campaign Phase:", new_campaign.phase)
# Print all device metadata related to this campaign
for campaign_device_metadata in new_campaign.device_metadata():
pprint(campaign_device_metadata.to_dict())
# end of example
new_campaign.stop()
new_campaign.read()
print("Campaign Phase:", new_campaign.phase)
new_campaign.delete()
def test_certificate_black_listing(self):
from mbed_cloud.foundation import TrustedCertificate
# Find a production certificate
my_certificate = TrustedCertificate().list(filter={
"device_execution_mode": {
"neq": 1
}
}).first()
my_cert_id = my_certificate.id
# Record the original status to revert to its original state at the end
original_status = TrustedCertificate(id=my_cert_id).read().status
# an example: certificate black listing
from mbed_cloud import SDK
from mbed_cloud import ApiFilter
from mbed_cloud.foundation.enums import TrustedCertificateStatusEnum
pelion_dm_sdk = SDK()
# Set the certificate to inactive
my_cert = pelion_dm_sdk.foundation.trusted_certificate(
id=my_cert_id).read()
my_cert.status = TrustedCertificateStatusEnum.INACTIVE
my_cert.update()
# List all devices which have tried to bootstrap
api_filter = ApiFilter()
api_filter.add_filter("trusted_certificate_id", "eq", my_cert)
for device_denial in pelion_dm_sdk.foundation.device_enrollment_denial(
).list(filter=api_filter):
print("Device endpoint name: %s" % device_denial.endpoint_name)
# end of example
new_status = my_cert.read().status
self.assertEqual(TrustedCertificateStatusEnum.INACTIVE, new_status,
"Status should have been set to disabled")
# Revert the certificate to its original status
my_cert.status = original_status
my_cert.update()
end_status = my_cert.read().status
self.assertEqual(
original_status, end_status,
"Status should have been reverted back to its original value")
def test_add_filter(self):
api_filter = ApiFilter()
self.assertEqual({}, api_filter.to_api())
api_filter.add_filter("created_at", "gte", datetime(2019, 1, 1))
expected_filter = {"created_at__gte": "2019-01-01T00:00:00Z"}
self.assertEqual(expected_filter, api_filter.to_api())
api_filter.add_filter("created_at", "lte", date(2019, 12, 31))
expected_filter = {
"created_at__gte": "2019-01-01T00:00:00Z",
"created_at__lte": "2019-12-31"
}
self.assertEqual(expected_filter, api_filter.to_api())
api_filter.add_filter("status", "eq", True)
expected_filter = {
"created_at__gte": "2019-01-01T00:00:00Z",
"created_at__lte": "2019-12-31",
"status__eq": "true"
}
expected_query_string = "created_at__gte=2019-01-01T00:00:00Z&created_at__lte=2019-12-31&status__eq=true"
self.assertEqual(expected_filter, api_filter.to_api())
self.assertEqual(expected_query_string, api_filter.to_query_string())
