Пример #1
0
		private static void CreateFields(ClientContext ctx, ContentType orderCT) {
			#region Customer
			FieldCreationInformation customer = new FieldCreationInformation(FieldType.Lookup);
			customer.DisplayName = "Customer";
			customer.InternalName = "Customer";
			customer.Group = "ODA1";
			customer.Id = Constants.GUID.OrderCT.CUSTOMER.ToGuid();

			ctx.Web.AddFieldToContentType(orderCT, ctx.Web.CreateField<FieldUrl>(customer, false));
			#endregion
			#region Product
			TaxonomyFieldCreationInformation product = new TaxonomyFieldCreationInformation();

			product.DisplayName = "Product";
			product.InternalName = "Product_2";
			product.Group = "ODA1";
			product.TaxonomyItem = GetProductTermSet(ctx);
			
			product.Id = Constants.GUID.OrderCT.PRODUCT.ToGuid();
			var meh = ctx.Web.CreateTaxonomyField(product);
			ctx.ExecuteQuery();
			ctx.Web.WireUpTaxonomyField(meh, product.TaxonomyItem as TermSet);
			ctx.Web.AddFieldToContentType(orderCT, meh );
			#endregion
			#region Price
			FieldCreationInformation price = new FieldCreationInformation(FieldType.Currency);
			price.DisplayName = "Price";
			price.InternalName = "Price";
			price.Group = "ODA1";
			price.Id = Constants.GUID.OrderCT.PRICE.ToGuid();

			FieldUrl addedPrice = ctx.Web.CreateField<FieldUrl>(price, false);
			ctx.Web.AddFieldToContentType(orderCT, addedPrice);
			#endregion
		}
Пример #2
0
        protected override void ExecuteCmdlet()
        {
            Field field = null;
            var termSet = ClientContext.Site.GetTaxonomyItemByPath(TermSetPath, TermPathDelimiter);
            Guid id = Id.Id;
            if (id == Guid.Empty)
            {
                id = Guid.NewGuid();
            }

            TaxonomyFieldCreationInformation fieldCI = new TaxonomyFieldCreationInformation()
            {
                Id = id,
                InternalName = InternalName,
                DisplayName = DisplayName,
                Group = Group,
                TaxonomyItem = termSet,
                MultiValue = MultiValue,
                Required = Required,
                AddToDefaultView = AddToDefaultView
            };

            if (List != null)
            {
                var list = this.SelectedWeb.GetList(List);

                field = list.CreateTaxonomyField(fieldCI);
            }
            else
            {
                field = this.SelectedWeb.CreateTaxonomyField(fieldCI);
            }
            WriteObject(field);
        }
Пример #3
0
        /// <summary>
        /// Used to create a custom document library and Contoso Content type
        /// </summary>
        /// <param name="ctx">The authenticated ClientContext</param>
        /// <param name="library">The Library to create</param>
        public void CreateContosoDocumentLibrary(ClientContext ctx, Library library)
        {
            //Check the fields
            if (!ctx.Web.FieldExistsById(FLD_CLASSIFICATION_ID))
            {
                TermStore termStore = GetDefaultTermStore(ctx.Web);

                if (termStore == null)
                {
                    throw new NullReferenceException("The default term store is not available.");
                }

                // get the term group and term set
                TermGroup termGroup = termStore.Groups.GetByName(TAXONOMY_GROUP);
                TermSet termSet = termGroup.TermSets.GetByName(TAXONOMY_TERMSET_CLASSIFICATION_NAME);
                ctx.Load(termStore);
                ctx.Load(termSet);
                ctx.ExecuteQuery();

                TaxonomyFieldCreationInformation fldCreate = new TaxonomyFieldCreationInformation()
                {
                    Id = FLD_CLASSIFICATION_ID,
                    InternalName = FLD_CLASSIFICATION_INTERNAL_NAME,
                    DisplayName = FLD_CLASSIFICATION_DISPLAY_NAME,
                    Group = FIELDS_GROUP_NAME,
                    TaxonomyItem = termSet,                    
                };
                ctx.Web.CreateTaxonomyField(fldCreate);

            }

            //check the content type
            if (!ctx.Web.ContentTypeExistsById(CONTOSODOCUMENT_CT_ID))
            {
                ctx.Web.CreateContentType(CONTOSODOCUMENT_CT_NAME,
                                          CT_DESC, CONTOSODOCUMENT_CT_ID,
                                          CT_GROUP);
            }

            //associate fields to content types
            if (!ctx.Web.FieldExistsByNameInContentType(CONTOSODOCUMENT_CT_NAME, FLD_CLASSIFICATION_INTERNAL_NAME))
            {
                ctx.Web.AddFieldToContentTypeById(CONTOSODOCUMENT_CT_ID,
                                                  FLD_CLASSIFICATION_ID.ToString(),
                                                  false);
            }

            
            CreateLibrary(ctx, library, CONTOSODOCUMENT_CT_ID);
        }
Пример #4
0
        protected void btnScenario2_Click(object sender, EventArgs e)
        {
            // Taxonomy field to host web - Note that this requires that group and taxonomy set exists when the code is executed.
            var spContext = SharePointContextProvider.Current.GetSharePointContext(Context);
            // Notice that you can assign the guid if needed - in here we randomize it for demo purposes
            var taxFieldId = Guid.NewGuid();

            using (var ctx = spContext.CreateUserClientContextForSPHost())
            {
                var groupName = drpGroups.SelectedItem.Text;
                var termSetName = drpTermSets.SelectedItem.Text;
                var taxFieldName = "ContosoTaxonomySample";

                if (!ctx.Web.FieldExistsByName(taxFieldName))
                {
                    // Get access to the right term set
                    TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(ctx.Web.Context);
                    TermStore termStore = taxonomySession.GetDefaultSiteCollectionTermStore();
                    TermGroup termGroup = termStore.Groups.GetByName(groupName);
                    TermSet termSet = termGroup.TermSets.GetByName(termSetName);
                    ctx.Web.Context.Load(termStore);
                    ctx.Web.Context.Load(termSet);
                    ctx.Web.Context.ExecuteQueryRetry();

                    TaxonomyFieldCreationInformation fieldCI = new TaxonomyFieldCreationInformation()
                    {
                        Id = taxFieldId,
                        InternalName = taxFieldName,
                        DisplayName = "Contoso Taxonomy Sample",
                        Group = "Contoso Fields",
                        TaxonomyItem = termSet,
                    };
                    ctx.Web.CreateTaxonomyField(fieldCI);
                    lblStatus2.Text = string.Format("Created new taxonomy field with name of 'Contoso Taxonomy Sample'. Move to <a href='{0}'>host web</a> and test the functionality.", spContext.SPHostUrl.ToString());
                }
                else
                {
                    ctx.Web.WireUpTaxonomyField(taxFieldId, groupName, termSetName);
                    lblStatus2.Text = "Taxonomy field with planned Id already existed";
                }
            }
        }
Пример #5
0
        /// <summary>
        /// Used to create a custom document library and Contoso Content type
        /// </summary>
        /// <param name="ctx">The client context that has be authenticated</param>
        /// <param name="library">The Library to create</param>
        public void CreateContosoDocumentLibrary(ClientContext ctx, Library library)
        {
            //Check the fields
            if (!ctx.Web.FieldExistsById(FLD_CLASSIFICATION_ID)){

                // Get access to the right term set
                TaxonomySession taxonomySession = TaxonomySession.GetTaxonomySession(ctx.Web.Context);
                TermStore termStore = taxonomySession.GetDefaultSiteCollectionTermStore();
                TermGroup termGroup = termStore.Groups.GetByName(TAXONOMY_GROUP);
                TermSet termSet = termGroup.TermSets.GetByName(TAXONOMY_TERMSET_CLASSIFICATION_NAME);
                ctx.Web.Context.Load(termStore);
                ctx.Web.Context.Load(termSet);
                ctx.Web.Context.ExecuteQueryRetry();

                TaxonomyFieldCreationInformation fieldCI = new TaxonomyFieldCreationInformation()
                {
                    Id = FLD_CLASSIFICATION_ID,
                    InternalName = FLD_CLASSIFICATION_INTERNAL_NAME,
                    DisplayName = FLD_CLASSIFICATION_DISPLAY_NAME,
                    Group = FIELDS_GROUP_NAME,
                    TaxonomyItem = termSet
                };
                ctx.Web.CreateTaxonomyField(fieldCI);
            }
            
            //check the content type
            if (!ctx.Web.ContentTypeExistsById(CONTOSODOCUMENT_CT_ID)){
                ctx.Web.CreateContentType(CONTOSODOCUMENT_CT_NAME, 
                                          CT_DESC, CONTOSODOCUMENT_CT_ID, 
                                          CT_GROUP);
            }

            //associate fields to content types
            if (!ctx.Web.FieldExistsByNameInContentType(CONTOSODOCUMENT_CT_NAME, FLD_CLASSIFICATION_INTERNAL_NAME)){
                ctx.Web.AddFieldToContentTypeByName(CONTOSODOCUMENT_CT_NAME, 
                                                    FLD_CLASSIFICATION_ID);
            }
            CreateLibrary(ctx, library, CONTOSODOCUMENT_CT_ID);
          
        }
Пример #6
0
        /// <summary>
        /// Can be used to create taxonomy field remotely to web.
        /// </summary>
        /// <param name="web">Site to be processed - can be root web or sub site</param>
        /// <param name="fieldCreationInformation">Creation Information of the field</param>
        /// <returns>New taxonomy field</returns>
        public static Field CreateTaxonomyField(this Web web, TaxonomyFieldCreationInformation fieldCreationInformation)
        {
            fieldCreationInformation.InternalName.ValidateNotNullOrEmpty("internalName");
            fieldCreationInformation.DisplayName.ValidateNotNullOrEmpty("displayName");
            fieldCreationInformation.TaxonomyItem.ValidateNotNullOrEmpty("taxonomyItem");

            CleanupTaxonomyHiddenField(web, web.Fields, fieldCreationInformation);

            if (fieldCreationInformation.Id == Guid.Empty)
            {
                fieldCreationInformation.Id = Guid.NewGuid();
            }

            var showFieldAttribute = new KeyValuePair<string, string>();
            if (fieldCreationInformation.AdditionalAttributes != null)
            {
                showFieldAttribute = fieldCreationInformation.AdditionalAttributes.FirstOrDefault(a => a.Key == "ShowField");
            }
            if (showFieldAttribute.Key == null)
            {
                if (fieldCreationInformation.AdditionalAttributes == null)
                {
                    fieldCreationInformation.AdditionalAttributes = new List<KeyValuePair<string, string>>();
                }
                ((List<KeyValuePair<string, string>>)fieldCreationInformation.AdditionalAttributes).Add(new KeyValuePair<string, string>("ShowField", "Term1033"));
            }

            var _field = web.CreateField(fieldCreationInformation);

            WireUpTaxonomyFieldInternal(_field, fieldCreationInformation.TaxonomyItem, fieldCreationInformation.MultiValue);
            _field.Update();

            web.Context.ExecuteQueryRetry();

            return _field;
        }
        protected override void ExecuteCmdlet()
        {
            TaxonomyItem taxItem = null;
            Field field;
            if (ParameterSetName == "Path")
            {
                taxItem = ClientContext.Site.GetTaxonomyItemByPath(TermSetPath, TermPathDelimiter);
            }
            else
            {
                var taxSession = ClientContext.Site.GetTaxonomySession();
                var termStore = taxSession.GetDefaultKeywordsTermStore();
                try
                {
                    taxItem = termStore.GetTermSet(TaxonomyItemId.Id);
                }
                catch
                {
                    try
                    {
                        taxItem = termStore.GetTerm(TaxonomyItemId.Id);
                    }
                    catch
                    {
                        throw new Exception(string.Format("Taxonomy Item with Id {0} not found", TaxonomyItemId.Id));
                    }
                }
                taxItem.EnsureProperty(t => t.Id);
            }

            Guid id = Id.Id;
            if (id == Guid.Empty)
            {
                id = Guid.NewGuid();
            }

            TaxonomyFieldCreationInformation fieldCI = new TaxonomyFieldCreationInformation()
            {
                Id = id,
                InternalName = InternalName,
                DisplayName = DisplayName,
                Group = Group,
                TaxonomyItem = taxItem,
                MultiValue = MultiValue,
                Required = Required,
                AddToDefaultView = AddToDefaultView
            };

            if (List != null)
            {
                var list = List.GetList(SelectedWeb);
                field = list.CreateTaxonomyField(fieldCI);
            }
            else
            {
                field = SelectedWeb.CreateTaxonomyField(fieldCI);
            }
            WriteObject(field);
        }
 public static Field CreateTaxonomyField(this List list, Guid id, string internalName, string displayName, string group, Term anchorTerm, bool multiValue = false)
 {
     TaxonomyFieldCreationInformation fieldCI = new TaxonomyFieldCreationInformation()
     {
         Id = id,
         InternalName = internalName,
         DisplayName = displayName,
         Required = false,
         Group = group,
         MultiValue = multiValue,
         TaxonomyItem = anchorTerm
     };
     return list.CreateTaxonomyField(fieldCI);
 }
        public static Field CreateTaxonomyField(this List list, Guid id, string internalName, string displayName, string group, string mmsGroupName, string mmsTermSetName, bool multiValue = false)
        {
            id.ValidateNotNullOrEmpty("id");
            internalName.ValidateNotNullOrEmpty("internalName");
            displayName.ValidateNotNullOrEmpty("displayName");
            mmsGroupName.ValidateNotNullOrEmpty("mmsGroupName");
            mmsTermSetName.ValidateNotNullOrEmpty("mmsTermSetName");

            var clientContext = list.Context as ClientContext;
            TermStore termStore = clientContext.Site.GetDefaultSiteCollectionTermStore();


            if (termStore == null)
                throw new NullReferenceException("The default term store is not available.");

            // get the term group and term set
            TermGroup termGroup = termStore.Groups.GetByName(mmsGroupName);
            TermSet termSet = termGroup.TermSets.GetByName(mmsTermSetName);
            list.Context.Load(termStore);
            list.Context.Load(termSet);
            list.Context.ExecuteQuery();

            TaxonomyFieldCreationInformation fieldCI = new TaxonomyFieldCreationInformation()
            {
                Id = id,
                InternalName = internalName,
                DisplayName = displayName,
                Required = false,
                Group = group,
                MultiValue = multiValue,
                TaxonomyItem = termSet
            };
            return list.CreateTaxonomyField(fieldCI);
        }
 public static Field CreateTaxonomyField(this Web web, Guid id, string internalName, string displayName, string group, TermSet termSet, bool multiValue = false)
 {
     TaxonomyFieldCreationInformation fieldCI = new TaxonomyFieldCreationInformation()
     {
         Id = id,
         InternalName = internalName,
         DisplayName = displayName,
         Group = group,
         TaxonomyItem = termSet,
         MultiValue = multiValue
     };
     return web.CreateTaxonomyField(fieldCI);
 }
        public static Field CreateTaxonomyField(this Web web, Guid id, string internalName, string displayName, string group, string mmsGroupName, string mmsTermSetName, bool multiValue = false)
        {
            id.ValidateNotNullOrEmpty("id");
            internalName.ValidateNotNullOrEmpty("internalName");
            displayName.ValidateNotNullOrEmpty("displayName");
            // Group can be emtpy
            mmsGroupName.ValidateNotNullOrEmpty("mmsGroupName");
            mmsTermSetName.ValidateNotNullOrEmpty("mmsTermSetName");

            TermStore termStore = GetDefaultTermStore(web);

            if (termStore == null)
                throw new NullReferenceException("The default term store is not available.");


            // get the term group and term set
            TermGroup termGroup = termStore.Groups.GetByName(mmsGroupName);
            TermSet termSet = termGroup.TermSets.GetByName(mmsTermSetName);
            web.Context.Load(termStore);
            web.Context.Load(termSet);
            web.Context.ExecuteQuery();

            TaxonomyFieldCreationInformation fieldCI = new TaxonomyFieldCreationInformation()
            {
                Id = id,
                InternalName = internalName,
                DisplayName = displayName,
                Group = group,
                TaxonomyItem = termSet,
                MultiValue = multiValue
            };
            return web.CreateTaxonomyField(fieldCI);
        }
Пример #12
0
        public void CreateTaxonomyFieldLinkedToTermTest()
        {
            using (var clientContext = TestCommon.CreateClientContext())
            {
                // Retrieve Termset and Term
                TaxonomySession session = TaxonomySession.GetTaxonomySession(clientContext);
                var termSet = session.GetDefaultSiteCollectionTermStore().GetTermSet(_termSetId);
                var anchorTerm = termSet.GetTerm(_termId);
                clientContext.Load(termSet);
                clientContext.Load(anchorTerm);
                clientContext.ExecuteQuery();

                // Retrieve List
                var list = clientContext.Web.Lists.GetById(_listId);
                clientContext.Load(list);
                clientContext.ExecuteQuery();

                // Create field
                var fieldId = Guid.NewGuid();
                var fieldName = "Test_" + DateTime.Now.ToFileTime();
                TaxonomyFieldCreationInformation fieldCI = new TaxonomyFieldCreationInformation()
                {
                    Id = fieldId,
                    DisplayName = fieldName,
                    InternalName = fieldName,
                    Group = "Test Fields Group",
                    TaxonomyItem = anchorTerm
                };
                var field = list.CreateTaxonomyField(fieldCI);


                Assert.AreEqual(fieldId, field.Id, "Field IDs do not match.");
                Assert.AreEqual(fieldName, field.InternalName, "Field internal names do not match.");
                Assert.AreEqual("TaxonomyFieldType", field.TypeAsString, "Failed to create a TaxonomyField object.");
            }
        }
Пример #13
0
        public void SetTaxonomyFieldValueTest()
        {
            var fieldName = "Test2_" + DateTime.Now.ToFileTime();

            var fieldId = Guid.NewGuid();

            using (var clientContext = TestCommon.CreateClientContext())
            {
                // Retrieve list
                var list = clientContext.Web.Lists.GetById(_listId);
                clientContext.Load(list);
                clientContext.ExecuteQuery();

                // Retrieve Termset
                TaxonomySession session = TaxonomySession.GetTaxonomySession(clientContext);
                var termSet = session.GetDefaultSiteCollectionTermStore().GetTermSet(_termSetId);
                clientContext.Load(termSet);
                clientContext.ExecuteQuery();

                // Create taxonomyfield first
                TaxonomyFieldCreationInformation fieldCI = new TaxonomyFieldCreationInformation()
                {
                    Id = fieldId,
                    DisplayName = fieldName,
                    InternalName = fieldName,
                    Group = "Test Fields Group",
                    TaxonomyItem = termSet
                };
                var field = list.CreateTaxonomyField(fieldCI);

                // Create Item
                ListItemCreationInformation itemCi = new ListItemCreationInformation();

                var item = list.AddItem(itemCi);
                item.Update();
                clientContext.Load(item);
                clientContext.ExecuteQuery();

                item.SetTaxonomyFieldValue(fieldId, _termName, _termId);

                clientContext.Load(item, i => i[fieldName]);
                clientContext.ExecuteQuery();

                var value = item[fieldName] as TaxonomyFieldValue;

                Assert.AreEqual(_termId.ToString(), value.TermGuid, "Term not set correctly");
            }
        }
Пример #14
0
        public void CreateTaxonomyFieldMultiValueTest()
        {
            using (var clientContext = TestCommon.CreateClientContext())
            {
                // Retrieve Termset
                TaxonomySession session = TaxonomySession.GetTaxonomySession(clientContext);
                var termSet = session.GetDefaultSiteCollectionTermStore().GetTermSet(_termSetId);
                clientContext.Load(termSet);
                clientContext.ExecuteQuery();

                // Get Test TermSet

                var web = clientContext.Web;
                var fieldName = "Test_" + DateTime.Now.ToFileTime();
                var fieldId = Guid.NewGuid();
                TaxonomyFieldCreationInformation fieldCI = new TaxonomyFieldCreationInformation()
                {
                    Id = fieldId,
                    DisplayName = fieldName,
                    InternalName = fieldName,
                    Group = "Test Fields Group",
                    TaxonomyItem = termSet,
                    MultiValue = true
                };
                var field = web.CreateTaxonomyField(fieldCI);


                Assert.AreEqual(fieldId, field.Id, "Field IDs do not match.");
                Assert.AreEqual(fieldName, field.InternalName, "Field internal names do not match.");
                Assert.AreEqual("TaxonomyFieldTypeMulti", field.TypeAsString, "Failed to create a TaxonomyField object.");
            }
        }
Пример #15
0
 private static void CleanupTaxonomyHiddenField(Web web, FieldCollection fields, TaxonomyFieldCreationInformation fieldCreationInformation)
 {
     // if the Guid is empty then we'll have no issue
     if (fieldCreationInformation.Id != Guid.Empty)
     {
         FieldCollection _fields = fields;
         web.Context.Load(_fields, fc => fc.Include(f => f.Id, f => f.InternalName, f => f.Hidden));
         web.Context.ExecuteQueryRetry();
         var _field = _fields.FirstOrDefault(f => f.InternalName.Equals(fieldCreationInformation.InternalName));
         // if the field does not exist we assume the possiblity that it was created earlier then deleted and the hidden field was left behind
         // if the field does exist then return and let the calling process exception out when attempting to create it
         // this does not appear to be an issue with lists, just site columns, but it doesnt hurt to check
         if (_field == null)
         {
             // The hidden field format is the id of the field itself with hyphens removed and the first character replaced
             // with a random character, so get everything to the right of the first character and remove hyphens
             var _hiddenField = fieldCreationInformation.Id.ToString().Replace("-", "").Substring(1);
             _field = _fields.FirstOrDefault(f => f.InternalName.EndsWith(_hiddenField));
             if (_field != null)
             {
                 if (_field.Hidden)
                 {
                     // just in case the field itself is hidden, make sure it is not because depending on the current CU hidden fields may not be deletable
                     _field.Hidden = false;
                     _field.Update();
                 }
                 _field.DeleteObject();
                 web.Context.ExecuteQueryRetry();
             }
         }
     }
 }
Пример #16
0
        /// <summary>
        /// Can be used to create taxonomy field remotely in a list. 
        /// </summary>
        /// <param name="list">List to be processed</param>
        /// <param name="fieldCreationInformation">Creation information of the field</param>
        /// <returns>New taxonomy field</returns>
        public static Field CreateTaxonomyField(this List list, TaxonomyFieldCreationInformation fieldCreationInformation)
        {
            fieldCreationInformation.InternalName.ValidateNotNullOrEmpty("internalName");
            fieldCreationInformation.DisplayName.ValidateNotNullOrEmpty("displayName");
            fieldCreationInformation.TaxonomyItem.ValidateNotNullOrEmpty("taxonomyItem");

            if (fieldCreationInformation.Id == Guid.Empty)
            { 
                fieldCreationInformation.Id = Guid.NewGuid(); 
            }
            try
            {
                List<KeyValuePair<string, string>> additionalAttributes = new List<KeyValuePair<string, string>>();
                additionalAttributes.Add(new KeyValuePair<string, string>("ShowField", "Term1033"));

                var _field = list.CreateField(fieldCreationInformation);

                WireUpTaxonomyFieldInternal(_field, fieldCreationInformation.TaxonomyItem, fieldCreationInformation.MultiValue);
                _field.Update();

                list.Context.ExecuteQuery();

                return _field;
            }
            catch (Exception)
            {
                ///If there is an exception the hidden field might be present
                FieldCollection _fields = list.Fields;
                list.Context.Load(_fields, fc => fc.Include(f => f.Id, f => f.InternalName));
                list.Context.ExecuteQuery();
                var _hiddenField = fieldCreationInformation.Id.ToString().Replace("-", "");

                var _field = _fields.FirstOrDefault(f => f.InternalName == _hiddenField);
                if (_field != null)
                {
                    _field.Hidden = false; // Cannot delete a hidden column
                    _field.Update();
                    _field.DeleteObject();
                    list.Context.ExecuteQuery();
                }
                throw;
            }
        }