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,
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, message=None, successful=None):
"""Creates a local `VerificationResponse` 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 message: Provides details in case of failure.
:type message: str
:param successful: Indicates whether the certificate issuer was verified
successfully.
:type successful: bool
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._message = fields.StringField(value=message)
self._successful = fields.BooleanField(value=successful)
def __init__(
self,
_client=None,
account_id=None,
certificate=None,
certificate_fingerprint=None,
created_at=None,
description=None,
device_execution_mode=None,
enrollment_mode=None,
id=None,
is_developer_certificate=None,
issuer=None,
name=None,
owner_id=None,
service=None,
status=None,
subject=None,
updated_at=None,
valid=None,
validity=None,
):
"""Creates a local `SubtenantTrustedCertificate` 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.
:type account_id: str
:param certificate: (Required) X509.v3 trusted certificate in PEM format.
:type certificate: str
:param certificate_fingerprint: A SHA-256 fingerprint of the certificate.
:type certificate_fingerprint: str
:param created_at: Creation UTC time RFC3339.
:type created_at: datetime
:param description: Human readable description of this certificate.
:type description: str
:param device_execution_mode: Device execution mode where 1 means a developer certificate.
:type device_execution_mode: int
:param enrollment_mode: If true, signature is not required. Default value false.
:type enrollment_mode: bool
:param id: (Required) Entity ID.
:type id: str
:param is_developer_certificate: Whether or not this certificate is a developer certificate.
:type is_developer_certificate: bool
:param issuer: Issuer of the certificate.
:type issuer: str
:param name: (Required) Certificate name.
:type name: str
:param owner_id: The ID of the owner.
:type owner_id: str
:param service: (Required) Service name where the certificate is used.
:type service: str
:param status: Status of the certificate.
:type status: str
:param subject: Subject of the certificate.
:type subject: str
:param updated_at: Last update UTC time RFC3339.
:type updated_at: datetime
:param valid: This read-only flag indicates whether the certificate is valid or
not.
:type valid: bool
:param validity: Expiration time in UTC formatted as RFC3339.
:type validity: datetime
"""
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._certificate_fingerprint = fields.StringField(value=certificate_fingerprint)
self._created_at = fields.DateTimeField(value=created_at)
self._description = fields.StringField(value=description)
self._device_execution_mode = fields.IntegerField(value=device_execution_mode)
self._enrollment_mode = fields.BooleanField(value=enrollment_mode)
self._id = fields.StringField(value=id)
self._is_developer_certificate = fields.BooleanField(value=is_developer_certificate)
self._issuer = fields.StringField(value=issuer)
self._name = fields.StringField(value=name)
self._owner_id = fields.StringField(value=owner_id)
self._service = fields.StringField(value=service, enum=enums.SubtenantTrustedCertificateServiceEnum)
self._status = fields.StringField(value=status, enum=enums.SubtenantTrustedCertificateStatusEnum)
self._subject = fields.StringField(value=subject)
self._updated_at = fields.DateTimeField(value=updated_at)
self._valid = fields.BooleanField(value=valid)
self._validity = fields.DateTimeField(value=validity)
def __init__(
self,
_client=None,
account_id=None,
active_sessions=None,
address=None,
created_at=None,
creation_time=None,
custom_fields=None,
email=None,
email_verified=None,
full_name=None,
id=None,
is_gtc_accepted=None,
is_marketing_accepted=None,
is_totp_enabled=None,
last_login_time=None,
login_history=None,
login_profiles=None,
password=None,
password_changed_time=None,
phone_number=None,
status=None,
totp_scratch_codes=None,
updated_at=None,
username=None,
):
"""Creates a local `User` 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 ID of the account.
:type account_id: str
:param active_sessions: List of active user sessions.
:type active_sessions: list
:param address: Address.
:type address: str
:param created_at: Creation UTC time RFC3339.
:type created_at: datetime
:param creation_time: A timestamp of the user creation in the storage, in milliseconds.
:type creation_time: int
:param custom_fields: User's account-specific custom properties. The value is a string.
:type custom_fields: dict
:param email: (Required) The email address.
:type email: str
:param email_verified: A flag indicating whether the user's email address has been
verified or not.
:type email_verified: bool
:param full_name: The full name of the user.
:type full_name: str
:param id: (Required) The ID of the user.
:type id: str
:param is_gtc_accepted: A flag indicating that the user has accepted General Terms and
Conditions.
:type is_gtc_accepted: bool
:param is_marketing_accepted: A flag indicating that the user has consented to receive marketing
information.
:type is_marketing_accepted: bool
:param is_totp_enabled: A flag indicating whether two-factor authentication (TOTP) has
been enabled.
:type is_totp_enabled: bool
:param last_login_time: A timestamp of the latest login of the user, in milliseconds.
:type last_login_time: int
:param login_history: Timestamps, succeedings, IP addresses and user agent information
of the last five logins of the user, with timestamps in RFC3339
format.
:type login_history: list
: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 password: The password when creating a new user. It will be generated when
not present in the request.
:type password: str
:param password_changed_time: A timestamp of the latest change of the user password, in
milliseconds.
:type password_changed_time: int
:param phone_number: Phone number.
:type phone_number: str
:param status: The status of the user. ENROLLING state indicates that the user is
in the middle of the enrollment process. INVITED means that the
user has not accepted the invitation request. RESET means that the
password must be changed immediately. INACTIVE users are locked
out and not permitted to use the system.
:type status: str
:param totp_scratch_codes: A list of scratch codes for the two-factor authentication. Visible
only when 2FA is requested to be enabled or the codes regenerated.
:type totp_scratch_codes: list
:param updated_at: Last update UTC time RFC3339.
:type updated_at: datetime
:param username: A username.
:type username: str
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
from mbed_cloud.foundation.entities.accounts.active_session import ActiveSession
from mbed_cloud.foundation.entities.accounts.login_history import LoginHistory
from mbed_cloud.foundation.entities.accounts.login_profile import LoginProfile
# fields
self._account_id = fields.StringField(value=account_id)
self._active_sessions = fields.ListField(value=active_sessions,
entity=ActiveSession)
self._address = fields.StringField(value=address)
self._created_at = fields.DateTimeField(value=created_at)
self._creation_time = fields.IntegerField(value=creation_time)
self._custom_fields = fields.DictField(value=custom_fields)
self._email = fields.StringField(value=email)
self._email_verified = fields.BooleanField(value=email_verified)
self._full_name = fields.StringField(value=full_name)
self._id = fields.StringField(value=id)
self._is_gtc_accepted = fields.BooleanField(value=is_gtc_accepted)
self._is_marketing_accepted = fields.BooleanField(
value=is_marketing_accepted)
self._is_totp_enabled = fields.BooleanField(value=is_totp_enabled)
self._last_login_time = fields.IntegerField(value=last_login_time)
self._login_history = fields.ListField(value=login_history,
entity=LoginHistory)
self._login_profiles = fields.ListField(value=login_profiles,
entity=LoginProfile)
self._password = fields.StringField(value=password)
self._password_changed_time = fields.IntegerField(
value=password_changed_time)
self._phone_number = fields.StringField(value=phone_number)
self._status = fields.StringField(value=status,
enum=enums.UserStatusEnum)
self._totp_scratch_codes = fields.ListField(value=totp_scratch_codes)
self._updated_at = fields.DateTimeField(value=updated_at)
self._username = fields.StringField(value=username)
def __init__(
self,
_client=None,
changes=None,
created_at=None,
data=None,
date_time=None,
description=None,
device_id=None,
event_type=None,
event_type_category=None,
event_type_description=None,
id=None,
state_change=None,
):
"""Creates a local `DeviceEvents` 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 changes:
:type changes: dict
:param created_at:
:type created_at: datetime
:param data: Additional data relevant to the event.
:type data: dict
:param date_time:
:type date_time: datetime
:param description:
:type description: str
:param device_id:
:type device_id: str
:param event_type: Event code
:type event_type: str
:param event_type_category: Category code which groups the event type by a summary category.
:type event_type_category: str
:param event_type_description: Generic description of the event
:type event_type_description: str
:param id: (Required)
:type id: str
:param state_change:
:type state_change: bool
"""
super().__init__(_client=_client)
# inline imports for avoiding circular references and bulk imports
# fields
self._changes = fields.DictField(value=changes)
self._created_at = fields.DateTimeField(value=created_at)
self._data = fields.DictField(value=data)
self._date_time = fields.DateTimeField(value=date_time)
self._description = fields.StringField(value=description)
self._device_id = fields.StringField(value=device_id)
self._event_type = fields.StringField(value=event_type)
self._event_type_category = fields.StringField(
value=event_type_category)
self._event_type_description = fields.StringField(
value=event_type_description)
self._id = fields.StringField(value=id)
self._state_change = fields.BooleanField(value=state_change)