SharePoint API: sharing & permissions namespaces changes (RoleDefintion and RoleAssignment resources), examples refactorings

Author: [email protected]

README.md

@@ -1,6 +1,10 @@
 # About
 Office 365 & Microsoft Graph library for Python
 
+
+#### Sponsored by
+[![https://tracking.gitads.io/?repo=Office365-REST-Python-Client](https://images.gitads.io/Office365-REST-Python-Client)](https://tracking.gitads.io/?repo=Office365-REST-Python-Client)
+
 # Usage
 
 1.   [Installation](#Installation)

examples/sharepoint/audit/__init__.py

@@ -9,7 +9,7 @@
                                              UserCredential(settings['user_credentials']['username'],
                                                             settings['user_credentials']['password']))
 
-path = "../../tests/data/SharePoint User Guide.docx"
+path = "../../../tests/data/SharePoint User Guide.docx"
 with open(path, 'rb') as content_file:
     file_content = content_file.read()
 

examples/sharepoint/files/__init__.py

@@ -1,5 +1,4 @@
 from settings import settings
-
 from office365.runtime.auth.userCredential import UserCredential
 from office365.sharepoint.client_context import ClientContext
 
@@ -13,7 +12,7 @@ def print_upload_progress(offset):
                                                  UserCredential(settings['user_credentials']['username'],
                                                                 settings['user_credentials']['password']))
     size_1Mb = 1000000
-    local_path = "../../tests/data/big_buck_bunny.mp4"
+    local_path = "../../../tests/data/big_buck_bunny.mp4"
     target_url = "/Shared Documents"
     result_file = ctx.web.get_folder_by_server_relative_url(target_url) \
         .files.create_upload_session(local_path, size_1Mb, print_upload_progress)

examples/sharepoint/download_file.py renamed to examples/sharepoint/files/download_file.py

@@ -0,0 +1,19 @@
+from office365.runtime.auth.userCredential import UserCredential
+from office365.sharepoint.client_context import ClientContext
+from office365.sharepoint.search.searchRequest import SearchRequest
+from office365.sharepoint.search.searchService import SearchService
+from settings import settings
+
+
+ctx = ClientContext.connect_with_credentials(settings['url'],
+                                             UserCredential(settings['user_credentials']['username'],
+                                                            settings['user_credentials']['password']))
+
+search = SearchService(ctx)
+request = SearchRequest("IsDocument:1")
+result = search.post_query(request)
+ctx.execute_query()
+relevant_results = result.PrimaryQueryResult.RelevantResults
+for i in relevant_results['Table']['Rows']:
+    cells = relevant_results['Table']['Rows'][i]['Cells']
+    print(cells[6]['Value'])

examples/sharepoint/download_file_from_url.py renamed to examples/sharepoint/files/download_file_from_url.py

@@ -41,14 +41,14 @@ def add(self, user_id):
 
     def remove(self, user_id):
         """Remove a user from the group."""
+
         qry = ServiceOperationQuery(self, "{0}/$ref".format(user_id))
         self.context.add_query(qry)
-        self.context.get_pending_request().beforeExecute += self._construct_remove_user_request
 
-    def _construct_remove_user_request(self, request):
-        """
+        def _construct_remove_user_request(request):
+            """
+            :type request: RequestOptions
+            """
+            request.method = HttpMethod.Delete
 
-        :type request: RequestOptions
-        """
-        request.method = HttpMethod.Delete
-        self.context.get_pending_request().beforeExecute -= self._construct_remove_user_request
+        self.context.before_execute(_construct_remove_user_request)

examples/sharepoint/upload_file.py renamed to examples/sharepoint/files/upload_file.py

@@ -19,7 +19,13 @@ def add_team(self):
         team._parent_collection = self.parent_collection
         qry = ServiceOperationQuery(self, "team", None, team, None, team)
         self.context.add_query(qry)
-        self.context.get_pending_request().beforeExecute += self._construct_create_team_request
+
+        def _construct_create_team_request(request):
+            request.method = HttpMethod.Put
+            request.set_header('Content-Type', "application/json")
+            request.data = json.dumps(request.data)
+
+        self.context.before_execute(_construct_create_team_request)
         return team
 
     def delete_object(self, permanent_delete=False):
@@ -33,12 +39,6 @@ def delete_object(self, permanent_delete=False):
             deleted_item = self.context.directory.deletedGroups[self.id]
             deleted_item.delete_object()
 
-    def _construct_create_team_request(self, request):
-        request.method = HttpMethod.Put
-        request.set_header('Content-Type', "application/json")
-        request.data = json.dumps(request.data)
-        self.context.get_pending_request().beforeExecute -= self._construct_create_team_request
-
     @property
     def members(self):
         """Users and groups that are members of this group."""

examples/sharepoint/upload_large_file.py renamed to examples/sharepoint/files/upload_large_file.py

@@ -60,13 +60,12 @@ def _content_downloaded(result):
             file_object.write(result.value)
 
         self.get_content()
-        self.context.after_query_executed(_content_downloaded)
+        self.context.after_execute_query(_content_downloaded)
 
     def create_folder(self, name):
         """Create a new folder or DriveItem in a Drive with a specified parent item or path.
 
-        :param name: Folder name
-        :type name: str
+        :param str name: Folder name
         """
         drive_item = DriveItem(self.context, None)
         drive_item._parent_collection = self.children

examples/sharepoint/folders/__init__.py

@@ -91,7 +91,7 @@ def ensure_property(self, name_or_names, action):
 
         if len(names_to_include) > 0:
             self.context.load(self, names_to_include)
-            self.context.after_query_executed(action)
+            self.context.after_execute_query(action)
         else:
             action(self)
 

examples/sharepoint/download_folder.py renamed to examples/sharepoint/folders/download_folder.py

@@ -1,3 +1,4 @@
+from office365.runtime.resource_path import ResourcePath
 from office365.runtime.client_result import ClientResult
 from office365.runtime.client_object import ClientObject
 from office365.runtime.http.request_options import RequestOptions
@@ -9,7 +10,7 @@ class ClientObjectCollection(ClientObject):
     def __init__(self, context, item_type, resource_path=None):
         """Client object collection
 
-        :type context: ClientRuntimeContext
+        :type context: office365.runtime.client_runtime_context.ClientRuntimeContext
         :type item_type: type[ClientObject]
         :type resource_path: ResourcePath
         """
@@ -52,6 +53,9 @@ def remove_child(self, client_object):
         self._data.remove(client_object)
 
     def __iter__(self):
+        """
+        :rtype: collections.Iterable[ClientObject]
+        """
         for cur_item in self._data:
             yield cur_item
 
@@ -108,7 +112,7 @@ def _calc_items_count(target_collection):
             list(iter(target_collection))
             result.value = len(target_collection)
         self.context.load(self)
-        self.context.after_query_executed(_calc_items_count)
+        self.context.after_execute_query(_calc_items_count)
         return result
 
     def _load_paged_items(self):

examples/sharepoint/loadWebFluentAPI.py renamed to examples/sharepoint/load_web_fluent_api.py

@@ -1,8 +1,10 @@
 import abc
-from functools import partial
+from office365.runtime.http.request_options import RequestOptions
+from office365.runtime.client_query import ClientQuery
 from office365.runtime.client_query import ReadEntityQuery
 
 
+
 class ClientRuntimeContext(object):
 
     def __init__(self, service_root_url, auth_context=None):
@@ -38,16 +40,53 @@ def load(self, client_object, properties_to_retrieve=None):
         qry = ReadEntityQuery(client_object, properties_to_retrieve)
         self.get_pending_request().add_query(qry)
 
-    def after_query_executed(self, action):
+    def before_execute(self, action, once=True):
+        """
+        Attach an event handler which is triggered before request is submitted to server
+
+        :param (RequestOptions) -> None action:
+        :param bool once:
+        :return: None
         """
-        :param (office365.runtime.client_object.ClientObject or office365.runtime.client_result.ClientResult) -> None action:
+        def _process_request(request):
+            if once:
+                self.get_pending_request().beforeExecute -= _process_request
+            action(request)
+
+        self.get_pending_request().beforeExecute += _process_request
+
+    def after_execute(self, action, once=True):
+        """
+        Attach an event handler which is triggered after request is submitted to server
+
+        :param (RequestOptions) -> None action:
+        :param bool once:
+        :return: None
         """
 
-        def _process_response(qry, response):
+        def _process_response(response):
+            if once:
+                self.get_pending_request().afterExecute -= _process_response
+            action(response)
+        self.get_pending_request().afterExecute += _process_response
+
+    def after_execute_query(self, action, query=None):
+        """
+        Attach an event handler (for a query) which is triggered once the request is submitted to server
+
+        :type action: (office365.runtime.client_object.ClientObject or office365.runtime.client_result.ClientResult) -> None
+        :type query: ClientQuery or None
+        """
+        if query is None:
+            query = self.get_pending_request().last_query
+
+        def _process_response(response):
             current_qry = self.get_pending_request().current_query
-            if current_qry.id == qry.id:
-                action(qry.return_type)
-        self.get_pending_request().afterExecute += partial(_process_response, self.get_pending_request().last_query)
+            if current_qry.id == query.id:
+                self.get_pending_request().afterExecute -= _process_response
+                action(query.return_type)
+
+        self.get_pending_request().afterExecute += _process_response
 
     def execute_request_direct(self, request):
         """

examples/sharepoint/search/__init__.py

@@ -1,3 +1,4 @@
+import typing
 from office365.runtime.http.http_method import HttpMethod
 from office365.runtime.queries.serviceOperationQuery import ServiceOperationQuery
 
@@ -6,20 +7,20 @@ class DownloadFileQuery(ServiceOperationQuery):
 
     def __init__(self, web, file_url, file_object):
         """
+        A download file content query
 
         :type file_url: str
-        :type web: Web
-        :type file_object: any
+        :type web: office365.sharepoint.webs.web.Web
+        :type file_object: typing.IO
         """
-        self.file_object = file_object
-        web.context.get_pending_request().beforeExecute += self._construct_download_query
-        web.context.get_pending_request().afterExecute += self._process_response
-        super(DownloadFileQuery, self).__init__(web, r"getFileByServerRelativeUrl('{0}')/\$value".format(file_url))
 
-    def _construct_download_query(self, request):
-        self.binding_type.context.get_pending_request().beforeExecute -= self._construct_download_query
-        request.method = HttpMethod.Get
+        def _construct_download_query(request):
+            request.method = HttpMethod.Get
+
+        def _process_response(response):
+            file_object.write(response.content)
+
+        web.context.before_execute(_construct_download_query)
+        web.context.after_execute(_process_response)
+        super(DownloadFileQuery, self).__init__(web, r"getFileByServerRelativeUrl('{0}')/\$value".format(file_url))
 
-    def _process_response(self, response):
-        self.binding_type.context.get_pending_request().afterExecute -= self._process_response
-        self.file_object.write(response.content)

examples/sharepoint/search/search_documents.py

@@ -0,0 +1,33 @@
+import typing
+from office365.runtime.http.http_method import HttpMethod
+from office365.runtime.queries.serviceOperationQuery import ServiceOperationQuery
+
+
+class UploadFileQuery(ServiceOperationQuery):
+
+    def __init__(self, web, file_url, file_object):
+        """
+        A download file content query
+
+        :type file_url: str
+        :type web: office365.sharepoint.webs.web.Web
+        :type file_object: typing.IO
+        """
+        super().__init__(web)
+
+        def _process_response(response):
+            """
+            :type response: RequestOptions
+            """
+            file_object.write(response.content)
+
+        def _construct_upload_request(request):
+            request.data = file_object.read()
+            request.method = HttpMethod.Post
+            request.set_header('X-HTTP-Method', 'PUT')
+
+        web.context.before_execute(_construct_upload_request)
+        web.context.after_execute(_process_response)
+        super(UploadFileQuery, self).__init__(web, r"getFileByServerRelativeUrl('{0}')/\$value".format(file_url))
+
+

office365/graph/directory/directoryObjectCollection.py

@@ -40,10 +40,9 @@ def __init__(self, files, source_path, chunk_size, chunk_uploaded):
         self._chunk_uploaded = chunk_uploaded
         self._uploaded_bytes = 0
         self._upload_results = []
-        self._binding_type.context.get_pending_request().afterExecute += self._build_upload_session_query
+        self._binding_type.context.after_execute(self._build_upload_session_query)
 
     def _build_upload_session_query(self, response):
-        self._binding_type.context.get_pending_request().afterExecute -= self._build_upload_session_query
         st = os.stat(self._source_path)
         # upload a file in chunks
         f_pos = 0
@@ -59,7 +58,7 @@ def _build_upload_session_query(self, response):
                 self._return_type = self.file.finish_upload(self._upload_id, f_pos, piece)
             f_pos += len(piece)
             if self._chunk_uploaded is not None:
-                self._binding_type.context.after_query_executed(self._process_chunk_upload)
+                self._binding_type.context.after_execute_query(self._process_chunk_upload)
         fh.close()
 
     def _process_chunk_upload(self, result_object):

office365/graph/directory/group.py

@@ -1,11 +1,59 @@
+import typing
 from office365.runtime.resource_path import ResourcePath
 from office365.runtime.resource_path_service_operation import ResourcePathServiceOperation
+from office365.sharepoint.actions.download_file import DownloadFileQuery
+from office365.sharepoint.actions.upload_file import UploadFileQuery
 from office365.sharepoint.files.file import AbstractFile
 
 
 class AttachmentFile(AbstractFile):
     """Represents an attachment file in a SharePoint List Item."""
 
+    def download(self, file_object):
+        """Download attachment file content
+
+        :type file_object: typing.IO
+        """
+
+        def _download_inner(target_attachment_file):
+            url = self.server_relative_url
+            qry = DownloadFileQuery(self.context.web, url, file_object)
+            self.context.add_query(qry)
+
+        self.ensure_property("ServerRelativeUrl", _download_inner)
+
+    def upload(self, file_object):
+        """
+        :type file_object: typing.IO file_object
+        """
+
+        def _upload_inner(target_attachment_file):
+            qry = UploadFileQuery(self.context.web, self.server_relative_url, file_object)
+            self.context.add_query(qry)
+
+        self.ensure_property("ServerRelativeUrl", _upload_inner)
+
+    @property
+    def file_name(self):
+        """
+        :rtype: str or None
+        """
+        return self.properties.get("FileName", None)
+
+    @property
+    def server_relative_url(self):
+        """
+        :rtype: str or None
+        """
+        return self.properties.get("ServerRelativeUrl", None)
+
+    @property
+    def parent_collection(self):
+        """
+        :rtype: office365.sharepoint.attachments.attachmentfile_collection.AttachmentFileCollection
+        """
+        return self._parent_collection
+
     def set_property(self, name, value, persist_changes=True):
         super(AttachmentFile, self).set_property(name, value, persist_changes)
         # fallback: create a new resource path