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

office365/sharepoint/activities/logger.py

@@ -1,8 +1,33 @@
+from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.sharepoint.base_entity import BaseEntity
 
 
 class ActivityLogger(BaseEntity):
 
+    def log_activity(self, operation, list_id, list_item_unique_id, affected_resource_url, item_type,
+                     audit_creation_time, is_offline):
+        """
+        :param str operation:
+        :param str list_id:
+        :param str list_item_unique_id:
+        :param str affected_resource_url:
+        :param str item_type:
+        :param str audit_creation_time:
+        :param bool is_offline:
+        """
+        payload = {
+            "Operation": operation,
+            "ListId": list_id,
+            "ListItemUniqueId": list_item_unique_id,
+            "AffectedResourceUrl": affected_resource_url,
+            "ItemType": item_type,
+            "AuditCreationTime": audit_creation_time,
+            "IsOffline": is_offline
+        }
+        qry = ServiceOperationQuery(self, "LogActivity", None, payload)
+        self.context.add_query(qry)
+        return self
+
     @property
     def entity_type_name(self):
         return "Microsoft.SharePoint.Internal.ActivityLogger"

office365/sharepoint/activities/revision_info.py

@@ -0,0 +1,9 @@
+from office365.runtime.client_value import ClientValue
+
+
+class RevisionInfo(ClientValue):
+    """"""
+
+    @property
+    def entity_type_name(self):
+        return "Microsoft.SharePoint.Activities.RevisionInfo"

office365/sharepoint/addtoonedrive/mount_point.py

@@ -0,0 +1,25 @@
+from office365.runtime.queries.service_operation import ServiceOperationQuery
+from office365.sharepoint.addtoonedrive.mounted_folder_info import MountedFolderInfo
+from office365.sharepoint.base_entity import BaseEntity
+
+
+class MountPoint(BaseEntity):
+    """"""
+
+    @staticmethod
+    def get_mounted_folder_info(context, target_site_id, target_web_id, target_unique_id):
+        """
+        :type context: office365.sharepoint.client_context.ClientContext
+        :param str target_site_id:
+        :param str target_web_id:
+        :param str target_unique_id:
+        """
+        return_type = MountedFolderInfo(context)
+        payload = {
+            "targetSiteId": target_site_id,
+            "targetWebId": target_web_id,
+            "targetUniqueId": target_unique_id
+        }
+        qry = ServiceOperationQuery(context.web, "GetMountedFolderInfo", None, payload, None, return_type, True)
+        context.add_query(qry)
+        return return_type

office365/sharepoint/addtoonedrive/mounted_folder_info.py

@@ -0,0 +1,5 @@
+from office365.sharepoint.base_entity import BaseEntity
+
+
+class MountedFolderInfo(BaseEntity):
+    """"""

office365/sharepoint/alerts/alert.py

@@ -12,6 +12,37 @@ class Alert(BaseEntity):
     set for this type.
     """
 
+    @property
+    def alert_frequency(self):
+        """
+        Gets the time interval for sending the alert.
+        :rtype: int
+        """
+        return self.properties.get("AlertFrequency", None)
+
+    @property
+    def alert_template_name(self):
+        """
+        Gets the string representing the alert template name.
+        :rtype: int
+        """
+        return self.properties.get("AlertTemplateName", None)
+
+    @property
+    def always_notify(self):
+        """
+        Gets a Boolean value that causes daily and weekly alerts to trigger, even if there is no matching event.
+        :rtype: bool
+        """
+        return self.properties.get("AlwaysNotify", None)
+
+    @property
+    def item(self):
+        """Gets the list item or document to which the alert applies."""
+        from office365.sharepoint.listitems.listitem import ListItem
+        return self.properties.get('Item',
+                                   ListItem(self.context, ResourcePath("item", self.resource_path)))
+
     @property
     def user(self):
         """Gets user object that represents User for the alert."""

office365/sharepoint/apps/license_collection.py

@@ -6,6 +6,5 @@ from office365.sharepoint.apps.license import AppLicense
 class AppLicenseCollection(ClientValue):
     """Specifies a collection of marketplace licenses."""
 
-    def __init__(self, items = ClientValueCollection(AppLicense)):
+    def __init__(self, items=ClientValueCollection(AppLicense)):
         self.Items = items
-

office365/sharepoint/changes/item.py

@@ -6,6 +6,20 @@ from office365.sharepoint.sharing.shared_with_user import SharedWithUser
 class ChangeItem(Change):
     """A change on an item."""
 
+    @property
+    def activity_type(self):
+        """
+        Returns activity type defined in ChangeActivityType
+        """
+        return self.properties.get("ActivityType", None)
+
+    @property
+    def content_type_id(self):
+        """
+        Specifies an identifier for the content type
+        """
+        return self.properties.get("ContentTypeId", None)
+
     @property
     def shared_by_user(self):
         """Return the sharedBy User Information in sharing action for change log."""

office365/sharepoint/client_context.py

@@ -1,6 +1,7 @@
 import copy
 
 from office365.runtime.auth.authentication_context import AuthenticationContext
+from office365.runtime.auth.client_credential import ClientCredential
 from office365.runtime.auth.user_credential import UserCredential
 from office365.runtime.client_runtime_context import ClientRuntimeContext
 from office365.runtime.compat import urlparse, get_absolute_url
@@ -22,7 +23,7 @@ from office365.sharepoint.webs.web import Web
 
 
 class ClientContext(ClientRuntimeContext):
-    """SharePoint client context"""
+    """SharePoint client context (used for SharePoint v1 API)"""
 
     def __init__(self, base_url, auth_context=None):
         """
@@ -43,27 +44,21 @@ class ClientContext(ClientRuntimeContext):
     @staticmethod
     def from_url(full_url):
         """
-        Constructs ClientContext from absolute Url
+        Constructs a client from absolute resource url
 
-        :param str full_url: Full Url to a resource
-        :return: ClientContext
+        :param str full_url: Absolute Url to a resource
         """
         root_site_url = get_absolute_url(full_url)
         ctx = ClientContext(root_site_url)
-        result = Web.get_web_url_from_page_url(ctx, full_url)
 
-        def _init_context_for_web(resp):
-            """
-            :type resp: requests.Response
-            """
-            resp.raise_for_status()
-            ctx._auth_context.url = result.value
-
-        ctx.after_execute(_init_context_for_web)
+        def _init_context(return_type):
+            ctx._auth_context.url = return_type.value
+        Web.get_web_url_from_page_url(ctx, full_url).after_execute(_init_context)
         return ctx
 
     def with_client_certificate(self, tenant, client_id, thumbprint, cert_path=None, private_key=None, scopes=None):
-        """Creates authenticated SharePoint context via certificate credentials
+        """
+        Creates authenticated SharePoint context via certificate credentials
 
         :param str tenant: Tenant name
         :param str or None cert_path: Path to A PEM encoded certificate private key.
@@ -77,21 +72,49 @@ class ClientContext(ClientRuntimeContext):
                                                             scopes)
         return self
 
+    def with_interactive(self, tenant, client_id, scopes=None):
+        """
+        Initializes a client to acquire a token interactively i.e. via a local browser.
+
+        Prerequisite: In Azure Portal, configure the Redirect URI of your
+        "Mobile and Desktop application" as ``http://localhost``.
+
+        :param str tenant: Tenant name, for example: contoso.onmicrosoft.com
+        :param str client_id: The OAuth client id of the calling application.
+        :param list[str] or None scopes:  Scopes requested to access a protected API (a resource)
+        """
+        self.authentication_context.with_interactive(tenant, client_id, scopes)
+        return self
+
+    def with_device_flow(self, tenant, client_id, scopes=None):
+        """
+        Initializes a client to acquire a token via device flow auth.
+
+        :param str tenant: Tenant name, for example: contoso.onmicrosoft.com
+        :param str client_id: The OAuth client id of the calling application.
+        :param list[str] or None scopes:  Scopes requested to access a protected API (a resource)
+        """
+        self.authentication_context.with_device_flow(tenant, client_id, scopes)
+        return self
+
     def with_access_token(self, token_func):
         """
-        :type token_func: () -> TokenResponse
+        Initializes a client to acquire a token from a callback
+
+        :param () -> TokenResponse token_func: A callback
         """
         self.authentication_context.with_access_token(token_func)
         return self
 
     def with_user_credentials(self, username, password, allow_ntlm=False, browser_mode=False):
         """
-        Assigns credentials
+        Initializes a client to acquire a token via user credentials.
 
-        :type username: str
-        :type password: str
-        :type allow_ntlm: bool
-        :type browser_mode: bool
+
+        :param str username: Typically, a UPN in the form of an email address
+        :param str password: The password
+        :param bool allow_ntlm: Flag indicates whether NTLM scheme is enabled. Disabled by default
+        :param bool browser_mode:
         """
         self.authentication_context.with_credentials(
             UserCredential(username, password),
@@ -99,9 +122,22 @@ class ClientContext(ClientRuntimeContext):
             browser_mode=browser_mode)
         return self
 
+    def with_client_credentials(self, client_id, client_secret):
+        """
+        Initializes a client to acquire a token via client credentials (SharePoint App-Only)
+
+        SharePoint App-Only is the older, but still very relevant, model of setting up app-principals.
+        This model works for both SharePoint Online and SharePoint 2013/2016/2019 on-premises
+
+        :param str client_id: The OAuth client id of the calling application
+        :param str client_secret: Secret string that the application uses to prove its identity when requesting a token
+        """
+        self.authentication_context.with_credentials(ClientCredential(client_id, client_secret))
+        return self
+
     def with_credentials(self, credentials):
         """
-        Assigns credentials
+        Initializes a client to acquire a token via user or client credentials
 
         :type credentials: UserCredential or ClientCredential
         """
@@ -110,7 +146,7 @@ class ClientContext(ClientRuntimeContext):
 
     def execute_batch(self, items_per_batch=100):
         """
-        Construct and submit a batch request
+        Construct and submit to a server a batch request
 
         :param int items_per_batch: Maximum to be selected for bulk operation
         """
@@ -143,9 +179,13 @@ class ClientContext(ClientRuntimeContext):
         request.set_header('X-RequestDigest', self._ctx_web_info.FormDigestValue)
 
     def _get_context_web_information(self):
-        """Returns an ContextWebInformation object that specifies metadata about the site"""
+        """
+        Returns an ContextWebInformation object that specifies metadata about the site
+        """
         client = ODataRequest(JsonLightFormat())
-        client.beforeExecute += self._authenticate_request
+        for e in self.pending_request().beforeExecute:
+            client.beforeExecute += e
+        client.beforeExecute -= self._build_modification_query
         request = RequestOptions("{0}/contextInfo".format(self.service_root_url()))
         request.method = HttpMethod.Post
         response = client.execute_request_direct(request)
@@ -194,6 +234,10 @@ class ClientContext(ClientRuntimeContext):
         return ctx
 
     def _authenticate_request(self, request):
+        """
+        Authenticate request
+        :type request: office365.runtime.http.request_options.RequestOptions
+        """
         self.authentication_context.authenticate_request(request)
 
     def _build_modification_query(self, request):
@@ -205,7 +249,7 @@ class ClientContext(ClientRuntimeContext):
         if request.method == HttpMethod.Post:
             self._ensure_form_digest(request)
         # set custom SharePoint control headers
-        if isinstance(self.pending_request().default_json_format, JsonLightFormat):
+        if isinstance(self.pending_request().json_format, JsonLightFormat):
             if isinstance(self.current_query, DeleteEntityQuery):
                 request.ensure_header("X-HTTP-Method", "DELETE")
                 request.ensure_header("IF-MATCH", '*')
@@ -284,9 +328,8 @@ class ClientContext(ClientRuntimeContext):
 
     @property
     def context_info(self):
-        """Returns an ContextWebInformation object that specifies metadata about the site
-
-        :rtype: ContextWebInformation
+        """
+        Returns an ContextWebInformation object that specifies metadata about the site
         """
         if self._ctx_web_info is None:
             self._ctx_web_info = ContextWebInformation()
@@ -294,20 +337,26 @@ class ClientContext(ClientRuntimeContext):
 
     @property
     def web(self):
-        """Get Web client object"""
+        """
+        A group of related webpages that is hosted by a server on the World Wide Web or an intranet.
+        Each website has its own entry points, metadata, administration settings, and workflows.
+        """
         if not self._web:
             self._web = Web(self)
         return self._web
 
     @property
     def site(self):
-        """Get Site client object"""
+        """
+        Represents a collection of sites in a Web application, including a top-level website and all its sub sites.
+        """
         if not self._site:
             self._site = Site(self)
         return self._site
 
     @property
     def apps(self):
+        """"""
         from office365.sharepoint.apps.app_collection import AppCollection
         return AppCollection(self, ResourcePath("Apps"))
 
@@ -346,6 +395,12 @@ class ClientContext(ClientRuntimeContext):
         from office365.sharepoint.contentcenter.machinelearning.models.collection import SPMachineLearningModelCollection
         return SPMachineLearningModelCollection(self, ResourcePath("models"))
 
+    @property
+    def folder_coloring(self):
+        """Alias to FolderColoring"""
+        from office365.sharepoint.folders.coloring import FolderColoring
+        return FolderColoring(self, ResourcePath("foldercoloring"))
+
     @property
     def group_site_manager(self):
         """Alias to GroupSiteManager"""
@@ -499,6 +554,11 @@ class ClientContext(ClientRuntimeContext):
         from office365.sharepoint.tenant.settings import TenantSettings
         return TenantSettings.current(self)
 
+    @property
+    def viva_site_manager(self):
+        from office365.sharepoint.viva.site_manager import VivaSiteManager
+        return VivaSiteManager(self)
+
     @property
     def workflow_services_manager(self):
         """Alias to WorkflowServicesManager"""
@@ -507,6 +567,7 @@ class ClientContext(ClientRuntimeContext):
 
     @property
     def work_items(self):
+        """"""
         from office365.sharepoint.contentcenter.machinelearning.workitems.collection import \
             SPMachineLearningWorkItemCollection
         return SPMachineLearningWorkItemCollection(self, ResourcePath("workitems"))

office365/sharepoint/clientsidecomponent/component_context_info.py

@@ -4,6 +4,13 @@ from office365.sharepoint.base_entity import BaseEntity
 class ComponentContextInfo(BaseEntity):
     """This class functions as a wrapper of the ContextInfo object. Reserved for internal use only."""
 
+    @property
+    def serialized_data(self):
+        """
+        :rtype: str
+        """
+        return self.properties.get("SerializedData", None)
+
     @property
     def entity_type_name(self):
         return "Microsoft.SharePoint.Internal.ClientSideComponent.ComponentContextInfo"

office365/sharepoint/clientsidecomponent/identifier.py

@@ -8,6 +8,9 @@ class SPClientSideComponentIdentifier(ClientValue):
         self.id = _id
         self.version = version
 
+    def __repr__(self):
+        return self.id
+
     @property
     def entity_type_name(self):
         return "Microsoft.SharePoint.ClientSideComponent.SPClientSideComponentIdentifier"

office365/sharepoint/compliance/tag_info.py

@@ -3,6 +3,23 @@ from office365.runtime.client_value import ClientValue
 
 class ComplianceTagInfo(ClientValue):
 
+    def __init__(self, is_record=None, is_regulatory=None, should_keep=None, tag_name=None, unified_rule_id=None,
+                 unified_tag_id=None):
+        """
+        :param bool is_record:
+        :param bool is_regulatory:
+        :param bool should_keep:
+        :param str tag_name:
+        :param str unified_rule_id:
+        :param str unified_tag_id:
+        """
+        self.IsRecord = is_record
+        self.IsRegulatory = is_regulatory
+        self.ShouldKeep = should_keep
+        self.TagName = tag_name
+        self.UnifiedRuleId = unified_rule_id
+        self.UnifiedTagId = unified_tag_id
+
     @property
     def entity_type_name(self):
         return "SP.ComplianceFoundation.Models.ComplianceTagInfo"

office365/sharepoint/contenttypes/collection.py

@@ -19,7 +19,7 @@ class ContentTypeCollection(BaseEntityCollection):
         :param str name: Content type name
         :rtype: ContentType
         """
-        return self.filter("Name eq '{0}'".format(name)).single()
+        return self.single("Name eq '{0}'".format(name))
 
     def get_by_id(self, content_type_id):
         """
@@ -57,24 +57,23 @@ class ContentTypeCollection(BaseEntityCollection):
         :param str group: Specifies the group of the content type
         :param str or ContentType parent_content_type: Specifies the parent content type (string identifier or object)
         """
-        def _create_query(parent_content_type_id):
+        def _create_and_add_query(parent_content_type_id):
             """
             :type parent_content_type_id: str
             """
             parameters = ContentTypeEntityData(name, description, group, parent_content_type_id)
             payload = {"parameters": parameters}
-            return ServiceOperationQuery(self, "Create", None, payload, None, return_type)
+            qry = ServiceOperationQuery(self, "Create", None, payload, None, return_type)
+            self.context.add_query(qry)
 
         return_type = ContentType(self.context)
         self.add_child(return_type)
         if isinstance(parent_content_type, ContentType):
             def _ct_loaded():
-                next_qry = _create_query(parent_content_type.string_id)
-                self.context.add_query(next_qry)
+                _create_and_add_query(parent_content_type.string_id)
             parent_content_type.ensure_property("StringId", _ct_loaded)
         else:
-            qry = _create_query(parent_content_type)
-            self.context.add_query(qry)
+            _create_and_add_query(parent_content_type)
         return return_type
 
     def add_available_content_type(self, content_type_id):

office365/sharepoint/contenttypes/content_type.py

@@ -9,7 +9,13 @@ from office365.sharepoint.translation.user_resource import UserResource
 
 
 class ContentType(BaseEntity):
-    """Specifies a content type."""
+    """
+    Specifies a content type.
+
+    A named and uniquely identifiable collection of settings and fields that store metadata for individual items
+    in a SharePoint list. One or more content types can be associated with a list, which restricts the contents
+    to items of those types
+    """
 
     def reorder_fields(self, field_names):
         """
@@ -39,6 +45,30 @@ class ContentType(BaseEntity):
             self.context.add_query(qry)
         return self
 
+    @property
+    def client_form_custom_formatter(self):
+        """
+        :rtype: str
+        """
+        return self.properties.get("ClientFormCustomFormatter", None)
+
+    @property
+    def display_form_client_side_component_id(self):
+        """
+        The component ID of an SPFx Form Customizer to connect to this content type for usage with display forms.
+        :rtype: str
+        """
+        return self.properties.get("DisplayFormClientSideComponentId", None)
+
+    @property
+    def display_form_client_side_component_properties(self):
+        """
+        The component properties of an SPFx Form Customizer to connect to this content type for usage with display forms
+        :rtype: str
+        """
+        return self.properties.get("DisplayFormClientSideComponentProperties", None)
+
+
     @property
     def display_form_template_name(self):
         """
@@ -54,6 +84,23 @@ class ContentType(BaseEntity):
         """
         return self.properties.get("DisplayFormUrl", None)
 
+    @property
+    def edit_form_client_side_component_id(self):
+        """
+        The component properties of an SPFx Form Customizer to connect to this content type for usage with edit item
+            forms
+        :rtype: str
+        """
+        return self.properties.get("EditFormClientSideComponentId", None)
+
+    @property
+    def edit_form_client_side_component_properties(self):
+        """
+        The component ID of an SPFx Form Customizer to connect to this content type for usage with edit item forms
+        :rtype: str
+        """
+        return self.properties.get("EditFormClientSideComponentProperties", None)
+
     @property
     def id(self):
         """Specifies an identifier for the content type as specified in [MS-WSSTS] section 2.1.2.8.1.
@@ -85,6 +132,7 @@ class ContentType(BaseEntity):
     @property
     def new_form_client_side_component_properties(self):
         """
+        The component properties of an SPFx Form Customizer to connect to this content type for usage with new item forms
         :rtype: str or None
         """
         return self.properties.get("NewFormClientSideComponentProperties", None)

office365/sharepoint/contenttypes/fieldlinks/collection.py

@@ -20,23 +20,22 @@ class FieldLinkCollection(BaseEntityCollection):
 
         :param str or office365.sharepoint.fields.field.Field field: Specifies the internal name of the field or type
         """
-        def _create_query(field_internal_name):
+        def _create_and_add_query(field_internal_name):
             """
             :type field_internal_name: str
             """
             return_type.set_property("FieldInternalName", field_internal_name)
-            return CreateEntityQuery(self, return_type, return_type)
+            qry = CreateEntityQuery(self, return_type, return_type)
+            self.context.add_query(qry)
 
         return_type = FieldLink(self.context)
         self.add_child(return_type)
         if isinstance(field, Field):
             def _field_loaded():
-                next_qry = _create_query(field.internal_name)
-                self.context.add_query(next_qry)
+                _create_and_add_query(field.internal_name)
             field.ensure_property("InternalName", _field_loaded)
         else:
-            qry = _create_query(field)
-            self.context.add_query(qry)
+            _create_and_add_query(field)
         return return_type
 
     def get_by_id(self, _id):

office365/sharepoint/features/known_list.py

@@ -5,3 +5,5 @@ class KnownFeaturesList:
     ContentTypeHub = "9a447926-5937-44cb-857a-d3829301c73b"
 
     DocId = "b50e3104-6812-424f-a011-cc90e6327318"
+
+    MetadataNavigationAndFiltering = "7201d6a4-a5d3-49a1-8c19-19c4bac6e668"