private static void CreatePages(ClientContext context, EnterpriseManualProperies p, string targetContentTypeName) { var page = context.Web.AddClientSidePage(p.FileName, true); ClientSideText txt1 = new ClientSideText() { Text = p.WikiContent }; page.AddControl(txt1, -1); Microsoft.SharePoint.Client.ContentType newContentType = context.Web.GetContentTypeByName(targetContentTypeName); context.Load(newContentType); context.ExecuteQuery(); ListItem item = page.PageListItem; context.Load(item); context.ExecuteQuery(); item.Properties["ContentTypeId"] = newContentType.Id.StringValue; item["ContentTypeId"] = newContentType.Id; item.Update(); page.Save(); context.ExecuteQuery(); }
public override int InsertItemByContentType <TContentType>(string listTitle, Fields <TContentType> fields) { Logger.Information("ClientQuery.InsertItemByContentType<TContentType>", string.Format("List = {0}, Items = {1}, ToArray = {2}", listTitle, string.Join(",", fields.ItemDictionary.Select(i => string.Format("{0} = {1}", i.Key, i.Value)).ToArray()))); using (_clientContext) { var list = _clientContext.Web.Lists.GetByTitle(listTitle); var listCreationInformation = new ListItemCreationInformation(); var listItem = list.AddItem(listCreationInformation); Microsoft.SharePoint.Client.ContentType oContentType = GetContentType(list, typeof(TContentType).GetCustomAttribute <ContentAttribute>(true).Name); listItem["ContentTypeId"] = oContentType.Id.ToString(); foreach (var field in fields.ItemDictionary) { listItem[field.Key] = field.Value; } listItem.Update(); _clientContext.ExecuteQuery(); return(listItem.Id); } }
public static string GetSettingsUrl(this SPClient.ContentType ct, TreeNode selectedNode) { // Link: <sitecollection|web>/_layouts/ManageContentType.aspx?ctype=0x0101009148F5A04DDD49CBA7127AADA5FB792B006973ACD696DC4858A76371B2FB2F439A // Link: <sitecollection|web>/_layouts/ManageContentType.aspx?List=%7BF798C4D9%2DEF29%2D4F8D%2DA1F1%2D4C70CFBAECE4%7D&ctype=0x010100A204AFB24228A94AB2D6195EB1705291 if (selectedNode.Parent.Parent.Tag is SPClient.Site) { SPClient.Site site = selectedNode.Parent.Parent.Tag as SPClient.Site; return(string.Format("{0}/_layouts/ManageContentType.aspx?ctype={1}", site.RootWeb.GetUrl(), ct.Id)); } else if (selectedNode.Parent.Parent.Tag is SPClient.Web) { // <sitecollection>/<web>/_layouts/15/ManageContentType.aspx?ctype=0x00A7470EADF4194E2E9ED1031B61DA088403000BE6CEFFF1ACA6429D14B2B7E0A03FE2 // <sitecollection>/<web>/_layouts/15/start.aspx#/_layouts/15/ManageContentType.aspx?ctype=0x00A7470EADF4194E2E9ED1031B61DA088403000BE6CEFFF1ACA6429D14B2B7E0A03FE2&Source=https%3A%2F%2Fbramdejager%2Esharepoint%2Ecom%2Fsub%2F%5Flayouts%2F15%2Fmngctype%2Easpx SPClient.Web web = selectedNode.Parent.Parent.Tag as SPClient.Web; return(string.Format("{0}/_layouts/ManageContentType.aspx?ctype={1}", web.GetUrl(), ct.Id)); } else if (selectedNode.Parent.Parent.Tag is SPClient.List) { SPClient.List list = selectedNode.Parent.Parent.Tag as SPClient.List; return(string.Format("{0}/_layouts/ManageContentType.aspx?list={1}&ctype={2}", list.ParentWeb.GetUrl(), list.Id, ct.Id)); } else { return(string.Empty); } }
public static void CreateContentType(ClientContext ctx, string contentTypeName, string categoryFieldName) { //ctx.Web.ContentTypeExistsByName ContentTypeCollection contentTypes = ctx.Web.ContentTypes; ctx.Load(contentTypes); ctx.ExecuteQuery(); if (ctx.Web.ContentTypeExistsByName(contentTypeName)) { return; } // Create a Content Type Information object. ContentTypeCreationInformation newCt = new ContentTypeCreationInformation(); // Set the name for the content type. newCt.Name = contentTypeName; //Site Page - 0x0101009D1CB255DA76424F860D91F20E6C4118 newCt.ParentContentType = ctx.Web.ContentTypes.GetById("0x0101009D1CB255DA76424F860D91F20E6C4118"); // Set content type to be available from specific group. newCt.Group = "LB Content Types"; // Create the content type. Microsoft.SharePoint.Client.ContentType myContentType = contentTypes.Add(newCt); FieldLinkCollection fieldsCollection = myContentType.FieldLinks; ctx.Load(fieldsCollection); ctx.ExecuteQuery(); FieldCollection fields = ctx.Site.RootWeb.Fields; ctx.Load(fields); ctx.ExecuteQuery(); //Field f = ctx.Site.RootWeb.Fields.GetFieldByInternalName(categoryFieldName); fieldsCollection.Add(new FieldLinkCreationInformation { //Field = ctx.Site.RootWeb.Fields.GetFieldByInternalName(categoryFieldName) Field = fields.GetFieldByInternalName(categoryFieldName) }); myContentType.Update(true); ctx.ExecuteQuery(); }
public void Create(ClientContext ctx) { Console.WriteLine("Creating content type {0}", this.Name); var createdCT = ctx.Web.CreateContentType(this.Name, this.Description, this.ContentTypeId.ToString(), this.Group, this.Parent); this.AssociatedContentType = createdCT; foreach (var column in this.ColumnsToAdd) { createdCT.AddFieldByName(column.FieldInformation.InternalName); } }
private static void CreatePages(ClientContext context, ErhvervManualProperies p, string targetContentTypeName) { var page = context.Web.AddClientSidePage(p.FileName, true); ClientSideText txt1 = new ClientSideText() { Text = p.WikiContent }; page.AddControl(txt1, -1); Microsoft.SharePoint.Client.ContentType newContentType = context.Web.GetContentTypeByName(targetContentTypeName); context.Load(newContentType); context.ExecuteQuery(); ListItem item = page.PageListItem; //item.Update(); context.Load(item); context.ExecuteQuery(); //item["ContentType"] = newContentType.Name; item.Properties["ContentTypeId"] = newContentType.Id.StringValue; item["ContentTypeId"] = newContentType.Id; item.Update(); //page.Save(); //context.ExecuteQuery(); //context.ExecuteQuery(); if (!string.IsNullOrEmpty(p.ErhvervCategory)) { SPOUtility.SetMetadataField(context, item, p.ErhvervCategory, "ErhvervCategory"); item.Update(); } if (!string.IsNullOrEmpty(p.ErhvervArea)) { SPOUtility.SetMetadataField(context, item, p.ErhvervArea, "ErhvervArea"); item.Update(); } page.Save(); context.ExecuteQuery(); }
private void button2_Click_1(object sender, EventArgs e) { Microsoft.SharePoint.Client.ContentType ctDoc = ctx.Web.ContentTypes.GetById("0x0101"); ctx.Load(ctDoc); ctx.ExecuteQuery(); ContentTypeCreationInformation ctci = new ContentTypeCreationInformation(); ctci.Description = "test"; ctci.Group = "Test"; ctci.ParentContentType = ctDoc; ctci.Name = RandomString(10); ctx.Web.ContentTypes.Add(ctci); ctx.ExecuteQuery(); }
public void SetFileProperties(File file, IDictionary <string, string> properties, bool checkoutIfRequired = true) { var context = file.Context; if (properties != null && properties.Count > 0) { // Get a reference to the target list, if any // and load file item properties var parentList = file.ListItemAllFields.ParentList; context.Load(parentList); context.Load(file.ListItemAllFields); try { context.ExecuteQueryRetry(); } catch (ServerException ex) { // If this throws ServerException (does not belong to list), then shouldn't be trying to set properties) if (ex.Message != "The object specified does not belong to a list.") { throw; } } // Loop through and detect changes first, then, check out if required and apply foreach (var kvp in properties) { var propertyName = kvp.Key; var propertyValue = kvp.Value; var targetField = parentList.Fields.GetByInternalNameOrTitle(propertyName); targetField.EnsureProperties(f => f.TypeAsString, f => f.ReadOnlyField); // Changed by PaoloPia because there are fields like PublishingPageLayout // which are marked as read-only, but have to be overwritten while uploading // a publishing page file and which in reality can still be written if (!targetField.ReadOnlyField || WriteableReadOnlyFields.Contains(propertyName.ToLower())) { switch (propertyName.ToUpperInvariant()) { case "CONTENTTYPE": { Microsoft.SharePoint.Client.ContentType targetCT = parentList.GetContentTypeByName(propertyValue); context.ExecuteQueryRetry(); if (targetCT != null) { file.ListItemAllFields["ContentTypeId"] = targetCT.StringId; } else { Log.Error(Constants.LOGGING_SOURCE, "Content Type {0} does not exist in target list!", propertyValue); } break; } default: { switch (targetField.TypeAsString) { case "User": var user = parentList.ParentWeb.EnsureUser(propertyValue); context.Load(user); context.ExecuteQueryRetry(); if (user != null) { var userValue = new FieldUserValue { LookupId = user.Id, }; file.ListItemAllFields[propertyName] = userValue; } break; case "URL": var urlArray = propertyValue.Split(','); var linkValue = new FieldUrlValue(); if (urlArray.Length == 2) { linkValue.Url = urlArray[0]; linkValue.Description = urlArray[1]; } else { linkValue.Url = urlArray[0]; linkValue.Description = urlArray[0]; } file.ListItemAllFields[propertyName] = linkValue; break; case "MultiChoice": var multiChoice = JsonUtility.Deserialize <String[]>(propertyValue); file.ListItemAllFields[propertyName] = multiChoice; break; case "LookupMulti": var lookupMultiValue = JsonUtility.Deserialize <FieldLookupValue[]>(propertyValue); file.ListItemAllFields[propertyName] = lookupMultiValue; break; case "TaxonomyFieldType": var taxonomyValue = JsonUtility.Deserialize <TaxonomyFieldValue>(propertyValue); file.ListItemAllFields[propertyName] = taxonomyValue; break; case "TaxonomyFieldTypeMulti": var taxonomyValueArray = JsonUtility.Deserialize <TaxonomyFieldValue[]>(propertyValue); file.ListItemAllFields[propertyName] = taxonomyValueArray; break; default: file.ListItemAllFields[propertyName] = propertyValue; break; } break; } } } file.ListItemAllFields.Update(); context.ExecuteQueryRetry(); } } }
private void UpdateContentType(Web web, Microsoft.SharePoint.Client.ContentType existingContentType, PnPContentType templateContentType, TokenParser parser, bool isNoScriptSite = false) { var isDirty = false; if (existingContentType.Hidden != templateContentType.Hidden) { // scope.LogPropertyUpdate("Hidden"); existingContentType.Hidden = templateContentType.Hidden; isDirty = true; } if (existingContentType.ReadOnly != templateContentType.ReadOnly) { //scope.LogPropertyUpdate("ReadOnly"); existingContentType.ReadOnly = templateContentType.ReadOnly; isDirty = true; } if (existingContentType.Sealed != templateContentType.Sealed) { //scope.LogPropertyUpdate("Sealed"); existingContentType.Sealed = templateContentType.Sealed; isDirty = true; } if (templateContentType.Description != null && existingContentType.Description != parser.ParseString(templateContentType.Description)) { //scope.LogPropertyUpdate("Description"); existingContentType.Description = parser.ParseString(templateContentType.Description); isDirty = true; } if (templateContentType.DocumentTemplate != null && existingContentType.DocumentTemplate != parser.ParseString(templateContentType.DocumentTemplate)) { //scope.LogPropertyUpdate("DocumentTemplate"); existingContentType.DocumentTemplate = parser.ParseString(templateContentType.DocumentTemplate); isDirty = true; } if (existingContentType.Name != parser.ParseString(templateContentType.Name)) { //scope.LogPropertyUpdate("Name"); existingContentType.Name = parser.ParseString(templateContentType.Name); isDirty = true; // CT is being renamed, add an extra token to the tokenparser parser.AddToken(new ContentTypeIdToken(web, existingContentType.Name, existingContentType.StringId)); } if (templateContentType.Group != null && existingContentType.Group != parser.ParseString(templateContentType.Group)) { // scope.LogPropertyUpdate("Group"); existingContentType.Group = parser.ParseString(templateContentType.Group); isDirty = true; } if (!isNoScriptSite) { if (templateContentType.DisplayFormUrl != null && existingContentType.DisplayFormUrl != parser.ParseString(templateContentType.DisplayFormUrl)) { // scope.LogPropertyUpdate("DisplayFormUrl"); existingContentType.DisplayFormUrl = parser.ParseString(templateContentType.DisplayFormUrl); isDirty = true; } if (templateContentType.EditFormUrl != null && existingContentType.EditFormUrl != parser.ParseString(templateContentType.EditFormUrl)) { //scope.LogPropertyUpdate("EditFormUrl"); existingContentType.EditFormUrl = parser.ParseString(templateContentType.EditFormUrl); isDirty = true; } if (templateContentType.NewFormUrl != null && existingContentType.NewFormUrl != parser.ParseString(templateContentType.NewFormUrl)) { // scope.LogPropertyUpdate("NewFormUrl"); existingContentType.NewFormUrl = parser.ParseString(templateContentType.NewFormUrl); isDirty = true; } } else { if (!String.IsNullOrEmpty(parser.ParseString(templateContentType.DisplayFormUrl)) || !String.IsNullOrEmpty(parser.ParseString(templateContentType.EditFormUrl)) || !String.IsNullOrEmpty(parser.ParseString(templateContentType.NewFormUrl))) { // log message Debug.WriteLine("Skip custom from urls {0}", existingContentType.Name); //scope.LogWarning(CoreResources.Provisioning_ObjectHandlers_ContentTypes_SkipCustomFormUrls, existingContentType.Name); } } #if !SP2013 if (templateContentType.Name.ContainsResourceToken()) { existingContentType.NameResource.SetUserResourceValue(templateContentType.Name, parser); isDirty = true; } if (templateContentType.Description.ContainsResourceToken()) { existingContentType.DescriptionResource.SetUserResourceValue(templateContentType.Description, parser); isDirty = true; } #endif if (isDirty) { existingContentType.Update(true); web.Context.ExecuteQueryRetry(); } // Delta handling existingContentType.EnsureProperty(c => c.FieldLinks); List <Guid> targetIds = existingContentType.FieldLinks.AsEnumerable().Select(c1 => c1.Id).ToList(); List <Guid> sourceIds = templateContentType.FieldRefs.Select(c1 => c1.Id).ToList(); var fieldsNotPresentInTarget = sourceIds.Except(targetIds).ToArray(); if (fieldsNotPresentInTarget.Any()) { foreach (var fieldId in fieldsNotPresentInTarget) { var fieldRef = templateContentType.FieldRefs.Find(fr => fr.Id == fieldId); var field = web.Fields.GetById(fieldId); //scope.LogDebug(CoreResources.Provisioning_ObjectHandlers_ContentTypes_Adding_field__0__to_content_type, fieldId); web.AddFieldToContentType(existingContentType, field, fieldRef.Required, fieldRef.Hidden); } } isDirty = false; foreach (var fieldId in targetIds.Intersect(sourceIds)) { var fieldLink = existingContentType.FieldLinks.FirstOrDefault(fl => fl.Id == fieldId); var fieldRef = templateContentType.FieldRefs.Find(fr => fr.Id == fieldId); if (fieldRef != null) { //scope.LogDebug(CoreResources.Provisioning_ObjectHandlers_ContentTypes_Field__0__exists_in_content_type, fieldId); if (fieldLink.Required != fieldRef.Required) { //scope.LogPropertyUpdate("Required"); fieldLink.Required = fieldRef.Required; isDirty = true; } if (fieldLink.Hidden != fieldRef.Hidden) { //scope.LogPropertyUpdate("Hidden"); fieldLink.Hidden = fieldRef.Hidden; isDirty = true; } } } // The new CT is a DocumentSet, and the target should be, as well if (templateContentType.DocumentSetTemplate != null) { if (!Microsoft.SharePoint.Client.DocumentSet.DocumentSetTemplate.IsChildOfDocumentSetContentType(web.Context, existingContentType).Value) { //scope.LogError(CoreResources.Provisioning_ObjectHandlers_ContentTypes_InvalidDocumentSet_Update_Request, existingContentType.Id, existingContentType.Name); } else { Microsoft.SharePoint.Client.DocumentSet.DocumentSetTemplate templateToUpdate = Microsoft.SharePoint.Client.DocumentSet.DocumentSetTemplate.GetDocumentSetTemplate(web.Context, existingContentType); // TODO: Implement Delta Handling //scope.LogWarning(CoreResources.Provisioning_ObjectHandlers_ContentTypes_DocumentSet_DeltaHandling_OnHold, existingContentType.Id, existingContentType.Name); } } if (isDirty) { existingContentType.Update(true); web.Context.ExecuteQueryRetry(); } }
private Microsoft.SharePoint.Client.ContentType CreateContentType(Web web, PnPContentType templateContentType, TokenParser parser, FileConnectorBase connector, List <Microsoft.SharePoint.Client.ContentType> existingCTs = null, List <Microsoft.SharePoint.Client.Field> existingFields = null, bool isNoScriptSite = false) { var name = parser.ParseString(templateContentType.Name); var description = parser.ParseString(templateContentType.Description); var id = parser.ParseString(templateContentType.Id); var group = parser.ParseString(templateContentType.Group); var createdCT = web.CreateContentType(name, description, id, group); foreach (var fieldRef in templateContentType.FieldRefs) { var field = web.Fields.FirstOrDefault(f => f.Id == fieldRef.Id); //var field = web.Fields.GetById(fieldRef.Id); if (field != null) { web.AddFieldToContentType(createdCT, field, fieldRef.Required, fieldRef.Hidden); } } // Add new CTs parser.AddToken(new ContentTypeIdToken(web, name, id)); #if !ONPREMISES // Set resources if (templateContentType.Name.ContainsResourceToken()) { createdCT.NameResource.SetUserResourceValue(templateContentType.Name, parser); } if (templateContentType.Description.ContainsResourceToken()) { createdCT.DescriptionResource.SetUserResourceValue(templateContentType.Description, parser); } #endif //Reorder the elements so that the new created Content Type has the same order as defined in the //template. The order can be different if the new Content Type inherits from another Content Type. //In this case the new Content Type has all field of the original Content Type and missing fields //will be added at the end. To fix this issue we ordering the fields once more. createdCT.FieldLinks.Reorder(templateContentType.FieldRefs.Select(fld => parser.ParseString(fld.Name)).ToArray()); createdCT.ReadOnly = templateContentType.ReadOnly; createdCT.Hidden = templateContentType.Hidden; createdCT.Sealed = templateContentType.Sealed; if (templateContentType.DocumentSetTemplate == null) { // Only apply a document template when the contenttype is not a document set if (!string.IsNullOrEmpty(parser.ParseString(templateContentType.DocumentTemplate))) { createdCT.DocumentTemplate = parser.ParseString(templateContentType.DocumentTemplate); } } // Skipping updates of forms as we can't upload forms to noscript sites if (!isNoScriptSite) { if (!String.IsNullOrEmpty(parser.ParseString(templateContentType.NewFormUrl))) { createdCT.NewFormUrl = parser.ParseString(templateContentType.NewFormUrl); } if (!String.IsNullOrEmpty(parser.ParseString(templateContentType.EditFormUrl))) { createdCT.EditFormUrl = parser.ParseString(templateContentType.EditFormUrl); } if (!String.IsNullOrEmpty(parser.ParseString(templateContentType.DisplayFormUrl))) { createdCT.DisplayFormUrl = parser.ParseString(templateContentType.DisplayFormUrl); } } else { if (!String.IsNullOrEmpty(parser.ParseString(templateContentType.DisplayFormUrl)) || !String.IsNullOrEmpty(parser.ParseString(templateContentType.EditFormUrl)) || !String.IsNullOrEmpty(parser.ParseString(templateContentType.NewFormUrl))) { // log message //scope.LogWarning(CoreResources.Provisioning_ObjectHandlers_ContentTypes_SkipCustomFormUrls, name); } } createdCT.Update(true); web.Context.ExecuteQueryRetry(); // If the CT is a DocumentSet if (templateContentType.DocumentSetTemplate != null) { // Retrieve a reference to the DocumentSet Content Type Microsoft.SharePoint.Client.DocumentSet.DocumentSetTemplate documentSetTemplate = Microsoft.SharePoint.Client.DocumentSet.DocumentSetTemplate.GetDocumentSetTemplate(web.Context, createdCT); // Load the collections to allow for deletion scenarions web.Context.Load(documentSetTemplate, d => d.AllowedContentTypes, d => d.DefaultDocuments, d => d.SharedFields, d => d.WelcomePageFields); web.Context.ExecuteQueryRetry(); if (!String.IsNullOrEmpty(templateContentType.DocumentSetTemplate.WelcomePage)) { // TODO: Customize the WelcomePage of the DocumentSet } // Add additional content types to the set of allowed content types bool hasDefaultDocumentContentTypeInTemplate = false; foreach (String ctId in templateContentType.DocumentSetTemplate.AllowedContentTypes) { Microsoft.SharePoint.Client.ContentType ct = existingCTs.FirstOrDefault(c => c.StringId == ctId); if (ct != null) { if (ct.Id.StringValue.Equals("0x0101", StringComparison.InvariantCultureIgnoreCase)) { hasDefaultDocumentContentTypeInTemplate = true; } documentSetTemplate.AllowedContentTypes.Add(ct.Id); } } // If the default document content type (0x0101) is not in our definition then remove it if (!hasDefaultDocumentContentTypeInTemplate) { Microsoft.SharePoint.Client.ContentType ct = existingCTs.FirstOrDefault(c => c.StringId == "0x0101"); if (ct != null) { documentSetTemplate.AllowedContentTypes.Remove(ct.Id); } } if (!isNoScriptSite) { foreach (var doc in templateContentType.DocumentSetTemplate.DefaultDocuments) { Microsoft.SharePoint.Client.ContentType ct = existingCTs.FirstOrDefault(c => c.StringId == doc.ContentTypeId); if (ct != null) { using (Stream fileStream = connector.GetFileStream(doc.FileSourcePath)) { documentSetTemplate.DefaultDocuments.Add(doc.Name, ct.Id, ReadFullStream(fileStream)); } } } } else { if (templateContentType.DocumentSetTemplate.DefaultDocuments.Any()) { //scope.LogWarning(CoreResources.Provisioning_ObjectHandlers_ContentTypes_SkipDocumentSetDefaultDocuments, name); } } foreach (var sharedField in templateContentType.DocumentSetTemplate.SharedFields) { Microsoft.SharePoint.Client.Field field = existingFields.FirstOrDefault(f => f.Id == sharedField); if (field != null) { documentSetTemplate.SharedFields.Add(field); } } foreach (var welcomePageField in templateContentType.DocumentSetTemplate.WelcomePageFields) { Microsoft.SharePoint.Client.Field field = existingFields.FirstOrDefault(f => f.Id == welcomePageField); if (field != null) { documentSetTemplate.WelcomePageFields.Add(field); } } documentSetTemplate.Update(true); web.Context.ExecuteQueryRetry(); } web.Context.Load(createdCT); web.Context.ExecuteQueryRetry(); return(createdCT); }
/// <summary> /// Adds the parent /// </summary> /// <param name="sourceContentTypeCollection">ContentTypeCollection of the source SharePoint</param> /// <param name="targetContentTypeCollection">ContentTypeCollection of the target SharePoint</param> /// <param name="parentContentType">ContentType of parent</param> /// <returns>return parent ContentType or null, if there is no parent</returns> private Microsoft.SharePoint.Client.ContentType AddParent(ContentTypeCollection sourceContentTypeCollection, ContentTypeCollection targetContentTypeCollection, Microsoft.SharePoint.Client.ContentType parentContentType) { Console.WriteLine("add parent ContentType..."); Logger.AddMessage("adding parent ContentType..."); if (parentContentType == null || parentContentType.Name == null) { return(null); } try { return(this.GetContentTypeByName(targetContentTypeCollection, parentContentType.Name)); } catch (ElementsMigrationException e) { Console.WriteLine("have to create parent content type. " + e.Message); Logger.AddMessage("have to create parent ContentType"); } this.CreateContentType(sourceContentTypeCollection, targetContentTypeCollection, parentContentType); return(this.GetContentTypeByName(targetContentTypeCollection, parentContentType.Name)); }
/// <summary> /// Creates a new ContentType. /// </summary> /// <param name="sourceContentTypeCollection">ContentTypeCollection of the source SharePoint</param> /// <param name="targetContentTypeCollection">ContentTypeCollection of the target SharePoint</param> /// <param name="sourceContentType">ContentType from source with information for the new one</param> private void CreateContentType(ContentTypeCollection sourceContentTypeCollection, ContentTypeCollection targetContentTypeCollection, Microsoft.SharePoint.Client.ContentType sourceContentType) { ContentTypeCreationInformation creationObject = new ContentTypeCreationInformation(); creationObject.Description = sourceContentType.Description; creationObject.Group = sourceContentType.Group; creationObject.Name = sourceContentType.Name; //// creationObject.ParentContentType = this.AddParent(sourceContentTypeCollection, targetContentTypeCollection, sourceContentType.Parent); ContentType targetContentType = targetContentTypeCollection.Add(creationObject); try { targetContentType.DisplayFormTemplateName = sourceContentType.DisplayFormTemplateName; } catch (PropertyOrFieldNotInitializedException) { } try { targetContentType.DisplayFormUrl = sourceContentType.DisplayFormUrl; } catch (PropertyOrFieldNotInitializedException) { } try { targetContentType.DocumentTemplate = sourceContentType.DocumentTemplate; } catch (PropertyOrFieldNotInitializedException) { } try { targetContentType.EditFormTemplateName = sourceContentType.EditFormTemplateName; } catch (PropertyOrFieldNotInitializedException) { } try { targetContentType.EditFormUrl = sourceContentType.EditFormUrl; } catch (PropertyOrFieldNotInitializedException) { } try { targetContentType.Hidden = sourceContentType.Hidden; } catch (PropertyOrFieldNotInitializedException) { } try { targetContentType.NewFormTemplateName = sourceContentType.NewFormTemplateName; } catch (PropertyOrFieldNotInitializedException) { } try { targetContentType.NewFormUrl = sourceContentType.NewFormUrl; } catch (PropertyOrFieldNotInitializedException) { } try { targetContentType.ReadOnly = sourceContentType.ReadOnly; } catch (PropertyOrFieldNotInitializedException) { } try { targetContentType.Sealed = sourceContentType.Sealed; } catch (PropertyOrFieldNotInitializedException) { } try { targetContentType.Tag = sourceContentType.Tag; } catch (PropertyOrFieldNotInitializedException) { } }