private void FilterContentTypeProperties(IContentTypeBase contentType, IEnumerable <string> exclude) { //remove all properties based on the exclusion list foreach (var remove in exclude) { if (contentType.PropertyTypeExists(remove)) { contentType.RemovePropertyType(remove); } } }
private void RemoveProperties(IContentTypeBase item, XElement properties) { logger.Debug(serializerType, "RemoveProperties"); List <string> removals = new List <string>(); var nodes = properties.Elements("GenericProperty") .Where(x => x.Element("Key") != null) .Select(x => new { Key = x.Element("Key").ValueOrDefault(Guid.Empty), Alias = x.Element("Alias").ValueOrDefault(string.Empty) }) .ToDictionary(k => k.Key, a => a.Alias); foreach (var property in item.PropertyTypes) { if (nodes.ContainsKey(property.Key)) { continue; } if (nodes.Any(x => x.Value == property.Alias)) { continue; } removals.Add(property.Alias); } if (removals.Any()) { foreach (var alias in removals) { // if you remove something with lots of // content this can timeout (still? - need to check on v8) logger.Debug(serializerType, "Removing {0}", alias); item.RemovePropertyType(alias); } } }
internal void DeserializeProperties(IContentTypeBase item, XElement node) { List <string> propertiesToRemove = new List <string>(); Dictionary <string, string> propertiesToMove = new Dictionary <string, string>(); Dictionary <PropertyGroup, string> tabsToBlank = new Dictionary <PropertyGroup, string>(); var genericPropertyNode = node.Element("GenericProperties"); if (genericPropertyNode != null) { // add or update properties foreach (var propertyNode in genericPropertyNode.Elements("GenericProperty")) { bool newProperty = false; var property = default(PropertyType); var propKey = propertyNode.Element("Key").ValueOrDefault(Guid.Empty); if (propKey != Guid.Empty) { property = item.PropertyTypes.SingleOrDefault(x => x.Key == propKey); } var alias = propertyNode.Element("Alias").ValueOrDefault(string.Empty); if (property == null) { // look up via alias? property = item.PropertyTypes.SingleOrDefault(x => x.Alias == alias); } // we need to get element stuff now before we can create or update var defGuid = propertyNode.Element("Definition").ValueOrDefault(Guid.Empty); var dataTypeDefinition = _dataTypeService.GetDataTypeDefinitionById(defGuid); if (dataTypeDefinition == null) { var propEditorAlias = propertyNode.Element("Type").ValueOrDefault(string.Empty); if (!string.IsNullOrEmpty(propEditorAlias)) { dataTypeDefinition = _dataTypeService .GetDataTypeDefinitionByPropertyEditorAlias(propEditorAlias) .FirstOrDefault(); } } if (dataTypeDefinition == null) { LogHelper.Warn <Events>("Failed to get Definition for property type"); continue; } if (property == null) { // create the property LogHelper.Debug <Events>("Creating new Property: {0} {1}", () => item.Alias, () => alias); property = new PropertyType(dataTypeDefinition, alias); newProperty = true; } if (property != null) { LogHelper.Debug <Events>("Updating Property :{0} {1}", () => item.Alias, () => alias); var key = propertyNode.Element("Key").ValueOrDefault(Guid.Empty); if (key != Guid.Empty) { LogHelper.Debug <Events>("Setting Key :{0}", () => key); property.Key = key; } LogHelper.Debug <Events>("Item Key :{0}", () => property.Key); // update settings. property.Name = propertyNode.Element("Name").ValueOrDefault("unnamed" + DateTime.Now.ToString("yyyyMMdd_HHmmss")); if (property.Alias != alias) { property.Alias = alias; } if (propertyNode.Element("Description") != null) { property.Description = propertyNode.Element("Description").Value; } if (propertyNode.Element("Mandatory") != null) { property.Mandatory = propertyNode.Element("Mandatory").Value.ToLowerInvariant().Equals("true"); } if (propertyNode.Element("Validation") != null) { property.ValidationRegExp = propertyNode.Element("Validation").Value; } if (propertyNode.Element("SortOrder") != null) { property.SortOrder = int.Parse(propertyNode.Element("SortOrder").Value); } if (propertyNode.Element("Type") != null) { LogHelper.Debug <Events>("Setting Property Type : {0}", () => propertyNode.Element("Type").Value); property.PropertyEditorAlias = propertyNode.Element("Type").Value; } if (property.DataTypeDefinitionId != dataTypeDefinition.Id) { property.DataTypeDefinitionId = dataTypeDefinition.Id; } var tabName = propertyNode.Element("Tab").ValueOrDefault(string.Empty); if (_itemType == "MemberType") { ((IMemberType)item).SetMemberCanEditProperty(alias, propertyNode.Element("CanEdit").ValueOrDefault(false)); ((IMemberType)item).SetMemberCanViewProperty(alias, propertyNode.Element("CanView").ValueOrDefault(false)); } if (!newProperty) { if (!string.IsNullOrEmpty(tabName)) { var propGroup = item.PropertyGroups.FirstOrDefault(x => x.Name == tabName); if (propGroup != null) { if (!propGroup.PropertyTypes.Any(x => x.Alias == property.Alias)) { // this tab currently doesn't contain this property, to we have to // move it (later) propertiesToMove.Add(property.Alias, tabName); } } } else { // this property isn't in a tab (now!) if (!newProperty) { var existingTab = item.PropertyGroups.FirstOrDefault(x => x.PropertyTypes.Contains(property)); if (existingTab != null) { // this item is now not in a tab (when it was) // so we have to remove it from tabs (later) tabsToBlank.Add(existingTab, property.Alias); } } } } else { // new propert needs to be added to content type.. if (string.IsNullOrEmpty(tabName)) { item.AddPropertyType(property); } else { item.AddPropertyType(property, tabName); } // setting the key before here doesn't seem to work for new types. if (key != Guid.Empty) { property.Key = key; } } } } // end foreach property } // end generic properties // look at what properties we need to remove. var propertyNodes = node.Elements("GenericProperties").Elements("GenericProperty"); foreach (var property in item.PropertyTypes) { XElement propertyNode = propertyNodes .FirstOrDefault(x => x.Element("key") != null && x.Element("Key").Value == property.Key.ToString()); if (propertyNode == null) { LogHelper.Debug <uSync.Core.Events>("Looking up property type by alias {0}", () => property.Alias); propertyNode = propertyNodes .SingleOrDefault(x => x.Element("Alias").Value == property.Alias); } if (propertyNode == null) { propertiesToRemove.Add(property.Alias); } } // now we have gone through all the properties, we can do the moves and removes from the groups if (propertiesToMove.Any()) { foreach (var move in propertiesToMove) { LogHelper.Debug <Events>("Moving Property: {0} {1}", () => move.Key, () => move.Value); item.MovePropertyType(move.Key, move.Value); } } if (propertiesToRemove.Any()) { // removing properties can cause timeouts on installs with lots of content... foreach (var delete in propertiesToRemove) { LogHelper.Debug <Events>("Removing Property: {0}", () => delete); item.RemovePropertyType(delete); } } if (tabsToBlank.Any()) { foreach (var blank in tabsToBlank) { // there might be a bug here, we need to do some cheking of if this is // possible with the public api // blank.Key.PropertyTypes.Remove(blank.Value); } } }
private void Prune(IContentTypeBase contentType, Type documentClrType, PropertyInfo[] tabProperties, IEnumerable<PropertyInfo> propertiesOfRoot) { bool modified = false; var propertiesToKeep = propertiesOfRoot.Where(x => { var attr = x.DeclaringType.GetCodeFirstAttribute<CodeFirstCommonBaseAttribute>(false); return x.DeclaringType == documentClrType || attr != null; }).Select(x => x.GetCodeFirstAttribute<ContentPropertyAttribute>().Alias) .Union(tabProperties.Where(x => { var attr = x.DeclaringType.GetCodeFirstAttribute<CodeFirstCommonBaseAttribute>(false); return x.DeclaringType == documentClrType || attr != null; }).SelectMany(x => { return x.PropertyType.GetProperties().Where(y => { return (y.DeclaringType == x.PropertyType || y.DeclaringType.GetCodeFirstAttribute<CodeFirstCommonBaseAttribute>(false) != null) && y.GetCodeFirstAttribute<ContentPropertyAttribute>() != null; }).Select(y => { var attr = y.GetCodeFirstAttribute<ContentPropertyAttribute>(); var tabAttr = x.GetCodeFirstAttribute<ContentTabAttribute>(); return attr.AddTabAliasToPropertyAlias ? attr.Alias + "_" + tabAttr.Name.Replace(" ", "_") : attr.Alias; }); })).ToList(); propertiesToKeep.AddRange(documentClrType.GetCustomAttributes<DoNotRemovePropertyAttribute>(true).Select(x => x.PropertyAlias)); //loop through all the properties on the ContentType to see if they should be removed. var existingUmbracoProperties = contentType.PropertyTypes.ToArray(); int length = contentType.PropertyTypes.Count(); for (int i = 0; i < length; i++) { if (!propertiesToKeep.Any(x => x.Equals(existingUmbracoProperties[i].Alias, StringComparison.InvariantCultureIgnoreCase))) { if (contentType.PropertyTypeExists(existingUmbracoProperties[i].Alias)) { modified = true; //remove the property contentType.RemovePropertyType(existingUmbracoProperties[i].Alias); var alias = existingUmbracoProperties[i].Alias; var children = GetChildren(contentType); //TODO is this needed? I reckon it shouldn't be RemovePropertyFromChildren(alias, children); } } } if (modified) { contentType.ResetDirtyProperties(false); Save(contentType); } }
/// <summary> /// Loop through all properties and remove existing ones if necessary /// </summary> /// <param name="contentType"></param> /// <param name="type"></param> /// <param name="dataTypeService"></param> private static void VerifyProperties(IContentTypeBase contentType, Type type, IDataTypeService dataTypeService) { var properties = type.GetProperties().Where(x => x.GetCustomAttribute<UmbracoTabAttribute>() != null).ToArray(); List<string> propertiesThatShouldExist = new List<string>(); foreach (var propertyTab in properties) { var tabAttribute = propertyTab.GetCustomAttribute<UmbracoTabAttribute>(); if (!contentType.PropertyGroups.Any(x => x.Name == tabAttribute.Name)) { contentType.AddPropertyGroup(tabAttribute.Name); } propertiesThatShouldExist.AddRange(VerifyAllPropertiesOnTab(propertyTab, contentType, tabAttribute.Name, dataTypeService)); } var propertiesOfRoot = type.GetProperties().Where(x => x.GetCustomAttribute<UmbracoPropertyAttribute>() != null); foreach (var item in propertiesOfRoot) { //TODO: check for correct name propertiesThatShouldExist.Add(VerifyExistingProperty(contentType, null, dataTypeService, item, true)); } //loop through all the properties on the ContentType to see if they should be removed; var existingUmbracoProperties = contentType.PropertyTypes.ToArray(); int length = contentType.PropertyTypes.Count(); for (int i = 0; i < length; i++) { if (!propertiesThatShouldExist.Contains(existingUmbracoProperties[i].Alias)) { //remove the property contentType.RemovePropertyType(existingUmbracoProperties[i].Alias); } } }