Office365-REST-Python-Client 2.4.2__py3-none-any.whl → 2.4.4__py3-none-any.whl

office365/base_item.py

@@ -1,10 +1,12 @@
+from datetime import datetime
 from office365.directory.permissions.identity_set import IdentitySet
 from office365.entity import Entity
 from office365.onedrive.listitems.item_reference import ItemReference
+from office365.runtime.paths.resource_path import ResourcePath
 
 
 class BaseItem(Entity):
-    """The baseItem resource is an abstract resource that contains a common set of properties shared among several
+    """The baseItem resource is an abstract resource that contains a auth set of properties shared among several
     other resources types """
 
     @property
@@ -17,20 +19,38 @@ class BaseItem(Entity):
         """Identity of the user, device, or application which created the item."""
         return self.properties.get('createdBy', IdentitySet())
 
+    @property
+    def created_by_user(self):
+        """
+        Identity of the user who created the item
+        """
+        from office365.directory.users.user import User
+        return self.properties.get('createdByUser',
+                                   User(self.context, ResourcePath("createdByUser", self.resource_path)))
+
     @property
     def last_modified_by(self):
         """Identity of the user, device, and application which last modified the item."""
         return self.properties.get('lastModifiedBy', IdentitySet())
 
+    @property
+    def last_modified_by_user(self):
+        """
+        Identity of the user who last modified the item.
+        """
+        from office365.directory.users.user import User
+        return self.properties.get('lastModifiedByUser',
+                                   User(self.context, ResourcePath("lastModifiedByUser", self.resource_path)))
+
     @property
     def created_datetime(self):
         """Gets date and time of item creation."""
-        return self.properties.get('createdDateTime', None)
+        return self.properties.get('createdDateTime', datetime.min)
 
     @property
     def last_modified_datetime(self):
         """Gets date and time the item was last modified."""
-        return self.properties.get('lastModifiedDateTime', None)
+        return self.properties.get('lastModifiedDateTime', datetime.min)
 
     @property
     def name(self):
@@ -50,7 +70,6 @@ class BaseItem(Entity):
     def description(self):
         """
         Provides a user-visible description of the item.
-
         :rtype: str or None
         """
         return self.properties.get('description', None)
@@ -63,7 +82,6 @@ class BaseItem(Entity):
     def web_url(self):
         """
         URL that displays the resource in the browser.
-
         :rtype: str or None
         """
         return self.properties.get('webUrl', None)
@@ -81,7 +99,11 @@ class BaseItem(Entity):
         if default_value is None:
             property_mapping = {
                 "createdBy": self.created_by,
+                "createdByUser": self.created_by_user,
+                "createdDateTime": self.created_datetime,
+                "lastModifiedDateTime": self.last_modified_datetime,
                 "lastModifiedBy": self.last_modified_by,
+                "lastModifiedByUser": self.last_modified_by_user,
                 "parentReference": self.parent_reference
             }
             default_value = property_mapping.get(name, None)

office365/booking/business.py

@@ -0,0 +1,7 @@
+from office365.entity import Entity
+
+
+class BookingBusiness(Entity):
+    """Represents a business in Microsoft Bookings. This is the top level object in the Microsoft Bookings API.
+    It contains business information and related business objects such as appointments, customers, services,
+    and staff members."""

office365/booking/currency.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class BookingCurrency(Entity):
+    """Represents a monetary currency supported by a bookingBusiness."""

office365/booking/solutions_root.py

@@ -0,0 +1,32 @@
+from office365.booking.business import BookingBusiness
+from office365.booking.currency import BookingCurrency
+from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.runtime.paths.resource_path import ResourcePath
+
+
+class SolutionsRoot(Entity):
+    """"""
+
+    @property
+    def booking_businesses(self):
+        """	Get a collection of bookingBusiness objects that has been created for the tenant."""
+        return self.properties.get('bookingBusinesses',
+                                   EntityCollection(self.context, BookingBusiness,
+                                                    ResourcePath("bookingBusinesses", self.resource_path)))
+
+    @property
+    def booking_currencies(self):
+        """Get a list of bookingCurrency objects available to a Microsoft Bookings business"""
+        return self.properties.get('bookingCurrencies',
+                                   EntityCollection(self.context, BookingCurrency,
+                                                    ResourcePath("bookingCurrencies", self.resource_path)))
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "bookingBusinesses": self.booking_businesses,
+                "bookingCurrencies": self.booking_currencies
+            }
+            default_value = property_mapping.get(name, None)
+        return super(SolutionsRoot, self).get_property(name, default_value)

office365/communications/calls/invitation_participant_info.py

@@ -1,6 +1,22 @@
+from office365.directory.permissions.identity_set import IdentitySet
 from office365.runtime.client_value import ClientValue
 
 
 class InvitationParticipantInfo(ClientValue):
     """This resource is used to represent the entity that is being invited to a group call."""
-    pass
+
+    def __init__(self, hidden=None, identity=IdentitySet(), participant_id=None,
+                 remove_from_default_audio_routing_group=None, replaces_call_id=None):
+        """
+        :param bool hidden: Optional. Whether to hide the participant from the roster.
+        :param IdentitySet identity: The identitySet associated with this invitation.
+        :param str participant_id: Optional. The ID of the target participant.
+        :param bool remove_from_default_audio_routing_group: Optional. Whether to remove them from the main mixer.
+        :param str replaces_call_id: Optional. The call which the target identity is currently a part of.
+            For peer-to-peer case, the call will be dropped once the participant is added successfully.
+        """
+        self.hidden = hidden
+        self.identity = identity
+        self.participantId = participant_id
+        self.removeFromDefaultAudioRoutingGroup = remove_from_default_audio_routing_group
+        self.replacesCallId = replaces_call_id

office365/communications/calls/options.py

@@ -3,3 +3,12 @@ from office365.runtime.client_value import ClientValue
 
 class CallOptions(ClientValue):
     """Represents an abstract base class that contains the optional features for a call."""
+
+    def __init__(self, hide_bot_after_escalation=None, is_content_sharing_notification_enabled=None):
+        """
+        :param bool hide_bot_after_escalation: Indicates whether to hide the app after the call is escalated.
+        :param bool is_content_sharing_notification_enabled: Indicates whether content sharing notifications should be
+           enabled for the call.
+        """
+        self.hideBotAfterEscalation = hide_bot_after_escalation
+        self.isContentSharingNotificationEnabled = is_content_sharing_notification_enabled

office365/communications/onlinemeetings/provider_type.py

@@ -5,6 +5,9 @@ class OnlineMeetingProviderType:
         pass
 
     unknown = 0
+
     skypeForBusiness = 1
+
     skypeForConsumer = 2
+
     teamsForBusiness = 3

office365/communications/presences/presence.py

@@ -1,4 +1,6 @@
+from office365.communications.presences.status_message import PresenceStatusMessage
 from office365.entity import Entity
+from office365.outlook.mail.item_body import ItemBody
 from office365.runtime.queries.service_operation import ServiceOperationQuery
 
 
@@ -46,6 +48,18 @@ class Presence(Entity):
         self.context.add_query(qry)
         return self
 
+    def set_status_message(self, message):
+        """
+        Set a presence status message for a user. An optional expiration date and time can be supplied.
+        :param str message: Status message item.
+        """
+        payload = {
+            "statusMessage": PresenceStatusMessage(ItemBody(message))
+        }
+        qry = ServiceOperationQuery(self, "setStatusMessage", None, payload)
+        self.context.add_query(qry)
+        return self
+
     def set_user_preferred_presence(self, availability="Available", activity="Available", expiration_duration=None):
         """
         Set the preferred availability and activity status for a user. If the preferred presence of a user is set,

office365/communications/presences/status_message.py

@@ -0,0 +1,12 @@
+from office365.outlook.mail.item_body import ItemBody
+from office365.runtime.client_value import ClientValue
+
+
+class PresenceStatusMessage(ClientValue):
+    """Represents a presence status message related to the presence of a user in Microsoft Teams."""
+
+    def __init__(self, message=ItemBody()):
+        """
+        :param ItemBody message: Status message item.
+        """
+        self.message = message

office365/directory/administrative_unit.py

@@ -1,4 +1,7 @@
+from office365.directory.extensions.extension import Extension
 from office365.directory.object import DirectoryObject
+from office365.entity_collection import EntityCollection
+from office365.runtime.paths.resource_path import ResourcePath
 
 
 class AdministrativeUnit(DirectoryObject):
@@ -8,3 +11,22 @@ class AdministrativeUnit(DirectoryObject):
     the users, groups, and devices contained within or scoped to an administrative unit to a regional or
     departmental administrator. This resource is an open type that allows other properties to be passed in.
     """
+
+    @property
+    def members(self):
+        """
+        Users and groups that are members of this administrative unit
+        """
+        from office365.directory.object_collection import DirectoryObjectCollection
+        return self.properties.get('members',
+                                   DirectoryObjectCollection(self.context, ResourcePath("members", self.resource_path)))
+
+    @property
+    def extensions(self):
+        """
+        The collection of open extensions defined for this administrative unit.
+        """
+        return self.properties.get('extensions',
+                                   EntityCollection(self.context, Extension,
+                                                    ResourcePath("extensions", self.resource_path)))
+

office365/directory/applications/collection.py

@@ -1,5 +1,6 @@
 from office365.delta_collection import DeltaCollection
 from office365.directory.applications.application import Application
+from office365.runtime.paths.appid import AppIdPath
 
 
 class ApplicationCollection(DeltaCollection):
@@ -14,4 +15,4 @@ class ApplicationCollection(DeltaCollection):
         :param str app_id: Application client identifier
         :rtype: Application
         """
-        return self.filter("appId eq '{0}'".format(app_id)).single()
+        return Application(self.context, AppIdPath(app_id, self.resource_path))

office365/directory/applications/roles/assignment.py

@@ -1,5 +1,6 @@
+from datetime import datetime
+
 from office365.directory.object import DirectoryObject
-from office365.entity_collection import EntityCollection
 
 
 class AppRoleAssignment(DirectoryObject):
@@ -9,10 +10,49 @@ class AppRoleAssignment(DirectoryObject):
     An app role assignment is a relationship between the assigned principal (a user, a group, or a service principal),
     a resource application (the app's service principal) and an app role defined on the resource application.
     """
-    pass
 
+    @property
+    def app_role_id(self):
+        """
+        The identifier (id) for the app role which is assigned to the principal.
+        This app role must be exposed in the appRoles property on
+        the resource application's service principal (resourceId). If the resource application has not declared
+        any app roles, a default app role ID of 00000000-0000-0000-0000-000000000000 can be specified to signal
+        that the principal is assigned to the resource app without any specific app roles. Required on create.
+        :rtype: str
+        """
+        return self.properties.get("appRoleId", None)
+
+    @property
+    def created_datetime(self):
+        """The time when the app role assignment was created."""
+        return self.properties.get('createdDateTime', datetime.min)
+
+    @property
+    def principal_display_name(self):
+        """The display name of the user, group, or service principal that was granted the app role assignment."""
+        return self.properties.get('principalDisplayName', None)
+
+    @property
+    def principal_id(self):
+        """The unique identifier (id) for the user, security group, or service principal being granted the app role.
+        Security groups with dynamic memberships are supported. Required on create."""
+        return self.properties.get('principalId', None)
+
+    @property
+    def principal_type(self):
+        """The type of the assigned principal. This can either be User, Group, or ServicePrincipal."""
+        return self.properties.get('principalType', None)
+
+    @property
+    def resource_display_name(self):
+        """The display name of the resource app's service principal to which the assignment is made."""
+        return self.properties.get('resourceDisplayName', None)
+
+    @property
+    def resource_id(self):
+        """The unique identifier (id) for the resource service principal for which the assignment is made.
+        Required on create. """
+        return self.properties.get('resourceId', None)
 
-class AppRoleAssignmentCollection(EntityCollection):
 
-    def __init__(self, context, resource_path=None):
-        super(AppRoleAssignmentCollection, self).__init__(context, AppRoleAssignment, resource_path)

office365/directory/applications/roles/assignment_collection.py

@@ -0,0 +1,8 @@
+from office365.directory.applications.roles.assignment import AppRoleAssignment
+from office365.entity_collection import EntityCollection
+
+
+class AppRoleAssignmentCollection(EntityCollection):
+
+    def __init__(self, context, resource_path=None):
+        super(AppRoleAssignmentCollection, self).__init__(context, AppRoleAssignment, resource_path)

office365/directory/applications/roles/role.py

@@ -8,7 +8,7 @@ class AppRole(ClientValue):
     or that can be used to assign an application to users or groups in a specified role.
     """
 
-    def __init__(self, allowed_member_types=None):
+    def __init__(self, allowed_member_types=None, description=None, display_name=None, is_enabled=None, origin=None):
         """
         :param list[str] allowed_member_types: Specifies whether this app role can be assigned to users and groups
             (by setting to ["User"]), to other application's (by setting to ["Application"], or both (by setting to
@@ -17,3 +17,8 @@ class AppRole(ClientValue):
             on application entities.
         """
         self.allowedMemberTypes = StringCollection(allowed_member_types)
+        self.description = description
+        self.displayName = display_name
+        self.isEnabled = is_enabled
+        self.origin = origin
+

office365/directory/audit/signins/activity.py

@@ -0,0 +1,31 @@
+from office365.runtime.client_value import ClientValue
+
+
+class SignInActivity(ClientValue):
+    """Provides the last interactive or non-interactive sign-in time for a specific user. Since signInActivity
+    describes a property of the user object, Azure AD stores sign in activity for your users for as long as the
+    user object exists."""
+
+    def __init__(self, last_non_interactive_sign_in_datetime=None, last_non_interactive_sign_in_request_id=None,
+                 last_sign_in_datetime=None, last_sign_in_request_id=None):
+        """
+        :param datetime.datetime last_non_interactive_sign_in_datetime: The last non-interactive sign-in date for a
+            specific user. You can use this field to calculate the last time a client attempted to sign into the
+            directory on behalf of a user. Because some users may use clients to access tenant resources rather
+            than signing into your tenant directly, you can use the non-interactive sign-in date to along with
+            lastSignInDateTime to identify inactive users.
+        :param str last_non_interactive_sign_in_request_id: Request identifier of the last non-interactive sign-in
+            performed by this user.
+        :param datetime.datetime last_sign_in_datetime: The last interactive sign-in date and time for a specific user.
+            You can use this field to calculate the last time a user attempted to sign into the directory with an
+            interactive authentication method. This field can be used to build reports, such as inactive users.
+            The timestamp represents date and time information using ISO 8601 format and is always in UTC time.
+            For example, midnight UTC on Jan 1, 2014 is: '2014-01-01T00:00:00Z'. Azure AD maintains interactive
+            sign-ins going back to April 2020. For more information about using the value of this property,
+            see Manage inactive user accounts in Azure AD.
+        :param str last_sign_in_request_id: Request identifier of the last interactive sign-in performed by this user.
+        """
+        self.lastNonInteractiveSignInDateTime = last_non_interactive_sign_in_datetime
+        self.lastNonInteractiveSignInRequestId = last_non_interactive_sign_in_request_id
+        self.lastSignInDateTime = last_sign_in_datetime
+        self.lastSignInRequestId = last_sign_in_request_id

office365/directory/audit/signins/location.py

@@ -1,5 +1,22 @@
+from office365.onedrive.driveitems.geo_coordinates import GeoCoordinates
 from office365.runtime.client_value import ClientValue
 
 
 class SignInLocation(ClientValue):
     """Provides the city, state and country/region from where the sign-in happened."""
+
+    def __init__(self, city=None, country_or_region=None, geo_coordinates=GeoCoordinates(), state=None):
+        """
+        :param str city: Provides the city where the sign-in originated. This is calculated using latitude/longitude
+            information from the sign-in activity.
+        :param str country_or_region: Provides the country code info (2 letter code) where the sign-in originated.
+            This is calculated using latitude/longitude information from the sign-in activity.
+        :param GeoCoordinates geo_coordinates: Provides the latitude, longitude and altitude where the sign-in
+            originated.
+        :param str state: Provides the State where the sign-in originated. This is calculated using latitude/longitude
+            information from the sign-in activity.
+        """
+        self.city = city
+        self.countryOrRegion = country_or_region
+        self.geoCoordinates = geo_coordinates
+        self.state = state

office365/directory/audit/signins/signin.py

@@ -9,6 +9,31 @@ class SignIn(Entity):
     You must have an Azure AD Premium P1 or P2 license to download sign-in logs using the Microsoft Graph API.
     """
 
+    @property
+    def app_display_name(self):
+        """
+        App name displayed in the Azure Portal.
+        :rtype: str
+        """
+        return self.properties.get("appDisplayName", None)
+
+    @property
+    def app_id(self):
+        """
+        Unique GUID representing the app ID in the Azure Active Directory.
+        :rtype: str
+        """
+        return self.properties.get("appId", None)
+
+    @property
+    def client_app_used(self):
+        """
+        Identifies the client used for the sign-in activity. Modern authentication clients include Browser, modern
+        clients. Legacy authentication clients include Exchange ActiveSync, IMAP, MAPI, SMTP, POP, and other clients.
+        :rtype: str
+        """
+        return self.properties.get("clientAppUsed", None)
+
     @property
     def device_detail(self):
         """Device information from where the sign-in occurred; includes device ID, operating system, and browser.
@@ -47,3 +72,11 @@ class SignIn(Entity):
         :rtype: str or None
         """
         return self.properties.get("status", SignInStatus())
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "deviceDetail": self.device_detail
+            }
+            default_value = property_mapping.get(name, None)
+        return super(SignIn, self).get_property(name, default_value)

office365/directory/authentication/authentication.py

@@ -10,6 +10,14 @@ class Authentication(Entity):
     for users.
     """
 
+    @property
+    def email_methods(self):
+        """The email address registered to a user for authentication."""
+        from office365.directory.authentication.methods.email import EmailAuthenticationMethod
+        return self.properties.get('emailMethods',
+                                   EntityCollection(self.context, EmailAuthenticationMethod,
+                                                    ResourcePath("emailMethods", self.resource_path)))
+
     @property
     def fido2_methods(self):
         """Represents the FIDO2 security keys registered to a user for authentication."""
@@ -45,6 +53,7 @@ class Authentication(Entity):
     def get_property(self, name, default_value=None):
         if default_value is None:
             property_mapping = {
+                "emailMethods": self.email_methods,
                 "fido2Methods": self.fido2_methods,
                 "passwordMethods": self.password_methods,
                 "phoneMethods": self.phone_methods

office365/directory/authentication/methods/details.py

@@ -0,0 +1,25 @@
+from office365.entity import Entity
+
+
+class UserRegistrationDetails(Entity):
+    """Represents the state of a user's authentication methods, including which methods are registered and which
+    features the user is registered and capable of (such as multi-factor authentication, self-service password reset,
+    and passwordless authentication)."""
+
+    @property
+    def is_admin(self):
+        """
+        Indicates whether the user has an admin role in the tenant. This value can be used to check the authentication
+        methods that privileged accounts are registered for and capable of.
+        :rtype: bool
+        """
+        return self.properties.get("isAdmin", None)
+
+    @property
+    def is_mfa_registered(self):
+        """
+        Indicates whether the user has registered a strong authentication method for multi-factor authentication.
+        The method may not necessarily be allowed by the authentication methods policy.
+        :rtype: bool
+        """
+        return self.properties.get("isMfaRegistered", None)

office365/directory/authentication/methods/email.py

@@ -0,0 +1,16 @@
+from office365.directory.authentication.methods.method import AuthenticationMethod
+
+
+class EmailAuthenticationMethod(AuthenticationMethod):
+    """
+    Represents an email address registered to a user. Email as an authentication method is available only for
+    self-service password reset (SSPR). Users may only have one email authentication method.
+    """
+
+    @property
+    def email_address(self):
+        """
+        The email address registered to this user.
+        :rtype: str
+        """
+        return self.properties.get("emailAddress", None)

office365/directory/authentication/methods/root.py

@@ -0,0 +1,27 @@
+from office365.directory.authentication.methods.details import UserRegistrationDetails
+from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.reports.userregistration.method_summary import UserRegistrationMethodSummary
+from office365.runtime.client_result import ClientResult
+from office365.runtime.paths.resource_path import ResourcePath
+from office365.runtime.queries.function import FunctionQuery
+
+
+class AuthenticationMethodsRoot(Entity):
+    """Container for navigation properties for Azure AD authentication methods resources."""
+
+    def users_registered_by_method(self):
+        """Get the number of users registered for each authentication method."""
+        return_type = ClientResult(self.context, UserRegistrationMethodSummary())
+        qry = FunctionQuery(self, "usersRegisteredByMethod", None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    @property
+    def user_registration_details(self):
+        """Represents the state of a user's authentication methods, including which methods are registered and which
+        features the user is registered and capable of (such as multi-factor authentication, self-service password
+        reset, and passwordless authentication)."""
+        return self.properties.get('userRegistrationDetails',
+                                   EntityCollection(self.context, UserRegistrationDetails,
+                                                    ResourcePath("userRegistrationDetails", self.resource_path)))

office365/directory/certificates/authority.py

@@ -4,14 +4,19 @@ from office365.runtime.client_value import ClientValue
 class CertificateAuthority(ClientValue):
     """Represents a certificate authority."""
 
-    def __init__(self, certificate=None, certificate_revocation_list_url=None, is_root_authority=None):
+    def __init__(self, certificate=None, certificate_revocation_list_url=None, is_root_authority=None,
+                 issuer=None, issuer_ski=None):
         """
         :param str certificate: The base64 encoded string representing the public certificate.
         :param str certificate_revocation_list_url: The URL of the certificate revocation list.
         :param str is_root_authority: Required. true if the trusted certificate is a root authority, false if the
             trusted certificate is an intermediate authority.
+        :param str issuer: The issuer of the certificate, calculated from the certificate value
+        :param str issuer_ski: The subject key identifier of the certificate, calculated from the certificate value.
         """
         super(CertificateAuthority, self).__init__()
         self.certificate = certificate
         self.certificateRevocationListUrl = certificate_revocation_list_url
         self.isRootAuthority = is_root_authority
+        self.issuer = issuer
+        self.issuerSki = issuer_ski

office365/directory/extensions/extended_property.py

@@ -4,7 +4,14 @@ from office365.runtime.types.collections import StringCollection
 
 class SingleValueLegacyExtendedProperty(Entity):
     """An extended property that contains a single value."""
-    pass
+
+    @property
+    def value(self):
+        """
+        A property value.
+        :rtype: str
+        """
+        return self.properties.get("value", None)
 
 
 class MultiValueLegacyExtendedProperty(Entity):

office365/directory/extensions/extension.py

@@ -3,4 +3,4 @@ from office365.entity import Entity
 
 class Extension(Entity):
     """An abstract type to support the OData v4 open type openTypeExtension."""
-    pass
+

office365/directory/extensions/extension_property.py

@@ -15,7 +15,6 @@ class ExtensionProperty(DirectoryObject):
     def name(self):
         """
         Name of the extension property.
-
         :rtype: str
         """
         return self.properties.get("name", None)
@@ -24,7 +23,6 @@ class ExtensionProperty(DirectoryObject):
     def app_display_name(self):
         """
         Display name of the application object on which this extension property is defined. Read-only.
-
         :rtype: str
         """
         return self.properties.get("appDisplayName", None)
@@ -39,7 +37,6 @@ class ExtensionProperty(DirectoryObject):
             Integer - 32-bit value.
             LargeInteger - 64-bit value.
             String - 256 characters maximum
-
         :rtype: str
         """
         return self.properties.get("dataType", None)

office365/directory/extensions/open_type.py

@@ -7,3 +7,11 @@ class OpenTypeExtension(Extension):
     an extensibility option that provides an easy way to directly add untyped properties to a resource
     in Microsoft Graph.
     """
+
+    @property
+    def extension_name(self):
+        """
+        A unique text identifier for an open type data extension. Optional.
+        :rtype: str
+        """
+        return self.properties.get("extensionName", None)

office365/directory/groups/collection.py

@@ -31,9 +31,7 @@ class GroupCollection(DeltaCollection):
         params.securityEnabled = False
         params.mailEnabled = True
         params.groupTypes = ["Unified"]
-        return_type = self.context.groups.add(params)
 
-        def _after_group_created():
+        def _after_group_created(return_type):
             return_type.add_team()
-        self.context.after_query_execute(_after_group_created)
-        return return_type
+        return self.context.groups.add(params).after_execute(_after_group_created)