SharePoint API: introduced SearchService API support, bug fixes (#210 and #213)

Author: vvgrem@gmail.com

.travis.yml

@@ -34,4 +34,3 @@ jobs:
           tags: true
           python: 3.6
           repo: "vgrem/Office365-REST-Python-Client"
-          twine_version: 3.1.1

examples/sharepoint/AppPermissionRequests.xml

@@ -1,3 +1,4 @@
 <AppPermissionRequests AllowAppOnlyPolicy="true">
-     <AppPermissionRequest Scope="http://sharepoint/content/sitecollection/web" Right="Read"/>
+     <AppPermissionRequest Scope="http://sharepoint/content/sitecollection" Right="FullControl" />
+     <AppPermissionRequest Scope="http://sharepoint/search" Right="QueryAsUserIgnoreAppPrincipal"/>
 </AppPermissionRequests>

examples/sharepoint/connect_with_app.py

@@ -2,12 +2,14 @@
 from office365.sharepoint.client_context import ClientContext
 from settings import settings
 
-ctx = ClientContext.connect_with_credentials(settings['url'],
-                                             ClientCredential(settings['client_credentials']['client_id'],
-                                                              settings['client_credentials']['client_secret']))
+credentials = ClientCredential(settings['client_credentials']['client_id'],
+                               settings['client_credentials']['client_secret'])
+ctx = ClientContext(settings['url']).with_credentials(credentials)
+if not ctx.authentication_context.acquire_token():
+    print("Acquire token failed")
+
 
 target_web = ctx.web
 ctx.load(target_web)
 ctx.execute_query()
-
-
+print(target_web.url)

examples/sharepoint/requirements.txt

@@ -1,5 +1,4 @@
-import ast
-
+from generator.typeBuilder import TypeBuilder
 from office365.runtime.odata.odata_v3_reader import ODataV3Reader
 from office365.runtime.odata.odata_v4_reader import ODataV4Reader
 
@@ -10,9 +9,9 @@ def generate_files(model):
 
 
 def generate_type_file(type_schema):
-    if type_schema['state'] == 'attached':
-        tree = ast.parse(open(type_schema['file']).read())
-        print(type_schema['file'])
+    builder = TypeBuilder(type_schema)
+    if builder.build():
+        builder.save()
 
 
 def generate_sharepoint_model():

generator/generate.py

@@ -0,0 +1,21 @@
+import ast
+import astunparse
+
+
+class TypeBuilder(object):
+
+    def __init__(self, schema):
+        self._schema = schema
+        self._node = None
+
+    def build(self):
+        if self._schema['state'] == 'attached':
+            with open(self._schema['file']) as f:
+                self._node = ast.parse(f.read())
+            return True
+        return False
+
+    def save(self):
+        code = astunparse.unparse(self._node)
+        with open(self._schema['file']) as f:
+            f.write(code)

generator/metadata/SharePoint.xml

@@ -10,17 +10,38 @@
 
 class OutlookClient(ClientRuntimeContext):
 
-    def __init__(self, ctx_auth):
+    def __init__(self, auth_context):
         """
         Office365 Outlook client context
         Status: deprecated, prefer GraphClient instead
 
-        :type ctx_auth: AuthenticationContext
+        :type auth_context: AuthenticationContext
         """
-        self.__service_root_url = "https://outlook.office365.com/api/v1.0/"
-        super(OutlookClient, self).__init__(self.__service_root_url, ctx_auth)
+        self._resource = "https://outlook.office365.com"
+        self.__service_root_url = "{resource}/api/v1.0/".format(resource=self._resource)
+        super(OutlookClient, self).__init__(self.__service_root_url, auth_context)
         self._pendingRequest = ODataRequest(self, V4JsonFormat("minimal"))
         self._pendingRequest.beforeExecute += self._build_specific_query
+        self._token_parameters = None
+
+    @classmethod
+    def from_tenant(cls, tenant):
+        return OutlookClient(AuthenticationContext(tenant))
+
+    def with_user_credentials(self, client_id, user_name, password):
+        self._token_parameters = {
+            "client_id": client_id,
+            "username": user_name,
+            "password": password,
+            "resource": self._resource,
+            "scope": ("openid", "profile", "offline_access")
+        }
+        return self
+
+    def authenticate_request(self, request):
+        if not self._auth_context.is_authenticated:
+            self._auth_context.acquire_token_password_grant(**self._token_parameters)
+        super(OutlookClient, self).authenticate_request(request)
 
     def get_pending_request(self):
         return self._pendingRequest

generator/templates/__init__.py

@@ -12,7 +12,7 @@ class AuthenticationContext(BaseAuthenticationContext):
 
     def __init__(self, url, credentials=None):
         """
-        Authentication context for SharePoint Online/One Drive
+        Authentication context for SharePoint Online/OneDrive
 
         :param str url:  authority url
         :param ClientCredential or UserCredential credentials: credentials
@@ -33,9 +33,9 @@ def set_token(self, token):
 
     def acquire_token(self):
         if isinstance(self.credentials, ClientCredential):
-            self.acquire_token_for_app(self.credentials.clientId, self.credentials.clientSecret)
+            return self.acquire_token_for_app(self.credentials.clientId, self.credentials.clientSecret)
         elif isinstance(self.credentials, UserCredential):
-            self.acquire_token_for_user(self.credentials.userName, self.credentials.password)
+            return self.acquire_token_for_user(self.credentials.userName, self.credentials.password)
         else:
             raise ValueError("Unknown credential type")
 
@@ -48,19 +48,30 @@ def acquire_token_for_user(self, username, password):
         self.provider = SamlTokenProvider(self.url, username, password)
         if not self.provider.acquire_token():
             raise ValueError('Acquire token failed: {0}'.format(self.provider.error))
+        return True
 
     def acquire_token_for_app(self, client_id, client_secret):
         """Acquire token via client credentials (SharePoint App Principal)"""
         self.provider = ACSTokenProvider(self.url, client_id, client_secret)
         if not self.provider.acquire_token():
             raise ValueError('Acquire token failed: {0}'.format(self.provider.error))
+        return True
 
-    def acquire_token_password_grant(self, client_credentials, user_credentials):
-        """Acquire token via resource owner password credential (ROPC) grant"""
+    def acquire_token_password_grant(self, client_id, username, password, resource, scope):
+        """
+        Acquire token via resource owner password credential (ROPC) grant
+
+        :param str resource: A URI that identifies the resource for which the token is valid.
+        :param str username: : The username of the user on behalf this application is authenticating.
+        :param str password: The password of the user named in the username parameter.
+        :param str client_id: str The OAuth client id of the calling application.
+        :param list[str] scope:
+        """
         self.provider = OAuthTokenProvider(self.url)
-        return self.provider.acquire_token_password_type("https://outlook.office365.com",
-                                                         client_credentials,
-                                                         user_credentials)
+        return self.provider.acquire_token_password_type(resource=resource,
+                                                         client_id=client_id,
+                                                         user_credentials=UserCredential(username, password),
+                                                         scope=scope)
 
     def authenticate_request(self, request_options):
         """Authenticate request

generator/typeBuilder.py

@@ -1,28 +1,28 @@
 import requests
 from office365.runtime.auth.base_token_provider import BaseTokenProvider
 from office365.runtime.auth.tokenResponse import TokenResponse
+from office365.runtime.auth.userCredential import UserCredential
 
 
 class OAuthTokenProvider(BaseTokenProvider):
     """ OAuth token provider for AAD"""
 
     def __init__(self, tenant):
-        self.tenant = tenant
-        self.authority_url = "https://login.microsoftonline.com/"
+        self.authority_url = "https://login.microsoftonline.com/{tenant}".format(tenant=tenant)
         self.version = "v1.0"
         self.error = None
-        self.token = None  # type: TokenResponse
+        self.token = TokenResponse()
 
     def acquire_token(self, parameters):
         try:
-            url = "https://login.microsoftonline.com/{0}/oauth2/token".format(self.tenant)
-            response = requests.post(url=url,
+            token_url = "{authority}/oauth2/token".format(authority=self.authority_url)
+            response = requests.post(url=token_url,
                                      headers={'Content-Type': 'application/x-www-form-urlencoded'},
                                      data=parameters)
             self.token = TokenResponse.from_json(response.content)
             return self.token.is_valid
         except requests.exceptions.RequestException as e:
-            self.error = "Error: {}".format(e)
+            self.error = "Error: {0}".format(e)
             return False
 
     def is_authenticated(self):
@@ -31,17 +31,25 @@ def is_authenticated(self):
     def get_authorization_header(self):
         return '{token_type} {access_token}'.format(token_type=self.token.tokenType, access_token=self.token.accessToken)
 
-    def acquire_token_password_type(self, resource, client_credentials, user_credentials):
+    def acquire_token_password_type(self, resource, client_id, user_credentials, scope):
+        """
+        Gets a token for a given resource via user credentials
+
+        :param list[str] scope:
+        :param str resource:
+        :param str client_id:
+        :param UserCredential user_credentials:
+        :return: bool
+        """
         token_parameters = {
             'grant_type': 'password',
-            'client_id': client_credentials['client_id'],
-            'client_secret': client_credentials['client_secret'],
-            'username': user_credentials['username'],
-            'password': user_credentials['password'],
-            'scope': 'user.read openid profile offline_access',
+            'client_id': client_id,
+            'username': user_credentials.userName,
+            'password': user_credentials.password,
+            'scope': " ".join(scope),
             'resource': resource
         }
-        self.acquire_token(token_parameters)
+        return self.acquire_token(token_parameters)
 
     def get_last_error(self):
         return self.error

office365/outlookservices/outlook_client.py

@@ -120,7 +120,7 @@ def acquire_service_token_from_adfs(self, adfs_url, username, password):
                 logger.error(self.error)
                 return None
             # 2. prepare & submit token request
-            self.__sts_profile.signInPage = '_vti_bin/idcrl.svc'
+            self.__sts_profile.signInPage = '_vti_bin/idcrl.svc/'
             self.__sts_profile.securityTokenServicePath = 'rst2.srf'
             template = self._prepare_request_from_template('RST2.xml', {
                 'auth_url': self.__sts_profile.authorityUrl,
@@ -198,7 +198,11 @@ def _process_service_token_response(self, response):
         return token.text
 
     def _acquire_authentication_cookie(self, security_token, federated=False):
-        """Retrieve auth cookie from STS"""
+        """Retrieve auth cookie from STS
+
+        :type federated: bool
+        :type security_token: str
+        """
         logger = self.logger(self._acquire_authentication_cookie.__name__)
         session = requests.session()
         logger.debug_secrets("session: %s\nsession.post(%s, data=%s)", session, self.__sts_profile.signin_page_url,
@@ -210,13 +214,12 @@ def _acquire_authentication_cookie(self, security_token, federated=False):
                          headers={'Content-Type': 'application/x-www-form-urlencoded'})
         else:
             self._auth_cookies['SPOIDCRL'] = None
-            session.head(self.__sts_profile.signin_page_url,
-                         headers={
-                             'User-Agent': 'Office365 Python Client',
-                             'X-IDCRL_ACCEPTED': 't',
-                             'Authorization': 'BPOSIDCRL {0}'.format(security_token),
-                             'Content-Type': 'application/x-www-form-urlencoded'
-                         })
+            session.get(self.__sts_profile.signin_page_url,
+                        headers={
+                            'User-Agent': 'Office365 Python Client',
+                            'X-IDCRL_ACCEPTED': 't',
+                            'Authorization': 'BPOSIDCRL {0}'.format(security_token)
+                        })
         logger.debug_secrets("session.cookies: %s", session.cookies)
         cookies = requests.utils.dict_from_cookiejar(session.cookies)
         logger.debug_secrets("cookies: %s", cookies)

office365/runtime/auth/authentication_context.py

@@ -5,10 +5,18 @@ def __init__(self):
         super(ClientValueObject, self).__init__()
 
     def set_property(self, k, v, persist_changes=True):
-        self.__dict__[k] = v
+        if hasattr(self, k):
+            prop_type = getattr(self, k)
+            if isinstance(prop_type, ClientValueObject):
+                [prop_type.set_property(k, v, persist_changes) for k, v in v.items()]
+                setattr(self, k, prop_type)
+            else:
+                setattr(self, k, v)
+        else:
+            setattr(self, k, v)
 
     def get_property(self, k):
-        return self.__dict__[k]
+        return getattr(self, k)
 
     def to_json(self):
         return dict((k, v) for k, v in vars(self).items() if v is not None)

office365/runtime/auth/providers/oauth_token_provider.py

@@ -1,11 +1,27 @@
 from office365.runtime.client_query import DeleteEntityQuery
 from office365.runtime.resource_path_service_operation import ResourcePathServiceOperation
+from office365.runtime.serviceOperationQuery import ServiceOperationQuery
 from office365.sharepoint.base_entity import BaseEntity
 
 
 class Field(BaseEntity):
     """Represents a field in a SharePoint Web site"""
 
+    def set_show_in_display_form(self, flag):
+        """Sets the value of the ShowInDisplayForm property for this field."""
+        qry = ServiceOperationQuery(self, "setShowInDisplayForm", [flag])
+        self.context.add_query(qry)
+
+    def set_show_in_edit_form(self, flag):
+        """Sets the value of the ShowInEditForm property for this field."""
+        qry = ServiceOperationQuery(self, "setShowInEditForm", [flag])
+        self.context.add_query(qry)
+
+    def set_show_in_new_form(self, flag):
+        """Sets the value of the ShowInNewForm property for this field."""
+        qry = ServiceOperationQuery(self, "setShowInNewForm", [flag])
+        self.context.add_query(qry)
+
     def delete_object(self):
         """Deletes the field."""
         qry = DeleteEntityQuery(self)

office365/runtime/auth/providers/saml_token_provider.py

@@ -0,0 +1,17 @@
+from office365.runtime.client_value_object import ClientValueObject
+
+
+class FieldLookupValue(ClientValueObject):
+
+    def __init__(self, lookup_id=None, lookup_value=None):
+        """Specifies the value of a lookup for a field within a list item.
+
+        :param int or None lookup_id: Gets or sets the identifier (ID) of the list item that this instance of the lookup
+        field is referring to.
+        :param str or None lookup_value: Gets a summary of the list item that this instance
+        of the lookup field is referring to.
+
+        """
+        super().__init__()
+        self.LookupId = lookup_id
+        self.LookupValue = lookup_value

office365/runtime/client_value_object.py

@@ -0,0 +1,6 @@
+from office365.sharepoint.field import Field
+
+
+class FieldUrl(Field):
+    """Specifies a field that contains a URL."""
+    pass

office365/sharepoint/field.py

@@ -0,0 +1,12 @@
+from office365.sharepoint.fieldLookupValue import FieldLookupValue
+
+
+class FieldUserValue(FieldLookupValue):
+
+    def __init__(self, user_id):
+        """Represents the value of a user field for a list item."""
+        super().__init__(user_id)
+
+    @staticmethod
+    def from_user(user):
+        pass

office365/sharepoint/fieldLookupValue.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value_object import ClientValueObject
+
+
+class CustomResult(ClientValueObject):
+    pass

office365/sharepoint/fieldUrl.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value_object import ClientValueObject
+
+
+class QuerySuggestionResults(ClientValueObject):
+    pass

office365/sharepoint/fieldUserValue.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value_object import ClientValueObject
+
+
+class QueryResult(ClientValueObject):
+    pass