def __init__(self,
_client=None,
color=None,
reference=None,
updated_at=None):
"""Creates a local `SubtenantDarkThemeColor` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param color: The color given as name (purple) or as a hex code.
:type color: str
:param reference: Color name.
:type reference: str
:param updated_at: Last update time in UTC.
:type updated_at: datetime
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._color = fields.StringField(value=color)
self._reference = fields.StringField(
value=reference, enum=enums.SubtenantDarkThemeColorReferenceEnum)
self._updated_at = fields.DateTimeField(value=updated_at)
def __init__(self,
_client=None,
admin_email=None,
admin_name=None,
id=None):
"""Creates a local `ParentAccount` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param admin_email: The email address of the admin user who is the contact person of
the parent account.
:type admin_email: str
:param admin_name: The name of the admin user who is the contact person of the parent
account.
:type admin_name: str
:param id: The ID of the parent account.
:type id: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._admin_email = fields.StringField(value=admin_email)
self._admin_name = fields.StringField(value=admin_name)
self._id = fields.StringField(value=id)
def __init__(self,
_client=None,
created_at=None,
endpoint_name=None,
id=None):
"""Creates a local `PreSharedKey` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param created_at: The date-time (RFC3339) when this PSK was uploaded to Device
Management.
:type created_at: datetime
:param endpoint_name: The unique endpoint identifier that this PSK applies to. 16-64 [pr
intable](https://en.wikipedia.org/wiki/ASCII#Printable_characters)
(non-control) ASCII characters.
:type endpoint_name: str
:param id: The Id of the pre_shared_key, shadows the endpoint_name
:type id: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._created_at = fields.DateTimeField(value=created_at)
self._endpoint_name = fields.StringField(value=endpoint_name)
self._id = fields.StringField(value=id)
def __init__(self, _client=None, created_at=None, id=None, server_certificate=None, server_uri=None):
"""Creates a local `ServerCredentials` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param created_at: Creation UTC time RFC3339.
:type created_at: datetime
:param id: Unique entity ID.
:type id: str
:param server_certificate: PEM-format X.509 server certificate used to validate the server
certificate received during the TLS/DTLS handshake.
:type server_certificate: str
:param server_uri: Server URI that the client connects to.
:type server_uri: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._created_at = fields.DateTimeField(value=created_at)
self._id = fields.StringField(value=id)
self._server_certificate = fields.StringField(value=server_certificate)
self._server_uri = fields.StringField(value=server_uri)
def __init__(self,
_client=None,
reference=None,
static_uri=None,
updated_at=None):
"""Creates a local `DarkThemeImage` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param reference: Name of the image.
:type reference: str
:param static_uri: The static link to the image.
:type static_uri: str
:param updated_at: Last update time in UTC.
:type updated_at: datetime
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._reference = fields.StringField(
value=reference, enum=enums.DarkThemeImageReferenceEnum)
self._static_uri = fields.StringField(value=static_uri)
self._updated_at = fields.DateTimeField(value=updated_at)
def __init__(self, _client=None, date=None, ip_address=None, success=None, user_agent=None):
"""Creates a local `LoginHistory` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param date: UTC time RFC3339 for this login attempt.
:type date: datetime
:param ip_address: IP address of the client.
:type ip_address: str
:param success: Flag indicating whether login attempt was successful or not.
:type success: bool
:param user_agent: User Agent header from the login request.
:type user_agent: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._date = fields.DateTimeField(value=date)
self._ip_address = fields.StringField(value=ip_address)
self._success = fields.BooleanField(value=success)
self._user_agent = fields.StringField(value=user_agent)
def __init__(
self,
_client=None,
created_at=None,
description=None,
id=None,
issuer_attributes=None,
issuer_type=None,
name=None,
):
"""Creates a local `CertificateIssuer` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param created_at: Creation UTC time RFC3339.
:type created_at: datetime
:param description: General description for the certificate issuer.
:type description: str
:param id: (Required) The ID of the certificate issuer.
:type id: str
:param issuer_attributes: General attributes for connecting the certificate issuer.
When the
issuer_type is GLOBAL_SIGN, the value shall be empty.
When the
issuer_type is CFSSL_AUTH, see definition of CfsslAttributes.
:type issuer_attributes: dict
:param issuer_type: (Required) The type of the certificate issuer.
- GLOBAL_SIGN:
Certificates
are issued by GlobalSign service. The users must provide their own
GlobalSign account credentials.
- CFSSL_AUTH:
Certificates are
issued by CFSSL authenticated signing service.
The users must
provide their own CFSSL host_url and credentials.
:type issuer_type: str
:param name: (Required) Certificate issuer name, unique per account.
:type name: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._created_at = fields.DateTimeField(value=created_at)
self._description = fields.StringField(value=description)
self._id = fields.StringField(value=id)
self._issuer_attributes = fields.DictField(value=issuer_attributes)
self._issuer_type = fields.StringField(
value=issuer_type, enum=enums.CertificateIssuerTypeEnum)
self._name = fields.StringField(value=name)
def __init__(
self,
_client=None,
account_id=None,
created_at=None,
email=None,
expiration=None,
id=None,
login_profiles=None,
updated_at=None,
user_id=None,
):
"""Creates a local `SubtenantUserInvitation` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param account_id: (Required) The ID of the account the user is invited to.
:type account_id: str
:param created_at: Creation UTC time RFC3339.
:type created_at: datetime
:param email: (Required) Email address of the invited user.
:type email: str
:param expiration: Invitation expiration as UTC time RFC3339.
:type expiration: datetime
:param id: (Required) The ID of the invitation.
:type id: str
:param login_profiles: A list of login profiles for the user. Specified as the identity
providers the user is associated with.
:type login_profiles: list
:param updated_at: Last update UTC time RFC3339.
:type updated_at: datetime
:param user_id: The ID of the invited user.
:type user_id: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
from mbed_cloud.foundation.entities.accounts.login_profile import LoginProfile
# fields
self._account_id = fields.StringField(value=account_id)
self._created_at = fields.DateTimeField(value=created_at)
self._email = fields.StringField(value=email)
self._expiration = fields.DateTimeField(value=expiration)
self._id = fields.StringField(value=id)
self._login_profiles = fields.ListField(value=login_profiles,
entity=LoginProfile)
self._updated_at = fields.DateTimeField(value=updated_at)
self._user_id = fields.StringField(value=user_id)
def __init__(
self,
_client=None,
created_at=None,
datafile_checksum=None,
datafile_size=None,
datafile_url=None,
description=None,
id=None,
name=None,
updated_at=None,
):
"""Creates a local `FirmwareImage` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param created_at: The time the object was created
:type created_at: datetime
:param datafile_checksum: The checksum (sha256) generated for the datafile
:type datafile_checksum: str
:param datafile_size: The size of the datafile in bytes
:type datafile_size: int
:param datafile_url: The firmware image file URL
:type datafile_url: str
:param description: The description of the object
:type description: str
:param id: (Required) The firmware image ID
:type id: str
:param name: The firmware image name
:type name: str
:param updated_at: The time the object was updated
:type updated_at: datetime
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._created_at = fields.DateTimeField(value=created_at)
self._datafile_checksum = fields.StringField(value=datafile_checksum)
self._datafile_size = fields.IntegerField(value=datafile_size)
self._datafile_url = fields.StringField(value=datafile_url)
self._description = fields.StringField(value=description)
self._id = fields.StringField(value=id)
self._name = fields.StringField(value=name)
self._updated_at = fields.DateTimeField(value=updated_at)
def __init__(
self,
_client=None,
account_id=None,
claimed_at=None,
created_at=None,
enrolled_device_id=None,
enrollment_identity=None,
expires_at=None,
id=None,
):
"""Creates a local `DeviceEnrollment` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param account_id: ID
:type account_id: str
:param claimed_at: The time the device was claimed.
:type claimed_at: datetime
:param created_at: The time of the enrollment identity creation.
:type created_at: datetime
:param enrolled_device_id: The ID of the device in the Device Directory once it is
registered.
:type enrolled_device_id: str
:param enrollment_identity: (Required) Enrollment identity.
:type enrollment_identity: str
:param expires_at: The enrollment claim expiration time. If the device does not
connect to Device Management before expiration, the claim is
removed without separate notice.
:type expires_at: datetime
:param id: (Required) Enrollment identity.
:type id: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._account_id = fields.StringField(value=account_id)
self._claimed_at = fields.DateTimeField(value=claimed_at)
self._created_at = fields.DateTimeField(value=created_at)
self._enrolled_device_id = fields.StringField(value=enrolled_device_id)
self._enrollment_identity = fields.StringField(value=enrollment_identity)
self._expires_at = fields.DateTimeField(value=expires_at)
self._id = fields.StringField(value=id)
def __init__(
self,
_client=None,
created_at=None,
custom_attributes=None,
description=None,
devices_count=None,
id=None,
name=None,
updated_at=None,
):
"""Creates a local `DeviceGroup` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param created_at: The time the campaign was created.
:type created_at: datetime
:param custom_attributes: Up to ten custom key-value attributes. Note that keys cannot begin
with a number. Both keys and values are limited to 128 characters.
Updating this field replaces existing contents.
:type custom_attributes: dict
:param description: The description of the group.
:type description: str
:param devices_count: The number of devices in this group.
:type devices_count: int
:param id: (Required) The group ID.
:type id: str
:param name: Name of the group.
:type name: str
:param updated_at: The time the object was updated.
:type updated_at: datetime
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._created_at = fields.DateTimeField(value=created_at)
self._custom_attributes = fields.DictField(value=custom_attributes)
self._description = fields.StringField(value=description)
self._devices_count = fields.IntegerField(value=devices_count)
self._id = fields.StringField(value=id)
self._name = fields.StringField(value=name)
self._updated_at = fields.DateTimeField(value=updated_at)
def create(self, secret_hex):
"""Upload a PSK to Pelion Device Management.
`REST API Documentation <https://os.mbed.com/search/?q=Service+API+References+/v2/device-shared-keys>`_.
:param secret_hex: The secret of the PSK in hexadecimal. It is not case sensitive; 4a is
same as 4A, and it is allowed with or without 0x in the beginning. The
minimum length of the secret is 128 bits and maximum 256 bits.
:type secret_hex: str
:rtype: PreSharedKey
"""
# Conditionally setup the message body, fields which have not been set will not be sent to the API.
# This avoids null fields being rejected and allows the default value to be used.
body_params = {}
if self._id.value_set:
body_params["endpoint_name"] = self._id.to_api()
# Method parameters are unconditionally sent even if set to None
body_params["secret_hex"] = fields.StringField(secret_hex).to_api()
return self._client.call_api(
method="post",
path="/v2/device-shared-keys",
content_type="application/json",
body_params=body_params,
unpack=self,
)
def _to_query_param(sdk_value):
"""Convert a standard Python value to a value suitable for a query parameter value.
Note: This will not URL encode as this will be performed by the `requests` library
:param sdk_value: filter value
:return Value suitable for the query string
"""
# The values in a list need to be serialised individually to be rendered properly
if isinstance(sdk_value, list):
encoded_list = []
for list_value in sdk_value:
# Convert serialised value to string as the query parameter must be a string of comma separated values
encoded_list.append(str(_to_query_param(list_value)))
sdk_value = encoded_list
# If an entity has been provided as a value, extract the ID from the instance
if isinstance(sdk_value, Entity):
sdk_value = sdk_value.id
# Loop over the supported field types to find the type of the value and then serialise.
for field_type in _valid_field_types:
if isinstance(sdk_value, field_type.base_type):
return field_type(sdk_value).to_query_param()
# Default to a string field - this will happen for None values
return fields.StringField(sdk_value).to_query_param()
def update(self, account_id):
"""Updates a dark theme branding color.
`REST API Documentation <https://os.mbed.com/search/?q=Service+API+References+/v3/accounts/{account_id}/branding-colors/dark/{reference}>`_.
:param account_id: Account ID.
:type account_id: str
:rtype: SubtenantDarkThemeColor
"""
# Conditionally setup the message body, fields which have not been set will not be sent to the API.
# This avoids null fields being rejected and allows the default value to be used.
body_params = {}
if self._color.value_set:
body_params["color"] = self._color.to_api()
if self._updated_at.value_set:
body_params["updated_at"] = self._updated_at.to_api()
return self._client.call_api(
method="put",
path="/v3/accounts/{account_id}/branding-colors/dark/{reference}",
content_type="application/json",
path_params={
"account_id": fields.StringField(account_id).to_api(),
"reference": self._reference.to_api()
},
body_params=body_params,
unpack=self,
)
def remove_device(self, device_id=None):
"""Remove a device from a group
`REST API Documentation <https://os.mbed.com/search/?q=Service+API+References+/v3/device-groups/{device-group-id}/devices/remove/>`_.
:param device_id: No description available
:type device_id: str
:rtype:
"""
# Conditionally setup the message body, fields which have not been set will not be sent to the API.
# This avoids null fields being rejected and allows the default value to be used.
body_params = {}
# Method parameters are unconditionally sent even if set to None
body_params["device_id"] = fields.StringField(device_id).to_api()
return self._client.call_api(
method="post",
path="/v3/device-groups/{device-group-id}/devices/remove/",
content_type="application/json",
body_params=body_params,
path_params={"device-group-id": self._id.to_api()},
unpack=self,
)
def _paginate_devices(self,
after=None,
filter=None,
order=None,
limit=None,
include=None):
"""Get a page of devices
:param after: The ID of The item after which to retrieve the next page.
:type after: str
:param filter: Optional API filter for listing resources.
:type filter: mbed_cloud.client.api_filter.ApiFilter
:param order: The order of the records based on creation time, `ASC` or `DESC`; by
default `ASC`.
:type order: str
:param limit: How many objects to retrieve in the page. The minimum limit is 2 and
the maximum is 1000. Limit values outside of this range are set to the
closest limit.
:type limit: int
:param include: Comma-separated list of data fields to return. Currently supported:
`total_count`.
:type include: str
:rtype: mbed_cloud.pagination.PaginatedResponse
"""
# Filter query parameters
query_params = filter.to_api() if filter else {}
# Add in other query parameters
query_params["after"] = fields.StringField(after).to_api()
query_params["order"] = fields.StringField(order).to_api()
query_params["limit"] = fields.IntegerField(limit).to_api()
query_params["include"] = fields.StringField(include).to_api()
return self._client.call_api(
method="get",
path="/v3/device-groups/{device-group-id}/devices/",
content_type="application/json",
query_params=query_params,
path_params={"device-group-id": self._id.to_api()},
unpack=False,
)
def _paginate_device_metadata(self,
after=None,
filter=None,
order=None,
limit=None,
include=None):
"""List all campaign device metadata
:param after: The ID of the the item after which to retrieve the next page
:type after: str
:param filter: Optional API filter for listing resources.
:type filter: mbed_cloud.client.api_filter.ApiFilter
:param order: ASC or DESC
:type order: str
:param limit: How many objects to retrieve in the page. The minimum limit is 2 and
the maximum is 1000. Limit values outside of this range are set to the
closest limit.
:type limit: int
:param include: A comma-separated list of data fields to return. Currently supported:
total_count
:type include: str
:rtype: mbed_cloud.pagination.PaginatedResponse
"""
# Filter query parameters
query_params = filter.to_api() if filter else {}
# Add in other query parameters
query_params["after"] = fields.StringField(after).to_api()
query_params["order"] = fields.StringField(
order, enum=enums.UpdateCampaignOrderEnum).to_api()
query_params["limit"] = fields.IntegerField(limit).to_api()
query_params["include"] = fields.StringField(include).to_api()
return self._client.call_api(
method="get",
path="/v3/update-campaigns/{campaign_id}/campaign-device-metadata/",
content_type="application/json",
query_params=query_params,
path_params={"campaign_id": self._id.to_api()},
unpack=False,
)
def _paginate_list(self,
after=None,
filter=None,
order="ASC",
limit=50,
include=None):
"""Get all trusted certificates.
:param after: The entity ID to fetch after the given one.
:type after: str
:param filter: Optional API filter for listing resources.
:type filter: mbed_cloud.client.api_filter.ApiFilter
:param order: Record order based on creation time. Acceptable values: ASC, DESC.
Default: ASC.
:type order: str
:param limit: The number of results to return (2-1000). Default 50.
:type limit: int
:param include: Comma-separated additional data to return. Currently supported:
total_count.
:type include: str
:rtype: mbed_cloud.pagination.PaginatedResponse
"""
# Filter query parameters
query_params = filter.to_api() if filter else {}
# Add in other query parameters
query_params["after"] = fields.StringField(after).to_api()
query_params["order"] = fields.StringField(
order, enum=enums.TrustedCertificateOrderEnum).to_api()
query_params["limit"] = fields.IntegerField(limit).to_api()
query_params["include"] = fields.StringField(include).to_api()
return self._client.call_api(
method="get",
path="/v3/trusted-certificates",
content_type="application/json",
query_params=query_params,
unpack=False,
)
def _paginate_list(self,
after=None,
filter=None,
order=None,
limit=None,
include=None):
"""Get certificate enrollments list.
:param after: The ID of the item after which to retrieve the next page.
:type after: str
:param filter: Optional API filter for listing resources.
:type filter: mbed_cloud.client.api_filter.ApiFilter
:param order: The order of results.
:type order: str
:param limit: The number of results to return (2-1000).
:type limit: int
:param include: a comma-separated list of data fields to return.
:type include: str
:rtype: mbed_cloud.pagination.PaginatedResponse
"""
# Filter query parameters
query_params = filter.to_api() if filter else {}
# Add in other query parameters
query_params["after"] = fields.StringField(after).to_api()
query_params["order"] = fields.StringField(
order, enum=enums.CertificateEnrollmentOrderEnum).to_api()
query_params["limit"] = fields.IntegerField(limit).to_api()
query_params["include"] = fields.StringField(
include, enum=enums.CertificateEnrollmentIncludeEnum).to_api()
return self._client.call_api(
method="get",
path="/v3/certificate-enrollments",
content_type="application/json",
query_params=query_params,
unpack=False,
)
def _paginate_list(self,
after=None,
filter=None,
order=None,
limit=None,
include=None):
"""Return list of devices which were denied to bootstrap due to being subjected to blacklisting.
:param after: Optional parameter for pagination. Denied device ID.
:type after: str
:param filter: Optional API filter for listing resources.
:type filter: mbed_cloud.client.api_filter.ApiFilter
:param order: Optional parameter for pagination.
:type order: str
:param limit: Optional parameter for pagination.
:type limit: int
:param include: Not supported by the API.
:type include: str
:rtype: mbed_cloud.pagination.PaginatedResponse
"""
# Filter query parameters
query_params = filter.to_api() if filter else {}
# Add in other query parameters
query_params["after"] = fields.StringField(after).to_api()
query_params["order"] = fields.StringField(
order, enum=enums.DeviceEnrollmentDenialOrderEnum).to_api()
query_params["limit"] = fields.IntegerField(limit).to_api()
query_params["include"] = fields.StringField(include).to_api()
return self._client.call_api(
method="get",
path="/v3/device-enrollment-denials",
content_type="application/json",
query_params=query_params,
unpack=False,
)
def __init__(self,
_client=None,
certificate_issuer_id=None,
created_at=None,
id=None,
reference=None,
updated_at=None):
"""Creates a local `CertificateIssuerConfig` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param certificate_issuer_id: (Required) The ID of the certificate issuer.
Null if Device Management
internal HSM is used.
:type certificate_issuer_id: str
:param created_at: Created UTC time RFC3339.
:type created_at: datetime
:param id: (Required) The ID of the certificate issuer configuration.
:type id: str
:param reference: (Required) The certificate name to which the certificate issuer configuration
applies.
:type reference: str
:param updated_at: Updated UTC time RFC3339.
:type updated_at: datetime
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._certificate_issuer_id = fields.StringField(
value=certificate_issuer_id)
self._created_at = fields.DateTimeField(value=created_at)
self._id = fields.StringField(value=id)
self._reference = fields.StringField(value=reference)
self._updated_at = fields.DateTimeField(value=updated_at)
def _paginate_list(self,
after=None,
filter=None,
order=None,
limit=None,
include=None):
"""List PSKs.
:param after: An offset token for fetching a specific page. Provided by the server.
:type after: str
:param filter: Optional API filter for listing resources.
:type filter: mbed_cloud.client.api_filter.ApiFilter
:param order: Not supported by the API.
:type order: str
:param limit: The number of entries per page.
:type limit: int
:param include: Not supported by the API.
:type include: str
:rtype: mbed_cloud.pagination.PaginatedResponse
"""
# Filter query parameters
query_params = filter.to_api() if filter else {}
# Add in other query parameters
query_params["after"] = fields.StringField(after).to_api()
query_params["order"] = fields.StringField(order).to_api()
query_params["limit"] = fields.IntegerField(limit).to_api()
query_params["include"] = fields.StringField(include).to_api()
return self._client.call_api(
method="get",
path="/v2/device-shared-keys",
content_type="application/json",
query_params=query_params,
unpack=False,
)
def __init__(self,
_client=None,
action=None,
allow=None,
feature=None,
inherited=None,
resource=None):
"""Creates a local `Policy` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param action: Comma-separated list of actions, empty string represents all
actions.
:type action: str
:param allow: True or false controlling whether an action is allowed or not.
:type allow: bool
:param feature: Feature name corresponding to this policy.
:type feature: str
:param inherited: Flag indicating whether this feature is inherited or overwritten
specifically.
:type inherited: bool
:param resource: Resource that is protected by this policy.
:type resource: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._action = fields.StringField(value=action)
self._allow = fields.BooleanField(value=allow)
self._feature = fields.StringField(value=feature)
self._inherited = fields.BooleanField(value=inherited)
self._resource = fields.StringField(value=resource)
def __init__(
self,
_client=None,
account_id=None,
certificate=None,
created_at=None,
description=None,
developer_private_key=None,
id=None,
name=None,
security_file_content=None,
):
"""Creates a local `DeveloperCertificate` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param account_id: Account to which the developer certificate belongs.
:type account_id: str
:param certificate: PEM-format X.509 developer certificate.
:type certificate: str
:param created_at: Creation UTC time RFC3339.
:type created_at: datetime
:param description: Description for the developer certificate.
:type description: str
:param developer_private_key: PEM-format developer private key associated with the certificate.
:type developer_private_key: str
:param id: (Required) ID that uniquely identifies the developer certificate.
:type id: str
:param name: (Required) Name of the developer certificate.
:type name: str
:param security_file_content: Content of the `security.c` file flashed to the device to provide
security credentials.
:type security_file_content: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._account_id = fields.StringField(value=account_id)
self._certificate = fields.StringField(value=certificate)
self._created_at = fields.DateTimeField(value=created_at)
self._description = fields.StringField(value=description)
self._developer_private_key = fields.StringField(
value=developer_private_key)
self._id = fields.StringField(value=id)
self._name = fields.StringField(value=name)
self._security_file_content = fields.StringField(
value=security_file_content)
def __init__(
self,
_client=None,
created_at=None,
datafile_size=None,
datafile_url=None,
description=None,
device_class=None,
id=None,
key_table_url=None,
name=None,
timestamp=None,
updated_at=None,
):
"""Creates a local `FirmwareManifest` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param created_at: The time the object was created
:type created_at: datetime
:param datafile_size: The size of the datafile in bytes
:type datafile_size: int
:param datafile_url: The URL of the firmware manifest binary
:type datafile_url: str
:param description: The description of the firmware manifest
:type description: str
:param device_class: The class of the device
:type device_class: str
:param id: (Required) The firmware manifest ID
:type id: str
:param key_table_url: The key table of pre-shared keys for devices
:type key_table_url: str
:param name: The name of the object
:type name: str
:param timestamp: The firmware manifest version as a timestamp
:type timestamp: datetime
:param updated_at: The time the object was updated
:type updated_at: datetime
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._created_at = fields.DateTimeField(value=created_at)
self._datafile_size = fields.IntegerField(value=datafile_size)
self._datafile_url = fields.StringField(value=datafile_url)
self._description = fields.StringField(value=description)
self._device_class = fields.StringField(value=device_class)
self._id = fields.StringField(value=id)
self._key_table_url = fields.StringField(value=key_table_url)
self._name = fields.StringField(value=name)
self._timestamp = fields.DateTimeField(value=timestamp)
self._updated_at = fields.DateTimeField(value=updated_at)
def __init__(self,
_client=None,
account_id=None,
created_at=None,
endpoint_name=None,
id=None,
trusted_certificate_id=None):
"""Creates a local `DeviceEnrollmentDenial` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param account_id: account id
:type account_id: str
:param created_at: date on which the failed bootstrap was attempted on
:type created_at: datetime
:param endpoint_name: endpoint name
:type endpoint_name: str
:param id: id of the recorded failed bootstrap attempt
:type id: str
:param trusted_certificate_id: Trusted certificate id
:type trusted_certificate_id: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._account_id = fields.StringField(value=account_id)
self._created_at = fields.DateTimeField(value=created_at)
self._endpoint_name = fields.StringField(value=endpoint_name)
self._id = fields.StringField(value=id)
self._trusted_certificate_id = fields.StringField(
value=trusted_certificate_id)
def __init__(self,
_client=None,
account_id=None,
ip_address=None,
login_time=None,
reference_token=None,
user_agent=None):
"""Creates a local `ActiveSession` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param account_id: The UUID of the account.
:type account_id: str
:param ip_address: IP address of the client.
:type ip_address: str
:param login_time: The login time of the user.
:type login_time: datetime
:param reference_token: The reference token.
:type reference_token: str
:param user_agent: User Agent header from the login request.
:type user_agent: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._account_id = fields.StringField(value=account_id)
self._ip_address = fields.StringField(value=ip_address)
self._login_time = fields.DateTimeField(value=login_time)
self._reference_token = fields.StringField(value=reference_token)
self._user_agent = fields.StringField(value=user_agent)
def __init__(self, _client=None, id=None, name=None):
"""Creates a local `LoginProfile` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param id: ID of the identity provider.
:type id: str
:param name: Name of the identity provider.
:type name: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._id = fields.StringField(value=id)
self._name = fields.StringField(value=name)
def _paginate_list(self, after=None, filter=None, order="ASC", limit=None, include=None):
"""Get a list of enrollments per account.
:param after: Entity ID to fetch after.
:type after: str
:param filter: Optional API filter for listing resources.
:type filter: mbed_cloud.client.api_filter.ApiFilter
:param order: ASC or DESC
:type order: str
:param limit: Number of results to return (2-1000).
:type limit: int
:param include: Comma-separated additional data to return. Currently supported:
total_count.
:type include: str
:rtype: mbed_cloud.pagination.PaginatedResponse
"""
# Filter query parameters
query_params = filter.to_api() if filter else {}
# Add in other query parameters
query_params["after"] = fields.StringField(after).to_api()
query_params["order"] = fields.StringField(order, enum=enums.DeviceEnrollmentOrderEnum).to_api()
query_params["limit"] = fields.IntegerField(limit).to_api()
query_params["include"] = fields.StringField(include).to_api()
return self._client.call_api(
method="get",
path="/v3/device-enrollments",
content_type="application/json",
query_params=query_params,
unpack=False,
)
def __init__(
self,
_client=None,
certificate_name=None,
created_at=None,
device_id=None,
enroll_result=None,
enroll_result_detail=None,
enroll_status=None,
id=None,
updated_at=None,
):
"""Creates a local `CertificateEnrollment` instance
Parameters can be supplied on creation of the instance or given by
setting the properties on the instance after creation.
Parameters marked as `required` must be set for one or more operations
on the entity. For details on when they are required please see the
documentation for the setter method.
:param certificate_name: The certificate name.
:type certificate_name: str
:param created_at: Creation UTC time RFC3339.
:type created_at: datetime
:param device_id: The device ID.
:type device_id: str
:param enroll_result: The result of certificate enrollment request.
:type enroll_result: str
:param enroll_result_detail: Additional information in case of failure.
:type enroll_result_detail: str
:param enroll_status: The status of certificate enrollment request.
:type enroll_status: str
:param id: (Required) The certificate enrollment ID.
:type id: str
:param updated_at: Update UTC time RFC3339.
:type updated_at: datetime
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._certificate_name = fields.StringField(value=certificate_name)
self._created_at = fields.DateTimeField(value=created_at)
self._device_id = fields.StringField(value=device_id)
self._enroll_result = fields.StringField(
value=enroll_result,
enum=enums.CertificateEnrollmentEnrollResultEnum)
self._enroll_result_detail = fields.StringField(
value=enroll_result_detail)
self._enroll_status = fields.StringField(
value=enroll_status,
enum=enums.CertificateEnrollmentEnrollStatusEnum)
self._id = fields.StringField(value=id)
self._updated_at = fields.DateTimeField(value=updated_at)
