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

office365/sharepoint/fields/collection.py

@@ -38,35 +38,53 @@ class FieldCollection(BaseEntityCollection):
                                                  description=description,
                                                  field_type_kind=FieldType.URL))
 
-    def add_lookup_field(self, title, lookup_list_id, lookup_field_name, allow_multiple_values=False):
+    def add_lookup_field(self, title, lookup_list, lookup_field_name, allow_multiple_values=False):
         """
         Creates a Lookup field
 
-        :param bool allow_multiple_values:
-        :param str lookup_field_name:
-        :param str lookup_list_id:
-        :param str title:
+        :param bool allow_multiple_values: Flag determines whether to create multi lookup field or not
+        :param str lookup_field_name: Specifies the name of the field in the other data source when creating
+            a lookup field
+        :param str or office365.sharepoint.lists.list.List lookup_list: Lookup List object or identifier
+        :param str title: Specifies the display name of the field.
         """
-        if allow_multiple_values:
-            field_schema = '''
-                        <Field Type="LookupMulti" Mult="TRUE" DisplayName="{title}" Required="FALSE" Hidden="TRUE" \
-                        ShowField="{lookup_field_name}" List="{{{lookup_list_id}}}" StaticName="{title}" Name="{title}">
-                        </Field>
-                        '''.format(title=title, lookup_field_name=lookup_field_name, lookup_list_id=lookup_list_id)
-            return self.create_field_as_xml(field_schema)
+        return_type = Field(self.context)
+
+        def _add_lookup_field(lookup_list_id):
+            """
+            :type lookup_list_id: str
+            """
+            if allow_multiple_values:
+                field_schema = '''
+                            <Field Type="LookupMulti" Mult="TRUE" DisplayName="{title}" Required="FALSE" Hidden="TRUE" \
+                            ShowField="{lookup_field_name}" List="{{{lookup_list_id}}}" StaticName="{title}" Name="{title}">
+                            </Field>
+                            '''.format(title=title, lookup_field_name=lookup_field_name, lookup_list_id=lookup_list_id)
+                self.create_field_as_xml(field_schema, return_type=return_type)
+            else:
+                self.add_field(FieldCreationInformation(title=title,
+                                                        lookup_list_id=lookup_list_id,
+                                                        lookup_field_name=lookup_field_name,
+                                                        field_type_kind=FieldType.Lookup),
+                               return_type=return_type)
+
+        from office365.sharepoint.lists.list import List
+        if isinstance(lookup_list, List):
+
+            def _lookup_list_loaded():
+                _add_lookup_field(lookup_list.id)
+            lookup_list.ensure_property("Id", _lookup_list_loaded)
         else:
-            return self.add_field(FieldCreationInformation(title=title,
-                                                           lookup_list_id=lookup_list_id,
-                                                           lookup_field_name=lookup_field_name,
-                                                           field_type_kind=FieldType.Lookup))
+            _add_lookup_field(lookup_list)
+        return return_type
 
     def add_choice_field(self, title, values, multiple_values=False):
         """
-        Created Choice field
+        Creates a Choice field
 
         :param bool multiple_values:
         :param list[str] values:
-        :param str title:
+        :param str title: Specifies the display name of the field.
         """
         fld_type = FieldType.MultiChoice if multiple_values else FieldType.Choice
         create_field_info = FieldCreationInformation(title, fld_type)
@@ -77,7 +95,7 @@ class FieldCollection(BaseEntityCollection):
         """
         Creates a User field
 
-        :param str title: specifies the display name of the field
+        :param str title: Specifies the display name of the field
         """
         return self.add_field(FieldCreationInformation(title, FieldType.User))
 
@@ -90,23 +108,24 @@ class FieldCollection(BaseEntityCollection):
         """
         return self.add_field(FieldCreationInformation(title, FieldType.Text))
 
-    def add_dependent_lookup_field(self, display_name, primary_lookup_field, lookup_field):
-        """Adds a secondary lookup field to a field (2) collection.
-        A reference (3) to the SP.Field that was added is returned.
-        :param str lookup_field: Name of the field (2) from the target list (1) to include data from.
-        :param Field primary_lookup_field: Main lookup field to associate the dependent lookup field with.
-            A dependent lookup field will include data from the list item referred to from the instance of the main
-            lookup field.
-        :param str display_name: Title of the added field
+    def add_dependent_lookup_field(self, display_name, primary_lookup_field_id, show_field):
+        """Adds a secondary lookup field to a field collection (target). 
+        Args:
+            display_name (str): title of the added field in the target FieldCollection.
+            primary_lookup_field_id (str): ID of the main lookup-field in the target to associate the dependent lookup field with.
+            show_field (str): name of the field from the source list to include data from.
+        Returns:
+            Field: reference to the SP.Field that was added.
         """
         return_type = Field(self.context)
         self.add_child(return_type)
         parameters = {
             "displayName": display_name,
-            "primaryLookupField": primary_lookup_field,
-            "lookupField": lookup_field
+            "primaryLookupFieldId": primary_lookup_field_id,
+            "showField": show_field
         }
-        qry = ServiceOperationQuery(self, "AddDependentLookupField", None, parameters, None, return_type)
+        qry = ServiceOperationQuery(self, "AddDependentLookupField", None, parameters,
+                                    None, return_type)
         self.context.add_query(qry)
         return return_type
 
@@ -121,41 +140,53 @@ class FieldCollection(BaseEntityCollection):
         self.context.add_query(qry)
         return return_type
 
-    def add_field(self, parameters):
+    def add_field(self, parameters, return_type=None):
         """Adds a fields to the fields collection.
 
         :type parameters: office365.sharepoint.fields.creation_information.FieldCreationInformation
+        :param Field or None return_type: Return type
         """
-        return_type = Field(self.context)
+        if return_type is None:
+            return_type = Field(self.context)
         self.add_child(return_type)
         payload = {"parameters": parameters}
-        qry = ServiceOperationQuery(self, "AddField", None, payload, None, return_type)
+        qry = ServiceOperationQuery(self, "AddField", None, payload, None,
+                                    return_type)
         self.context.add_query(qry)
         return return_type
 
-    def create_taxonomy_field(self, name, term_set):
+    def create_taxonomy_field(self, name, term_set, allow_multiple_values=False):
         """
         Creates a Taxonomy field
 
         :param str name: Field name
         :param str or TermSet term_set: TermSet identifier or object
+        :param bool allow_multiple_values: Specifies whether the column will allow more than one value
         """
-        if isinstance(term_set, TermSet):
-            return_type = TaxonomyField(self.context)
+        return_type = TaxonomyField(self.context)
 
+        if isinstance(term_set, TermSet):
             def _term_set_loaded():
-                TaxonomyField.create(self, name, term_set.id, return_type)
+                TaxonomyField.create(self, name, term_set.id, None, allow_multiple_values,
+                                     return_type=return_type)
+
             term_set.ensure_property("id", _term_set_loaded)
             return return_type
         else:
-            return TaxonomyField.create(self, name, term_set)
+
+            def _term_store_loaded(term_store):
+                TaxonomyField.create(self, name, term_set, term_store.id, allow_multiple_values,
+                                     return_type=return_type)
+
+            self.context.load(self.context.taxonomy.term_store, after_loaded=_term_store_loaded)
+        return return_type
 
     def create_field_as_xml(self, schema_xml, return_type=None):
         """
         Creates a field based on the values defined in the parameters input parameter.
 
         :param str schema_xml: Specifies the schema that defines the field
-        :type return_type: Field
+        :param Field or None return_type: Return type
         """
         if return_type is None:
             return_type = Field(self.context)

office365/sharepoint/fields/computed.py

@@ -2,8 +2,11 @@ from office365.sharepoint.fields.field import Field
 
 
 class FieldComputed(Field):
-    """Specifies a computed field. To set the properties of this class, call the Update method
-    (section 3.2.5.42.2.1.5)."""
+    """
+    Specifies a computed field.
+
+    A field that can perform data manipulation and display functions by using the contents of other fields.
+    """
 
     @property
     def enable_lookup(self):

office365/sharepoint/fields/creation_information.py

@@ -15,10 +15,11 @@ class FieldCreationInformation(ClientValue):
         :param str lookup_web_id: Specifies the identifier of the site (2) that contains the list that is the
             source for the field (2) value.
         :param bool required: Specifies whether the field (2) requires a value.
-        :param str lookup_field_name:
-        :param str lookup_list_id: A CSOM GUID that specifies the target list for the lookup field (2).
-        :param str title:
-        :param int field_type_kind: Specifies the type of the field (2).
+        :param str lookup_field_name: Specifies the name of the field in the other data source when creating
+            a lookup field.
+        :param str lookup_list_id: A CSOM GUID that specifies the target list for the lookup field.
+        :param str title: Specifies the display name of the field.
+        :param int field_type_kind: Specifies the type of the field.
         :type description: str or None
         :param str formula:
         :param list[str] or None choices:

office365/sharepoint/fields/field.py

@@ -69,7 +69,8 @@ class Field(BaseEntity):
 
     def enable_index(self):
         """
-
+        Enables the index for a field
+        An index speeds up queries on the indexed fields as well as sorting and grouping operations
         """
         return_type = ClientResult(self.context)
         qry = ServiceOperationQuery(self, "enableIndex", None, None, None, return_type)
@@ -78,7 +79,7 @@ class Field(BaseEntity):
 
     def disable_index(self):
         """
-
+        Disables the index for a field
         """
         return_type = ClientResult(self.context)
         qry = ServiceOperationQuery(self, "disableIndex", None, None, None, return_type)
@@ -120,6 +121,14 @@ class Field(BaseEntity):
         """
         return self.properties.get('Id', None)
 
+    @property
+    def auto_indexed(self):
+        """
+        Gets a Boolean value that specifies whether the field is auto-indexed.
+        :rtype: str or None
+        """
+        return self.properties.get('AutoIndexed', None)
+
     @property
     def default_formula(self):
         """
@@ -166,16 +175,16 @@ class Field(BaseEntity):
 
     @title.setter
     def title(self, val):
-        """Sets a value that specifies the display name of the field.
-
+        """
+        Sets a value that specifies the display name of the field.
         :rtype: str or None
         """
         self.set_property("Title", val)
 
     @property
     def group(self):
-        """Gets a value that specifies the field group.
-
+        """
+        Gets a value that specifies the field group.
         :rtype: str or None
         """
         return self.properties.get('Group', None)
@@ -183,23 +192,22 @@ class Field(BaseEntity):
     @group.setter
     def group(self, val):
         """Sets a value that specifies the field group.
-
         :rtype: str or None
         """
         self.set_property("Group", val)
 
     @property
     def internal_name(self):
-        """Gets a value that specifies the field internal name.
-
+        """
+        Gets a value that specifies the field internal name.
         :rtype: str or None
         """
         return self.properties.get('InternalName', None)
 
     @property
     def can_be_deleted(self):
-        """Gets a value that specifies whether the field can be deleted
-
+        """
+        Gets a value that specifies whether the field can be deleted
         :rtype: bool or None
         """
         return self.properties.get('CanBeDeleted', None)
@@ -218,12 +226,42 @@ class Field(BaseEntity):
         """
         return self.properties.get('ClientSideComponentProperties', None)
 
+    @property
+    def client_validation_formula(self):
+        """
+        :rtype: str or None
+        """
+        return self.properties.get('ClientValidationFormula', None)
+
+    @property
+    def enforce_unique_values(self):
+        """
+        Specifies whether the field enforces unique values.
+        :rtype: bool or None
+        """
+        return self.properties.get('enforceUniqueValues', None)
+
+    @property
+    def filterable(self):
+        """
+        Specifies whether list items in the list can be filtered by the field value.
+        :rtype: bool or None
+        """
+        return self.properties.get('Filterable', None)
+
+    @property
+    def from_base_type(self):
+        """
+        Gets a Boolean value that indicates whether the field derives from a base field type.
+        :rtype: bool or None
+        """
+        return self.properties.get('FromBaseType', None)
+
     @property
     def js_link(self):
         """
         When implemented in a derived class, gets or sets the name of an external JavaScript file that contains
         any client rendering logic for fields of the derived type.
-
         :rtype: str or None
         """
         return self.properties.get('JSLink', None)
@@ -232,7 +270,6 @@ class Field(BaseEntity):
     def hidden(self):
         """
         Gets a value that specifies whether the field is hidden in list views and list forms.
-
         :rtype: bool or None
         """
         return self.properties.get('Hidden', None)
@@ -244,11 +281,26 @@ class Field(BaseEntity):
         """
         self.set_property("Hidden", val)
 
+    @property
+    def no_crawl(self):
+        """
+        Gets value that specifies whether the field can be crawled by a search engine.
+        :rtype: bool or None
+        """
+        return self.properties.get('NoCrawl', None)
+
+    @property
+    def read_only_field(self):
+        """
+        Specifies whether the value of the field is read-only.
+        :rtype: bool or None
+        """
+        return self.properties.get('ReadOnlyField', None)
+
     @property
     def default_value(self):
         """
         Gets  a value that specifies the default value for the field.
-
         :rtype: str or None
         """
         return self.properties.get('DefaultValue', None)
@@ -260,11 +312,17 @@ class Field(BaseEntity):
         """
         self.set_property("DefaultValue", val)
 
+    @property
+    def indexed(self):
+        """
+        :rtype: str or None
+        """
+        return self.properties.get('Indexed', None)
+
     @property
     def type_display_name(self):
         """
         Gets a value that specifies the display name for the type of the field.
-
         :rtype: str or None
         """
         return self.properties.get('TypeDisplayName', None)

office365/sharepoint/fields/user.py

@@ -34,9 +34,9 @@ class FieldUser(FieldLookup):
 
     @property
     def selection_group(self):
-        """Gets a value that specifies the identifier of the SharePoint group whose members can be selected
-            as values of the field.
-
+        """
+        Gets a value that specifies the identifier of the SharePoint group whose members can be selected
+        as values of the field.
         :rtype: int or None
         """
         return self.properties.get('SelectionGroup', None)

office365/sharepoint/files/checked_out_file.py

@@ -1,7 +1,7 @@
 from office365.runtime.paths.resource_path import ResourcePath
+from office365.runtime.paths.key import KeyPath
 from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.sharepoint.base_entity import BaseEntity
-from office365.sharepoint.internal.paths.entity import EntityPath
 from office365.sharepoint.principal.users.user import User
 
 
@@ -44,4 +44,5 @@ class CheckedOutFile(BaseEntity):
         super(CheckedOutFile, self).set_property(name, value, persist_changes)
         # fallback: create a new resource path
         if name == "CheckedOutById":
-            self._resource_path = EntityPath(value, self.parent_collection.resource_path)
+            self._resource_path = KeyPath(value, self.parent_collection.resource_path)
+        return self

office365/sharepoint/files/file.py

@@ -13,6 +13,7 @@ from office365.sharepoint.files.versions.event import FileVersionEvent
 from office365.sharepoint.base_entity import BaseEntity
 from office365.sharepoint.folders.folder import Folder
 from office365.sharepoint.permissions.irm.effective_settings import EffectiveInformationRightsManagementSettings
+from office365.sharepoint.permissions.irm.file_settings import InformationRightsManagementFileSettings
 from office365.sharepoint.permissions.irm.settings import InformationRightsManagementSettings
 from office365.sharepoint.principal.users.user import User
 from office365.sharepoint.files.versions.collection import FileVersionCollection
@@ -131,18 +132,22 @@ class File(AbstractFile):
         self.context.add_query(qry)
         return return_type
 
-    def share_link(self, link_kind, expiration=None):
+    def share_link(self, link_kind, expiration=None, role=None, password=None):
         """Creates a tokenized sharing link for a file based on the specified parameters and optionally
         sends an email to the people that are listed in the specified parameters.
 
         :param int link_kind: The kind of the tokenized sharing link to be created/updated or retrieved.
-        :param datetime or None expiration: A date/time string for which the format conforms to the ISO 8601:2004(E)
+        :param datetime.datetime or None expiration: A date/time string for which the format conforms to the ISO 8601:2004(E)
             complete representation for calendar date and time of day and which represents the time and date of expiry
             for the tokenized sharing link. Both the minutes and hour value MUST be specified for the difference
             between the local and UTC time. Midnight is represented as 00:00:00. A null value indicates no expiry.
             This value is only applicable to tokenized sharing links that are anonymous access links.
+        :param int role: The role to be used for the tokenized sharing link. This is required for Flexible links
+            and ignored for all other kinds.
+        :param str password: Optional password value to apply to the tokenized sharing link,
+            if it can support password protection.
         """
-        return self.listItemAllFields.share_link(link_kind, expiration)
+        return self.listItemAllFields.share_link(link_kind, expiration, role, password)
 
     def unshare_link(self, link_kind, share_id=None):
         """
@@ -676,7 +681,7 @@ class File(AbstractFile):
         Returns the Information Rights Management (IRM) settings for the file.
         """
         return self.properties.get('InformationRightsManagementSettings',
-                                   InformationRightsManagementSettings(self.context,
+                                   InformationRightsManagementFileSettings(self.context,
                                                                        ResourcePath(
                                                                            "InformationRightsManagementSettings",
                                                                            self.resource_path)))

office365/sharepoint/files/versions/version.py

@@ -3,7 +3,7 @@ from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.paths.service_operation import ServiceOperationPath
 from office365.sharepoint.base_entity import BaseEntity
-from office365.sharepoint.internal.paths.entity import EntityPath
+from office365.runtime.paths.key import KeyPath
 
 
 class FileVersion(BaseEntity):
@@ -15,15 +15,13 @@ class FileVersion(BaseEntity):
         :type file_object: typing.IO
         """
         def _file_version_loaded():
-            result = self.open_binary_stream()
-
-            def _process_response(response):
+            def _save_file(return_type):
                 """
-                :type response: requests.Response
+                :type return_type:ClientResult
                 """
-                response.raise_for_status()
-                file_object.write(result.value)
-            self.context.after_execute(_process_response)
+                file_object.write(return_type.value)
+            self.open_binary_stream().after_execute(_save_file)
+
         self.ensure_property("ID", _file_version_loaded)
         return self
 
@@ -87,5 +85,5 @@ class FileVersion(BaseEntity):
         super(FileVersion, self).set_property(key, value, persist_changes)
         if self._resource_path is None:
             if key == "ID":
-                self._resource_path = EntityPath(value, self.parent_collection.resource_path)
+                self._resource_path = KeyPath(value, self.parent_collection.resource_path)
         return self

office365/sharepoint/folders/collection.py

@@ -1,8 +1,8 @@
+from office365.runtime.paths.key import KeyPath
 from office365.runtime.paths.service_operation import ServiceOperationPath
 from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.sharepoint.base_entity_collection import BaseEntityCollection
 from office365.sharepoint.folders.folder import Folder
-from office365.sharepoint.internal.paths.entity import EntityPath
 from office365.sharepoint.types.resource_path import ResourcePath as SPResPath
 
 
@@ -48,7 +48,7 @@ class FolderCollection(BaseEntityCollection):
 
         :param str name: Specifies the Name of the folder.
         """
-        return_type = Folder(self.context, EntityPath(name, self.resource_path))
+        return_type = Folder(self.context, KeyPath(name, self.resource_path))
         self.add_child(return_type)
         qry = ServiceOperationQuery(self, "Add", [name], None, None, return_type)
         self.context.add_query(qry)

office365/sharepoint/folders/coloring.py

@@ -0,0 +1,39 @@
+from office365.runtime.queries.service_operation import ServiceOperationQuery
+from office365.sharepoint.base_entity import BaseEntity
+from office365.sharepoint.folders.folder import Folder
+
+
+class FolderColoring(BaseEntity):
+    """"""
+
+    def create_folder(self, decoded_url, ensure_unique_file_name=True, overwrite=True, coloring_information=None):
+        """
+        :param str decoded_url:
+        :param bool ensure_unique_file_name:
+        :param bool overwrite:
+        :param FolderColoringInformation coloring_information:
+        """
+        return_type = Folder(self.context)
+
+        payload = {
+            "DecodedUrl": decoded_url,
+            "EnsureUniqueFileName": ensure_unique_file_name,
+            "Overwrite": overwrite,
+            "coloringInformation": coloring_information
+        }
+        qry = ServiceOperationQuery(self, "CreateFolder", parameters_type=payload, return_type=return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    def stamp_color(self, decoded_url, coloring_information):
+        """
+        :param str decoded_url:
+        :param FolderColoringInformation coloring_information:
+        """
+        payload = {
+            "DecodedUrl": decoded_url,
+            "coloringInformation": coloring_information
+        }
+        qry = ServiceOperationQuery(self, "StampColor", parameters_type=payload)
+        self.context.add_query(qry)
+        return self

office365/sharepoint/folders/coloring_information.py

@@ -0,0 +1,15 @@
+from office365.runtime.client_value import ClientValue
+
+
+class FolderColoringInformation(ClientValue):
+    """"""
+
+    def __init__(self, color_hex=None, color_tag=None, emoji=None):
+        """
+        :param str color_hex:
+        :param str color_tag:
+        :param str emoji:
+        """
+        self.ColorHex = color_hex
+        self.ColorTag = color_tag
+        self.Emoji = emoji

office365/sharepoint/folders/folder.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 from office365.runtime.client_result import ClientResult
 from office365.runtime.client_value_collection import ClientValueCollection
 from office365.runtime.queries.service_operation import ServiceOperationQuery
@@ -132,18 +134,25 @@ class Folder(BaseEntity):
         self.ensure_property("ServerRelativePath", _move_folder)
         return return_type
 
-    def share_link(self, link_kind, expiration=None):
+    def share_link(self, link_kind, expiration=None, role=None, password=None):
         """Creates a tokenized sharing link for a folder based on the specified parameters and optionally
         sends an email to the people that are listed in the specified parameters.
 
         :param int link_kind: The kind of the tokenized sharing link to be created/updated or retrieved.
-        :param datetime or None expiration: A date/time string for which the format conforms to the ISO 8601:2004(E)
+        :param datetime.datetime or None expiration: A date/time string for which the format conforms to the ISO 8601:2004(E)
             complete representation for calendar date and time of day and which represents the time and date of expiry
             for the tokenized sharing link. Both the minutes and hour value MUST be specified for the difference
             between the local and UTC time. Midnight is represented as 00:00:00. A null value indicates no expiry.
             This value is only applicable to tokenized sharing links that are anonymous access links.
+        :param int role: The role to be used for the tokenized sharing link. This is required for Flexible links
+            and ignored for all other kinds.
+        :param str password: Optional password value to apply to the tokenized sharing link,
+            if it can support password protection.
         """
-        return self.list_item_all_fields.share_link(link_kind, expiration)
+        return self.list_item_all_fields.share_link(link_kind=link_kind,
+                                                    expiration=expiration,
+                                                    role=role,
+                                                    password=password)
 
     def unshare_link(self, link_kind, share_id=None):
         """
@@ -446,23 +455,24 @@ class Folder(BaseEntity):
 
     @property
     def time_created(self):
-        """Gets when the folder was created in UTC.
-
+        """
+        Gets when the folder was created in UTC.
         :rtype: datetime or None
         """
-        return self.properties.get("TimeCreated", None)
+        return self.properties.get("TimeCreated", datetime.min)
 
     @property
     def serverRelativeUrl(self):
-        """Gets the server-relative URL of the list folder.
-
+        """
+        Gets the server-relative URL of the list folder.
         :rtype: str or None
         """
         return self.properties.get("ServerRelativeUrl", None)
 
     @property
     def server_relative_path(self):
-        """Gets the server-relative Path of the list folder.
+        """
+        Gets the server-relative Path of the list folder.
         :rtype: SPResPath or None
         """
         return self.properties.get("ServerRelativePath", SPResPath())
@@ -479,7 +489,8 @@ class Folder(BaseEntity):
                 "ListItemAllFields": self.list_item_all_fields,
                 "ParentFolder": self.parent_folder,
                 "ServerRelativePath": self.server_relative_path,
-                "StorageMetrics": self.storage_metrics
+                "StorageMetrics": self.storage_metrics,
+                "TimeCreated": self.time_created
             }
             default_value = property_mapping.get(name, None)
         return super(Folder, self).get_property(name, default_value)