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

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/content_type.py

@@ -45,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):
         """
@@ -60,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.
@@ -91,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"

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,32 +108,27 @@ 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
 
-    def add_taxonomy_field(self, title, description=None):
-        """
-        Adds a taxonomy field
-        """
-        pass
-
     def add(self, field_create_information):
         """Adds a fields to the fields collection.
 
@@ -127,15 +140,18 @@ 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
 
@@ -151,7 +167,9 @@ class FieldCollection(BaseEntityCollection):
 
         if isinstance(term_set, TermSet):
             def _term_set_loaded():
-                TaxonomyField.create(self, name, term_set.id, None, allow_multiple_values, return_type=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:
@@ -159,6 +177,7 @@ class FieldCollection(BaseEntityCollection):
             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
 
@@ -167,7 +186,7 @@ class FieldCollection(BaseEntityCollection):
         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/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/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/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