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

Author: [email protected]

generator/metadata/SharePoint.xml

@@ -1,4 +1,3 @@
-from functools import partial
 from office365.graph.directory.permission_collection import PermissionCollection
 from office365.graph.onedrive.folder import Folder
 from office365.graph.onedrive.conflictBehavior import ConflictBehavior
@@ -13,10 +12,6 @@
 from office365.runtime.queries.serviceOperationQuery import ServiceOperationQuery
 
 
-def _content_downloaded(file_object, result):
-    file_object.write(result.value)
-
-
 class DriveItem(BaseItem):
     """The driveItem resource represents a file, folder, or other item stored in a drive. All file system objects in
     OneDrive and SharePoint are returned as driveItem resources """
@@ -61,8 +56,11 @@ def get_content(self):
         return qry.return_type
 
     def download(self, file_object):
+        def _content_downloaded(result):
+            file_object.write(result.value)
+
         self.get_content()
-        self.context.afterExecuteOnce += partial(_content_downloaded, file_object)
+        self.context.after_query_executed(_content_downloaded)
 
     def create_folder(self, name):
         """Create a new folder or DriveItem in a Drive with a specified parent item or path.
@@ -151,20 +149,15 @@ def invite(self, recipients, message, require_sign_in=True, send_invitation=True
         """Sends a sharing invitation for a driveItem. A sharing invitation provides permissions to the recipients
         and optionally sends them an email with a sharing link.
 
-        :param recipients: A collection of recipients who will receive access and the sharing invitation.
-        :type recipients: list[DriveRecipient]
-
-        :param message: A plain text formatted message that is included in the sharing invitation. Maximum length 2000 characters.
-        :type message: str
-
-        :param require_sign_in: Specifies whether the recipient of the invitation is required to sign-in to view the shared item.
-        :type require_sign_in: bool
-
-        :param send_invitation: If true, a sharing link is sent to the recipient. Otherwise, a permission is granted directly without sending a notification.
-        :type send_invitation: bool
-
-        :param roles: Specify the roles that are to be granted to the recipients of the sharing invitation.
-        :type roles: list[str]
+        :param list[DriveRecipient] recipients: A collection of recipients who will receive access and the sharing
+        invitation.
+        :param str message: A plain text formatted message that is included in the sharing invitation.
+        Maximum length 2000 characters.
+        :param bool require_sign_in: Specifies whether the recipient of the invitation is required to sign-in to view
+        the shared item.
+        :param bool send_invitation: If true, a sharing link is sent to the recipient. Otherwise, a permission is
+        granted directly without sending a notification.
+        :param list[str] roles: Specify the roles that are to be granted to the recipients of the sharing invitation.
         """
         if roles is None:
             roles = ["read"]

office365/graph/onedrive/driveItem.py

@@ -79,7 +79,7 @@ def ensure_property(self, name_or_names, action):
         """
         Ensures if property is loaded or list of properties are loaded
 
-        :type action: any
+        :type action: (any) -> None
         :type name_or_names: str or list[str]
         """
         names_to_include = []
@@ -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.afterExecuteOnce += action
+            self.context.after_query_executed(action)
         else:
             action(self)
 

office365/runtime/client_object.py

@@ -103,12 +103,12 @@ def get_items_count(self):
         :return: ClientResult
         """
         result = ClientResult(None)
-        self.context.load(self)
 
         def _calc_items_count(target_collection):
             list(iter(target_collection))
             result.value = len(target_collection)
-        self.context.afterExecuteOnce += _calc_items_count
+        self.context.load(self)
+        self.context.after_query_executed(_calc_items_count)
         return result
 
     def _load_paged_items(self):

office365/runtime/client_object_collection.py

@@ -4,6 +4,8 @@
 from office365.runtime.client_request_exception import ClientRequestException
 from office365.runtime.http.http_method import HttpMethod
 from office365.runtime.types.EventHandler import EventHandler
+from office365.runtime.client_query import ClientQuery
+from office365.runtime.http.request_options import RequestOptions
 
 
 class ClientRequest(object):
@@ -16,13 +18,42 @@ def __init__(self, context):
         """
         self.context = context
         self._queries = []
+        self._current_query = None
         self.beforeExecute = EventHandler()
         self.afterExecute = EventHandler()
 
     @property
     def queries(self):
+        """
+        :rtype: list[ClientQuery]
+        """
         return self._queries
 
+    @property
+    def current_query(self):
+        """
+        :rtype: ClientQuery or None
+        """
+        if self._current_query is None and len(self._queries) > 0:
+            self.next_query()
+        return self._current_query
+
+    @property
+    def last_query(self):
+        """
+        :rtype: ClientQuery or None
+        """
+        return self._queries and self._queries[-1]
+
+    def next_query(self):
+        self._current_query = self._queries and self._queries.pop(0)
+
+    def add_query(self, query):
+        """
+        :type query: ClientQuery
+        """
+        self._queries.append(query)
+
     @abstractmethod
     def build_request(self):
         pass
@@ -87,10 +118,3 @@ def execute_request_direct(self, request_options):
                                   stream=request_options.stream,
                                   proxies=request_options.proxies)
         return result
-
-    def add_query(self, query):
-        """
-        :type query: ClientQuery
-
-        """
-        self._queries.append(query)

office365/runtime/client_request.py

@@ -1,7 +1,6 @@
 import abc
-
+from functools import partial
 from office365.runtime.client_query import ReadEntityQuery
-from office365.runtime.types.EventHandler import EventHandler
 
 
 class ClientRuntimeContext(object):
@@ -15,12 +14,11 @@ def __init__(self, service_root_url, auth_context=None):
         """
         self._service_root_url = service_root_url
         self._auth_context = auth_context
-        self.afterExecuteOnce = EventHandler(True)
 
     @abc.abstractmethod
     def get_pending_request(self):
         """
-        :rtype: ClientRequest
+        :rtype: office365.runtime.client_request.ClientRequest
         """
         pass
 
@@ -40,18 +38,27 @@ def load(self, client_object, properties_to_retrieve=None):
         qry = ReadEntityQuery(client_object, properties_to_retrieve)
         self.get_pending_request().add_query(qry)
 
-    def execute_request_direct(self, request):
+    def after_query_executed(self, action):
         """
+        :param (office365.runtime.client_object.ClientObject or office365.runtime.client_result.ClientResult) -> None action:
+        """
+
+        def _process_response(qry, 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)
 
+    def execute_request_direct(self, request):
+        """
         :type request: RequestOptions
         """
         return self.get_pending_request().execute_request_direct(request)
 
     def execute_query(self):
         while self.has_pending_request:
+            self.get_pending_request().next_query()
             self.get_pending_request().execute_query()
-            query = self.get_pending_request().current_query
-            self.afterExecuteOnce.notify(query.return_type)
 
     def add_query(self, query):
         """
@@ -60,9 +67,6 @@ def add_query(self, query):
         """
         self.get_pending_request().add_query(query)
 
-    def add_query_first(self, query):
-        self.get_pending_request().queries.insert(0, query)
-
     def clear_queries(self):
         self.get_pending_request().queries.clear()
 

office365/runtime/client_runtime_context.py

@@ -22,7 +22,10 @@ def __init__(self, context, json_format):
         """
         super(ODataRequest, self).__init__(context)
         self._json_format = json_format
-        self._current_query = None
+
+    @property
+    def json_format(self):
+        return self._json_format
 
     def execute_request_direct(self, request):
         """
@@ -36,20 +39,8 @@ def execute_request_direct(self, request):
         request.ensure_header('Accept', media_type)
         return super(ODataRequest, self).execute_request_direct(request)
 
-    @property
-    def current_query(self):
-        return self._current_query
-
-    @property
-    def json_format(self):
-        return self._json_format
-
-    def _get_next_query(self):
-        self._current_query = self._queries.pop(0)
-        return self._current_query
-
     def build_request(self):
-        qry = self._get_next_query()
+        qry = self.current_query
         self.json_format.function_tag_name = None
 
         if isinstance(qry, ServiceOperationQuery):

office365/runtime/odata/odata_request.py

@@ -4,15 +4,15 @@
 
 class CreateFileQuery(ServiceOperationQuery):
 
-    def __init__(self, container, file_creation_information):
+    def __init__(self, files, file_creation_information):
         """
 
         :type file_creation_information: office365.sharepoint.file_creation_information.FileCreationInformation
-        :type container: FileCollection
+        :type files: FileCollection
         """
-        self._return_type = File(container.context)
-        super().__init__(container, "add", {
+        self._return_type = File(files.context)
+        super().__init__(files, "add", {
             "overwrite": file_creation_information.overwrite,
             "url": file_creation_information.url
         }, file_creation_information.content, None, self._return_type)
-        container.add_child(self._return_type)
+        files.add_child(self._return_type)

office365/sharepoint/actions/create_file.py

@@ -1,10 +1,9 @@
 import os
 import uuid
-
 from office365.runtime.client_result import ClientResult
+from office365.sharepoint.actions.create_file import CreateFileQuery
 from office365.sharepoint.files.file import File
 from office365.sharepoint.files.file_creation_information import FileCreationInformation
-from office365.sharepoint.actions.create_file import CreateFileQuery
 
 
 def read_in_chunks(file_object, size=1024):
@@ -25,56 +24,54 @@ def _create_empty_file(path):
 
 
 class UploadSessionQuery(CreateFileQuery):
-    def __init__(self, container, source_path, chunk_size, chunk_uploaded):
+    def __init__(self, files, source_path, chunk_size, chunk_uploaded):
         """
 
-        :type container: office365.sharepoint.file_collection.FileCollection
+        :type files: office365.sharepoint.files.file_collection.FileCollection
         :type source_path: str
         :type chunk_size: int
         :type chunk_uploaded: (int)->None
         """
 
-        super().__init__(container, _create_empty_file(source_path))
+        super().__init__(files, _create_empty_file(source_path))
         self._chunk_size = chunk_size
         self._upload_id = str(uuid.uuid4())
         self._source_path = source_path
         self._chunk_uploaded = chunk_uploaded
         self._uploaded_bytes = 0
         self._upload_results = []
-        container.context.afterExecuteOnce += self._build_upload_query
-
-    def _build_upload_query(self, target_file):
-        """
+        self._binding_type.context.get_pending_request().afterExecute += self._build_upload_session_query
 
-        :type target_file: File
-        """
+    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
         fh = open(self._source_path, 'rb')
         for piece in read_in_chunks(fh, size=self._chunk_size):
             if f_pos == 0:
-                upload_result = target_file.start_upload(self._upload_id, piece)
+                upload_result = self.file.start_upload(self._upload_id, piece)
                 self._upload_results.append(upload_result)
             elif f_pos + len(piece) < st.st_size:
-                upload_result = target_file.continue_upload(self._upload_id, f_pos, piece)
+                upload_result = self.file.continue_upload(self._upload_id, f_pos, piece)
                 self._upload_results.append(upload_result)
             else:
-                self._return_type = target_file.finish_upload(self._upload_id, f_pos, piece)
+                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)
         fh.close()
-        if self._chunk_uploaded is not None:
-            self._binding_type.context.afterExecuteOnce += self._process_chunk_upload
 
     def _process_chunk_upload(self, result_object):
-        self._binding_type.context.afterExecuteOnce += self._process_chunk_upload
         if isinstance(result_object, ClientResult):
             self._uploaded_bytes = int(result_object.value)
         elif isinstance(result_object, File):
-            self._uploaded_bytes = int(result_object.properties['Length'])
+            self._uploaded_bytes = result_object.length
         self._chunk_uploaded(self._uploaded_bytes)
 
     @property
     def file(self):
+        """
+        :rtype: File
+        """
         return self.return_type

office365/sharepoint/actions/upload_session.py

@@ -56,9 +56,11 @@ def from_url(abs_url):
         Web.get_web_url_from_page_url(ctx, abs_url)
 
         def _init_context_for_web(result):
+            """
+            :param office365.runtime.client_result.ClientResult result:
+            """
             ctx._base_url = result.value
-
-        ctx.afterExecuteOnce += _init_context_for_web
+        ctx.after_query_executed(_init_context_for_web)
         return ctx
 
     @staticmethod
@@ -103,7 +105,7 @@ def acquire_token():
 
     def with_credentials(self, credentials):
         """
-        Sets credentials
+        Assigns credentials
 
         :type credentials: UserCredential or ClientCredential
         """
@@ -117,6 +119,9 @@ def authenticate_request(self, request):
         super(ClientContext, self).authenticate_request(request)
 
     def get_pending_request(self):
+        """
+        :return: ODataRequest
+        """
         return self._pendingRequest
 
     def ensure_form_digest(self, request_options):