public override string ConvertDbToString(Property property, PropertyType propertyType, IDataTypeService dataTypeService) { if (property.Value == null || property.Value.ToString() == "") return string.Empty; //LogHelper.Info<ArchetypeHelper>(property.Value.ToString()); var archetype = ArchetypeHelper.Instance.DeserializeJsonToArchetype(property.Value.ToString(), propertyType.DataTypeDefinitionId); foreach (var fieldset in archetype.Fieldsets) { foreach (var propDef in fieldset.Properties) { try { var dtd = dataTypeService.GetDataTypeDefinitionById(Guid.Parse(propDef.DataTypeGuid)); var propType = new PropertyType(dtd) { Alias = propDef.Alias }; var prop = new Property(propType, propDef.Value); var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias); propDef.Value = propEditor.ValueEditor.ConvertDbToString(prop, propType, dataTypeService); } catch (Exception ex) { LogHelper.Error<ArchetypePropertyValueEditor>(ex.Message, ex); } } } return archetype.SerializeForPersistence(); }
public ContentDocument(IDataTypeService service, IContent content) : this() { Id = content.Id; ContentTypeId = content.ContentTypeId; ContentType = content.ContentType.Name; Name = content.Name; ParentId = content.ParentId; Level = content.Level; Path = content.Path; foreach (var propInfo in content.PropertyTypes.OrderBy(n => n.SortOrder)) { var p = new Property { Name = propInfo.Name, Alias = propInfo.Alias, Description = propInfo.Description, Required = propInfo.Mandatory, Validation = propInfo.ValidationRegExp, DataType = service.GetDataTypeDefinitionById(propInfo.DataTypeDefinitionId).Name, Value = (content.Properties.SingleOrDefault(n => n.Alias == propInfo.Alias).Value ?? string.Empty).ToString() }; Properties.Add(p); } }
internal void ExportToFile(string absoluteFilePath, string nodeType, int id) { XElement xml = null; if (nodeType.Equals("content", StringComparison.InvariantCultureIgnoreCase)) { var content = _contentService.GetById(id); xml = Export(content); } if (nodeType.Equals("media", StringComparison.InvariantCultureIgnoreCase)) { var media = _mediaService.GetById(id); xml = Export(media); } if (nodeType.Equals("contenttype", StringComparison.InvariantCultureIgnoreCase)) { var contentType = _contentTypeService.GetContentType(id); xml = Export(contentType); } if (nodeType.Equals("mediatype", StringComparison.InvariantCultureIgnoreCase)) { var mediaType = _contentTypeService.GetMediaType(id); xml = Export(mediaType); } if (nodeType.Equals("datatype", StringComparison.InvariantCultureIgnoreCase)) { var dataType = _dataTypeService.GetDataTypeDefinitionById(id); xml = Export(dataType); } if (xml != null) { xml.Save(absoluteFilePath); } }
private IDataTypeDefinition GetDataTypeDefinition(XElement property) { var dataTypeDefinitionId = new Guid(property.Element("Definition").Value); var dataTypeDefinition = dataTypeService.GetDataTypeDefinitionById(dataTypeDefinitionId); var legacyPropertyEditorId = Guid.Empty; Guid.TryParse(property.Element("Type").Value, out legacyPropertyEditorId); var propertyEditorAlias = property.Element("Type").Value.Trim(); if (dataTypeDefinition == null) { var dataTypeDefinitions = dataTypeService.GetDataTypeDefinitionByPropertyEditorAlias(propertyEditorAlias); if (dataTypeDefinitions != null && dataTypeDefinitions.Any()) { dataTypeDefinition = dataTypeDefinitions.FirstOrDefault(); } } else { #pragma warning disable CS0618 // Type or member is obsolete if (legacyPropertyEditorId != Guid.Empty && dataTypeDefinition.ControlId != legacyPropertyEditorId) #pragma warning restore CS0618 // Type or member is obsolete { #pragma warning disable CS0618 // Type or member is obsolete var dataTypeDefinitions2 = dataTypeService.GetDataTypeDefinitionByControlId(legacyPropertyEditorId); #pragma warning restore CS0618 // Type or member is obsolete if (dataTypeDefinitions2 != null && dataTypeDefinitions2.Any()) { dataTypeDefinition = dataTypeDefinitions2.FirstOrDefault(); } } else { if (dataTypeDefinition.PropertyEditorAlias != propertyEditorAlias) { var dataTypeDefinitions3 = dataTypeService.GetDataTypeDefinitionByPropertyEditorAlias(propertyEditorAlias); if (dataTypeDefinitions3 != null && dataTypeDefinitions3.Any()) { dataTypeDefinition = dataTypeDefinitions3.FirstOrDefault(); } } } } if (dataTypeDefinition == null) { dataTypeDefinition = dataTypeService.GetDataTypeDefinitionByPropertyEditorAlias("Umbraco.NoEdit").FirstOrDefault(); } return(dataTypeDefinition); }
public string GetExportValue(int dataTypeDefinitionId, string value) { // We need to retrieve the datatype associated with the property so that we can parse the fieldset // then we will go through each item in the fieldset and if there is a mapper associated with that item's datatype // we should map the property value string archetypeConfig = _dataTypeService.GetPreValuesCollectionByDataTypeId(dataTypeDefinitionId).PreValuesAsDictionary["archetypeConfig"].Value; var config = JsonConvert.DeserializeObject <ArchetypePreValue>(archetypeConfig); var typedContent = JsonConvert.DeserializeObject <ArchetypeModel>(value); foreach (ArchetypePreValueFieldset fieldSet in config.Fieldsets) { foreach (ArchetypePreValueProperty property in fieldSet.Properties) { IDataTypeDefinition dataType = _dataTypeService.GetDataTypeDefinitionById(property.DataTypeGuid); uSyncContentMapping mapping = uSyncCoreContext.Instance.Configuration.Settings.ContentMappings.SingleOrDefault(x => x.EditorAlias == dataType.PropertyEditorAlias); if (mapping != null) { IContentMapper mapper = ContentMapperFactory.GetMapper(mapping); if (mapper != null) { typedContent.Fieldsets.AsQueryable() .SelectMany(fs => fs.Properties) .Where(p => p.Alias == property.Alias) .ForEach(pm => pm.Value = mapper.GetExportValue(dataType.Id, pm.Value.ToString())); } } } } return(typedContent.SerializeForPersistence()); }
public override string ConvertDbToString(Property property, PropertyType propertyType, IDataTypeService dataTypeService) { if (property.Value == null || property.Value.ToString().IsNullOrWhiteSpace()) { return(string.Empty); } // Something weird is happening in core whereby ConvertDbToString is getting // called loads of times on publish, forcing the property value to get converted // again, which in tern screws up the values. To get round it, we create a // dummy property copying the original properties value, this way not overwriting // the original property value allowing it to be re-converted again later var prop2 = new Property(propertyType, property.Value); try { var value = JsonConvert.DeserializeObject <VortoValue>(property.Value.ToString()); if (value.Values != null) { // If the DTD Guid isn't set (probably because someone has made the value manually) // then do a lookup and store it if (value.DtdGuid == Guid.Empty) { var vortoDtd = dataTypeService.GetDataTypeDefinitionById(propertyType.DataTypeDefinitionId); value.DtdGuid = vortoDtd.Key; } var dtd = VortoHelper.GetTargetDataTypeDefinition(value.DtdGuid); var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias); var propType = new PropertyType(dtd); var keys = value.Values.Keys.ToArray(); foreach (var key in keys) { var prop = new Property(propType, value.Values[key] == null ? null : value.Values[key].ToString()); var newValue = propEditor.ValueEditor.ConvertDbToString(prop, propType, dataTypeService); value.Values[key] = newValue; } prop2.Value = JsonConvert.SerializeObject(value); } } catch (Exception ex) { LogHelper.Error <VortoPropertyValueEditor>("Error converting DB value to String", ex); } return(base.ConvertDbToString(prop2, propertyType, dataTypeService)); }
public override SyncAttempt <IDataTypeDefinition> Import(string filePath, bool force = false) { IDataTypeDefinition item = null; var node = XElement.Load(filePath); var key = node.Attribute("Key").ValueOrDefault(Guid.Empty); if (key != Guid.Empty) { item = _dataTypeService.GetDataTypeDefinitionById(key); } return(SyncAttempt <IDataTypeDefinition> .Succeed(Path.GetFileName(filePath), item, ChangeType.Update)); }
public static PropertyType CloneUsing(this PropertyType property, IDataTypeService dataTypeService) { var dataType = dataTypeService.GetDataTypeDefinitionById(property.DataTypeDefinitionId); return(new PropertyType(dataType) { Alias = property.Alias, CreateDate = property.CreateDate, Description = property.Description, Mandatory = property.Mandatory, Name = property.Name, PropertyEditorAlias = property.PropertyEditorAlias, SortOrder = property.SortOrder, ValidationRegExp = property.ValidationRegExp }); }
private string GetValue(string value, bool exporting) { if (string.IsNullOrEmpty(value)) { return(value); } var items = JsonConvert.DeserializeObject <EmbeddedContentItem[]>(value); foreach (EmbeddedContentItem item in items) { IContentType contentType = _contentTypeService.GetContentType(item.ContentTypeAlias); if (contentType == null) { continue; } foreach (KeyValuePair <string, object> property in item.Properties.ToList()) { PropertyType propertyType = contentType.CompositionPropertyTypes.FirstOrDefault(_ => _.Alias == property.Key); if (propertyType == null) { continue; } IDataTypeDefinition dataType = _dataTypeService.GetDataTypeDefinitionById(propertyType.DataTypeDefinitionId); IContentMapper mapper = ContentMapperFactory.GetMapper(new uSyncContentMapping { EditorAlias = dataType.PropertyEditorAlias }); if (mapper != null) { string newValue; if (exporting) { newValue = mapper.GetExportValue(dataType.Id, property.Value.ToString()); } else { newValue = mapper.GetImportValue(dataType.Id, property.Value.ToString()); } item.Properties[property.Key] = newValue; } } } return(JsonConvert.SerializeObject(items, Formatting.Indented)); }
internal void UpdateContentType(IContentType contentType, PropertyType propertyType) { if (propertyType != null) { IDataTypeDefinition dataTypeDefinition = _dataTypeService.GetDataTypeDefinitionById(propertyType.DataTypeDefinitionId); PropertyGroup propertyGroup = contentType.PropertyGroups.FirstOrDefault(o => o.PropertyTypes.Contains(propertyType.Alias)); var allFollowingPropertyTypes = propertyGroup.PropertyTypes.Where(o => o != propertyType && o.SortOrder >= propertyType.SortOrder).OrderBy(o => o.SortOrder).ToList(); var sortOrderIndex = propertyType.SortOrder + 1; if (PropertyHelper.IsLocalizedProperty(propertyType.Alias) == false) { propertyType.Alias = PropertyHelper.GetAlias(propertyType.Alias, LocalizationContext.DefaultCulture.TwoLetterISOLanguageName); } foreach (ILanguage language in LocalizationContext.Languages) { string localizedAlias = PropertyHelper.GetAlias(PropertyHelper.GetNotLocalizedAlias(propertyType.Alias), language.CultureInfo.TwoLetterISOLanguageName); if ((contentType.PropertyTypeExists(localizedAlias) == false || propertyType.Alias.Equals(localizedAlias) == false) && propertyType.PropertyEditorAlias.Equals("OPTEN.UrlAlias", StringComparison.OrdinalIgnoreCase) == false) { PropertyType newPropertyType = new PropertyType(dataTypeDefinition) { Alias = localizedAlias, Name = propertyType.Name, Description = propertyType.Description, SortOrder = sortOrderIndex }; contentType.AddPropertyType(newPropertyType, propertyGroup.Name); newPropertyType.SortOrder = sortOrderIndex; // Somehow umbraco sets a sort order on adding... but not always?!? sortOrderIndex++; } } foreach (var followingPropertyType in allFollowingPropertyTypes) { propertyGroup.PropertyTypes.Single(o => followingPropertyType == o).SortOrder = sortOrderIndex; sortOrderIndex++; } } _contentTypeService.Save(contentType); }
public static int?GetPrevalueIdForIContent(IContent ic, string propertyAlias, string propertyValue) { //find the property on the content node by its alias Property prop = ic.Properties.FirstOrDefault(a => a.Alias == propertyAlias); if (prop != null) { //get data type from the property IDataTypeService dtService = ApplicationContext.Current.Services.DataTypeService; IDataTypeDefinition dtDefinition = dtService.GetDataTypeDefinitionById(prop.PropertyType.DataTypeDefinitionId); //Return property value Id return(dtService.GetPreValuesCollectionByDataTypeId(dtDefinition.Id).PreValuesAsDictionary.Where(d => d.Value.Value == propertyValue).Select(f => f.Value.Id).First()); } //Return nothing return(null); }
/// <summary> /// Fix for incompatible Umbraco versions /// </summary> /// <param name="contentType">Type of the content.</param> /// <param name="dt">The dt.</param> /// <param name="alias">The alias.</param> /// <param name="name">The name.</param> /// <param name="tabName">Name of the tab.</param> public static void AddPropertyType(IContentTypeBase contentType, DataTypeDefinition dt, string alias, string name, string tabName) { IDataTypeDefinition idt = DataTypeService.GetDataTypeDefinitionById(dt.Id); Umbraco.Core.Models.PropertyType pt = new Umbraco.Core.Models.PropertyType(idt) { Alias = alias, Name = name }; if (String.IsNullOrEmpty(tabName)) { contentType.AddPropertyType(pt); } else { contentType.AddPropertyType(pt, tabName); } }
public override XNode ConvertDbToXml(Property property, PropertyType propertyType, IDataTypeService dataTypeService) { var propertyValue = property?.Value?.ToString(); if (propertyValue == null || string.IsNullOrWhiteSpace(propertyValue)) { return(base.ConvertDbToXml(property, propertyType, dataTypeService)); } var model = JsonConvert.DeserializeObject <PropertyListValue>(propertyValue); if (model == null || model.DataTypeGuid.Equals(Guid.Empty) || model.Values == null) { return(base.ConvertDbToXml(property, propertyType, dataTypeService)); } var dtd = dataTypeService.GetDataTypeDefinitionById(model.DataTypeGuid); if (dtd == null) { return(base.ConvertDbToXml(property, propertyType, dataTypeService)); } var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias); if (propEditor == null) { return(base.ConvertDbToXml(property, propertyType, dataTypeService)); } var propType = new PropertyType(dtd, propertyType.Alias); for (var i = 0; i < model.Values.Count; i++) { var prop = new Property(propType, model.Values[i]); var newValue = propEditor.ValueEditor.ConvertDbToXml(prop, propType, dataTypeService); model.Values[i] = newValue; } return(new XElement("values", new XAttribute("dtd", model.DataTypeGuid), model.Values.Select(x => new XElement("value", x)))); }
/// <summary> /// Gets the definition. /// </summary> /// <param name="dataTypeDefinition">The data type definition.</param> /// <returns>The definition.</returns> private IDataTypeDefinition GetDefinition(DataTypeDefinition dataTypeDefinition) { IDataTypeDefinition v; if (_mappedDefinitions.TryGetValue(dataTypeDefinition, out v)) { return(v); } v = _dataTypeService.GetDataTypeDefinitionById((int)dataTypeDefinition); if (v == null) { return(null); } _mappedDefinitions.Add(dataTypeDefinition, v); return(v); }
public static bool IsDataTypeIgnoringUserStartNodes(this IDataTypeService dataTypeService, Guid key) { if (DataTypeExtensions.IsBuildInDataType(key)) { return(false); //built in ones can never be ignoring start nodes } var dataType = dataTypeService.GetDataTypeDefinitionById(key); if (dataType != null) { var preValues = dataTypeService.GetPreValuesCollectionByDataTypeId(dataType.Id); if (preValues.FormatAsDictionary().TryGetValue( Constants.DataTypes.ReservedPreValueKeys.IgnoreUserStartNodes, out var preValue)) { return(preValue.Value.InvariantEquals("1")); } } return(false); }
public override object ConvertDbToEditor(Property property, PropertyType propertyType, IDataTypeService dataTypeService) { var propertyValue = property?.Value?.ToString(); if (propertyValue == null || string.IsNullOrWhiteSpace(propertyValue)) { return(base.ConvertDbToEditor(property, propertyType, dataTypeService)); } var items = JsonConvert.DeserializeObject <TupleValueItems>(propertyValue); if (items == null || items.Count == 0) { return(base.ConvertDbToEditor(property, propertyType, dataTypeService)); } foreach (var item in items) { // Get the associated datatype definition var dtd = dataTypeService.GetDataTypeDefinitionById(item.DataTypeGuid); // TODO: Caching? [LK:2018-06-25] if (dtd == null) { continue; } // Lookup the property editor and convert the db to editor value var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias); // TODO: Caching? [LK:2018-06-25] if (propEditor == null) { continue; } var propType = new PropertyType(dtd, propertyType.Alias); var prop = new Property(propType, item.Value); item.Value = propEditor.ValueEditor.ConvertDbToEditor(prop, propType, dataTypeService); } // Return the strongly-typed object, Umbraco will handle the JSON serializing/parsing, then Angular can handle it directly return(items); }
public override XNode ConvertDbToXml(Property property, PropertyType propertyType, IDataTypeService dataTypeService) { var propertyValue = property?.Value?.ToString(); if (propertyValue == null || string.IsNullOrWhiteSpace(propertyValue)) { return(base.ConvertDbToXml(property, propertyType, dataTypeService)); } var items = JsonConvert.DeserializeObject <TupleValueItems>(propertyValue); if (items == null || items.Count == 0) { return(base.ConvertDbToXml(property, propertyType, dataTypeService)); } foreach (var item in items) { var dtd = dataTypeService.GetDataTypeDefinitionById(item.DataTypeGuid); // TODO: Caching? [LK:2018-06-25] if (dtd == null) { continue; } var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias); // TODO: Caching? [LK:2018-06-25] if (propEditor == null) { continue; } var propType = new PropertyType(dtd, propertyType.Alias); var prop = new Property(propType, item.Value); item.DataTypeUdi = dtd.GetUdi(); item.Value = propEditor.ValueEditor.ConvertDbToXml(prop, propType, dataTypeService); } return(new XElement("values", items.Select(x => new XElement("value", new XAttribute("udi", x.DataTypeUdi), x.Value)))); }
public override uSyncAction DeleteItem(Guid key, string keyString) { IDataTypeDefinition item = null; if (key != Guid.Empty) { item = _dataTypeService.GetDataTypeDefinitionById(key); } /* delete only by key * if (item == null && !string.IsNullOrEmpty(keyString)) * item = _dataTypeService.GetDataTypeDefinitionByName(keyString); */ if (item != null) { LogHelper.Info <DataTypeHandler>("Deleting datatype: {0}", () => item.Name); _dataTypeService.Delete(item); return(uSyncAction.SetAction(true, keyString, typeof(IDataTypeDefinition), ChangeType.Delete, "Removed")); } return(uSyncAction.Fail(keyString, typeof(IDataTypeDefinition), ChangeType.Delete, "Not found")); }
/// <summary> /// Exports an <see cref="IContentType"/> item to xml as an <see cref="XElement"/> /// </summary> /// <param name="dataTypeService"></param> /// <param name="contentTypeService"></param> /// <param name="contentType">Content type to export</param> /// <returns><see cref="XElement"/> containing the xml representation of the IContentType object</returns> public XElement Serialize(IDataTypeService dataTypeService, IContentTypeService contentTypeService, IContentType contentType) { var info = new XElement("Info", new XElement("Name", contentType.Name), new XElement("Alias", contentType.Alias), new XElement("Icon", contentType.Icon), new XElement("Thumbnail", contentType.Thumbnail), new XElement("Description", contentType.Description), new XElement("AllowAtRoot", contentType.AllowedAsRoot.ToString()), new XElement("IsListView", contentType.IsContainer.ToString())); var masterContentType = contentType.ContentTypeComposition.FirstOrDefault(x => x.Id == contentType.ParentId); if (masterContentType != null) { info.Add(new XElement("Master", masterContentType.Alias)); } var compositionsElement = new XElement("Compositions"); var compositions = contentType.ContentTypeComposition; foreach (var composition in compositions) { compositionsElement.Add(new XElement("Composition", composition.Alias)); } info.Add(compositionsElement); var allowedTemplates = new XElement("AllowedTemplates"); foreach (var template in contentType.AllowedTemplates) { allowedTemplates.Add(new XElement("Template", template.Alias)); } info.Add(allowedTemplates); if (contentType.DefaultTemplate != null && contentType.DefaultTemplate.Id != 0) { info.Add(new XElement("DefaultTemplate", contentType.DefaultTemplate.Alias)); } else { info.Add(new XElement("DefaultTemplate", "")); } var structure = new XElement("Structure"); foreach (var allowedType in contentType.AllowedContentTypes) { structure.Add(new XElement("DocumentType", allowedType.Alias)); } var genericProperties = new XElement("GenericProperties"); // actually, all of them foreach (var propertyType in contentType.PropertyTypes) { var definition = dataTypeService.GetDataTypeDefinitionById(propertyType.DataTypeDefinitionId); var propertyGroup = propertyType.PropertyGroupId == null // true generic property ? null : contentType.PropertyGroups.FirstOrDefault(x => x.Id == propertyType.PropertyGroupId.Value); var genericProperty = new XElement("GenericProperty", new XElement("Name", propertyType.Name), new XElement("Alias", propertyType.Alias), new XElement("Type", propertyType.PropertyEditorAlias), new XElement("Definition", definition.Key), new XElement("Tab", propertyGroup == null ? "" : propertyGroup.Name), new XElement("SortOrder", propertyType.SortOrder), new XElement("Mandatory", propertyType.Mandatory.ToString()), propertyType.ValidationRegExp != null ? new XElement("Validation", propertyType.ValidationRegExp) : null, propertyType.Description != null ? new XElement("Description", new XCData(propertyType.Description)) : null); genericProperties.Add(genericProperty); } var tabs = new XElement("Tabs"); foreach (var propertyGroup in contentType.PropertyGroups) { var tab = new XElement("Tab", new XElement("Id", propertyGroup.Id.ToString(CultureInfo.InvariantCulture)), new XElement("Caption", propertyGroup.Name), new XElement("SortOrder", propertyGroup.SortOrder)); tabs.Add(tab); } var xml = new XElement("DocumentType", info, structure, genericProperties, tabs); var folderNames = string.Empty; //don't add folders if this is a child doc type if (contentType.Level != 1 && masterContentType == null) { //get url encoded folder names var folders = contentTypeService.GetContentTypeContainers(contentType) .OrderBy(x => x.Level) .Select(x => HttpUtility.UrlEncode(x.Name)); folderNames = string.Join("/", folders.ToArray()); } if (string.IsNullOrWhiteSpace(folderNames) == false) { xml.Add(new XAttribute("Folders", folderNames)); } return(xml); }
public XElement Serialize(IDataTypeService dataTypeService, IMediaType mediaType) { var info = new XElement("Info", new XElement("Name", mediaType.Name), new XElement("Alias", mediaType.Alias), new XElement("Icon", mediaType.Icon), new XElement("Thumbnail", mediaType.Thumbnail), new XElement("Description", mediaType.Description), new XElement("AllowAtRoot", mediaType.AllowedAsRoot.ToString())); var masterContentType = mediaType.CompositionAliases().FirstOrDefault(); if (masterContentType != null) { info.Add(new XElement("Master", masterContentType)); } var structure = new XElement("Structure"); foreach (var allowedType in mediaType.AllowedContentTypes) { structure.Add(new XElement("MediaType", allowedType.Alias)); } var genericProperties = new XElement("GenericProperties"); // actually, all of them foreach (var propertyType in mediaType.PropertyTypes) { var definition = dataTypeService.GetDataTypeDefinitionById(propertyType.DataTypeDefinitionId); var propertyGroup = propertyType.PropertyGroupId == null // true generic property ? null : mediaType.PropertyGroups.FirstOrDefault(x => x.Id == propertyType.PropertyGroupId.Value); var genericProperty = new XElement("GenericProperty", new XElement("Name", propertyType.Name), new XElement("Alias", propertyType.Alias), new XElement("Type", propertyType.PropertyEditorAlias), new XElement("Definition", definition.Key), new XElement("Tab", propertyGroup == null ? "" : propertyGroup.Name), new XElement("Mandatory", propertyType.Mandatory.ToString()), new XElement("Validation", propertyType.ValidationRegExp), new XElement("Description", new XCData(propertyType.Description))); genericProperties.Add(genericProperty); } var tabs = new XElement("Tabs"); foreach (var propertyGroup in mediaType.PropertyGroups) { var tab = new XElement("Tab", new XElement("Id", propertyGroup.Id.ToString(CultureInfo.InvariantCulture)), new XElement("Caption", propertyGroup.Name), new XElement("SortOrder", propertyGroup.SortOrder)); tabs.Add(tab); } var xml = new XElement("MediaType", info, structure, genericProperties, tabs); return(xml); }
private IDataTypeDefinition GetDataTypeDefinitionByEnum(UmbracoPropertyTypeEnum propertyTypeEnum) { var result = _dataTypeService.GetDataTypeDefinitionById((int)propertyTypeEnum); return(result); }
/// <summary> /// Adds the container (listview) tab to the document /// </summary> /// <typeparam name="TPersisted"></typeparam> /// <param name="display"></param> /// <param name="entityType">This must be either 'content' or 'media'</param> /// <param name="dataTypeService"></param> /// <param name="localizedTextService"></param> internal static void AddListView <TPersisted>(TabbedContentItem <ContentPropertyDisplay, TPersisted> display, string entityType, IDataTypeService dataTypeService, ILocalizedTextService localizedTextService) where TPersisted : IContentBase { int dtdId; var customDtdName = Constants.Conventions.DataTypes.ListViewPrefix + display.ContentTypeAlias; switch (entityType) { case "content": dtdId = Constants.System.DefaultContentListViewDataTypeId; break; case "media": dtdId = Constants.System.DefaultMediaListViewDataTypeId; break; case "member": dtdId = Constants.System.DefaultMembersListViewDataTypeId; break; default: throw new ArgumentOutOfRangeException("entityType does not match a required value"); } //first try to get the custom one if there is one var dt = dataTypeService.GetDataTypeDefinitionByName(customDtdName) ?? dataTypeService.GetDataTypeDefinitionById(dtdId); if (dt == null) { throw new InvalidOperationException("No list view data type was found for this document type, ensure that the default list view data types exists and/or that your custom list view data type exists"); } var preVals = dataTypeService.GetPreValuesCollectionByDataTypeId(dt.Id); var editor = PropertyEditorResolver.Current.GetByAlias(dt.PropertyEditorAlias); if (editor == null) { throw new NullReferenceException("The property editor with alias " + dt.PropertyEditorAlias + " does not exist"); } var listViewTab = new Tab <ContentPropertyDisplay>(); listViewTab.Alias = Constants.Conventions.PropertyGroups.ListViewGroupName; listViewTab.Label = localizedTextService.Localize("content/childItems"); listViewTab.Id = display.Tabs.Count() + 1; listViewTab.IsActive = true; var listViewConfig = editor.PreValueEditor.ConvertDbToEditor(editor.DefaultPreValues, preVals); //add the entity type to the config listViewConfig["entityType"] = entityType; //Override Tab Label if tabName is provided if (listViewConfig.ContainsKey("tabName")) { var configTabName = listViewConfig["tabName"]; if (configTabName != null && string.IsNullOrWhiteSpace(configTabName.ToString()) == false) { listViewTab.Label = configTabName.ToString(); } } var listViewProperties = new List <ContentPropertyDisplay>(); listViewProperties.Add(new ContentPropertyDisplay { Alias = string.Format("{0}containerView", Constants.PropertyEditors.InternalGenericPropertiesPrefix), Label = "", Value = null, View = editor.ValueEditor.View, HideLabel = true, Config = listViewConfig }); listViewTab.Properties = listViewProperties; SetChildItemsTabPosition(display, listViewConfig, listViewTab); }
public bool Execute(string packageName, XmlNode xmlData) { IMediaService mediaService = ApplicationContext.Current.Services.MediaService; IContentService contentService = UmbracoContext.Current.Application.Services.ContentService; IContentTypeService contentTypeService = ApplicationContext.Current.Services.ContentTypeService; IFileService fileService = ApplicationContext.Current.Services.FileService; //ApplicationContext.Current.Services.DataTypeService. IDataTypeService dataTypeService = UmbracoContext.Current.Application.Services.DataTypeService; #region Create media List <int> productImageIds = new List <int>(); List <IMedia> productImages = new List <IMedia>(); try { //Create image files const string productImagesFolderName = "Product images"; string[] mediaInstallImages = Directory.GetFiles(HostingEnvironment.MapPath("~/Assets/InstallMedia")); IMedia productImagesFolder = mediaService.GetByLevel(1).FirstOrDefault(m => m.Name == productImagesFolderName); if (productImagesFolder == null) { productImagesFolder = mediaService.CreateMedia(productImagesFolderName, -1, "Folder"); mediaService.Save(productImagesFolder); } if (!productImagesFolder.Children().Any()) { foreach (string mediaInstallImage in mediaInstallImages) { string fileName = Path.GetFileName(mediaInstallImage); IMedia productImage = mediaService.CreateMedia(fileName, productImagesFolder.Id, "Image"); byte[] buffer = File.ReadAllBytes(Path.GetFullPath(mediaInstallImage)); using (MemoryStream strm = new MemoryStream(buffer)) { productImage.SetValue("umbracoFile", fileName, strm); mediaService.Save(productImage); productImages.Add(productImage); productImageIds.Add(productImage.Id); } } } else { productImageIds = productImagesFolder.Children().Select(c => c.Id).ToList(); } Directory.Delete(HostingEnvironment.MapPath("~/Assets/InstallMedia"), true); } catch (Exception ex) { LogHelper.Error <TeaCommerceStarterKitInstall>("Create media failed", ex); } #endregion #region Set up Tea Commerce Store store = null; try { //Get store or create it IReadOnlyList <Store> stores = StoreService.Instance.GetAll().ToList(); store = stores.FirstOrDefault(); if (store == null) { store = new Store("Starter Kit Store"); } store.ProductSettings.ProductVariantPropertyAlias = "variants"; store.Save(); foreach (PaymentMethod paymentMethod in PaymentMethodService.Instance.GetAll(store.Id).Where(p => p.Alias == "invoicing")) { PaymentMethodSetting setting = paymentMethod.Settings.FirstOrDefault(s => s.Key == "acceptUrl"); if (setting != null) { setting.Value = "/cart-content/confirmation/"; } paymentMethod.Save(); } } catch (Exception ex) { LogHelper.Error <TeaCommerceStarterKitInstall>("Setting up Tea Commerce failed", ex); } #endregion #region Create Templates List <ITemplate> templates = new List <ITemplate>(); try { string[] templateFiles = Directory.GetFiles(HostingEnvironment.MapPath("~/views")); foreach (string templateFile in templateFiles) { string fileName = Path.GetFileNameWithoutExtension(templateFile); string fileContent = File.ReadAllText(templateFile); templates.Add(fileService.CreateTemplateWithIdentity(fileName, fileContent)); } } catch (Exception ex) { LogHelper.Error <TeaCommerceStarterKitInstall>("Create templates failed", ex); } #endregion #region Set up content types IEnumerable <IDataTypeDefinition> allDataTypeDefinitions = dataTypeService.GetAllDataTypeDefinitions(); try { IDataTypeDefinition variantEditorDataTypeDefinition = allDataTypeDefinitions.FirstOrDefault(d => d.Name.ToLowerInvariant().Contains("variant editor")); variantEditorDataTypeDefinition.DatabaseType = DataTypeDatabaseType.Ntext; var preValDictionary = new Dictionary <string, object> { { "xpathOrNode", "{\"showXPath\": true,\"query\": \"$current/ancestor-or-self::frontpage/attributes\"}" }, { "variantDocumentType", "variant" }, { "extraListInformation", "sku,priceJMD" }, { "hideLabel", "1" }, }; var currVal = dataTypeService.GetPreValuesCollectionByDataTypeId(variantEditorDataTypeDefinition.Id); //we need to allow for the property editor to deserialize the prevalues PropertyEditor pe = PropertyEditorResolver.Current.PropertyEditors.SingleOrDefault(x => x.Alias == "TeaCommerce.VariantEditor"); var formattedVal = pe.PreValueEditor.ConvertEditorToDb(preValDictionary, currVal); dataTypeService.SaveDataTypeAndPreValues(variantEditorDataTypeDefinition, formattedVal); //dataTypeService.Save( variantEditorDataTypeDefinition ); variantEditorDataTypeDefinition = dataTypeService.GetDataTypeDefinitionById(variantEditorDataTypeDefinition.Id); } catch (Exception ex) { LogHelper.Error <TeaCommerceStarterKitInstall>("Set up content types failed", ex); } #endregion #region Create Document types ContentType attributeContentType = null, attributeGroupContentType = null, attributesContentType = null, cartStepContentType = null, cartContentType = null, variantContentType = null, productContentType = null, productListContentType = null, frontpageContentType = null; try { attributeContentType = new ContentType(-1); attributeContentType.Alias = "attribute"; attributeContentType.Name = "Attribute"; attributeContentType.Icon = "icon-t-shirt"; contentTypeService.Save(attributeContentType); attributeGroupContentType = new ContentType(-1); attributeGroupContentType.Alias = "attributeGroup"; attributeGroupContentType.Name = "Attribute group"; attributeGroupContentType.Icon = "icon-t-shirt color-orange"; attributeGroupContentType.AllowedContentTypes = new List <ContentTypeSort>() { new ContentTypeSort(attributeContentType.Id, 0) }; contentTypeService.Save(attributeGroupContentType); attributesContentType = new ContentType(-1); attributesContentType.Alias = "attributes"; attributesContentType.Name = "Attributes"; attributesContentType.Icon = "icon-t-shirt"; attributesContentType.AllowedContentTypes = new List <ContentTypeSort>() { new ContentTypeSort(attributeGroupContentType.Id, 0) }; contentTypeService.Save(attributesContentType); cartStepContentType = new ContentType(-1); cartStepContentType.Alias = "cartStep"; cartStepContentType.Name = "Cart step"; cartStepContentType.Icon = "icon-shopping-basket-alt-2 color-orange"; cartStepContentType.AllowedTemplates = templates.Where(t => t.Alias.ToLowerInvariant().Contains("cartstep") && !t.Alias.ToLowerInvariant().Contains("master")); contentTypeService.Save(cartStepContentType); cartContentType = new ContentType(-1); cartContentType.Alias = "cart"; cartContentType.Name = "Cart"; cartContentType.Icon = "icon-shopping-basket-alt-2"; cartContentType.AllowedContentTypes = new List <ContentTypeSort>() { new ContentTypeSort(cartStepContentType.Id, 0) }; cartContentType.AllowedTemplates = templates.Where(t => t.Alias.ToLowerInvariant().Contains("cartstep1")); contentTypeService.Save(cartContentType); variantContentType = CreateVariantContentType(allDataTypeDefinitions, contentTypeService); productContentType = CreateProductContentType(allDataTypeDefinitions, contentTypeService, templates); productListContentType = new ContentType(-1); productListContentType.Alias = "productList"; productListContentType.Name = "Product list"; productListContentType.Icon = "icon-tags"; productListContentType.AllowedContentTypes = new List <ContentTypeSort>() { new ContentTypeSort(productContentType.Id, 0) }; productListContentType.AllowedTemplates = templates.Where(t => t.Alias.ToLowerInvariant().Contains("productlist")); contentTypeService.Save(productListContentType); frontpageContentType = CreateFrontpageContentType(allDataTypeDefinitions, contentTypeService, templates); } catch (Exception ex) { LogHelper.Error <TeaCommerceStarterKitInstall>("Create templates failed", ex); } #endregion #region Create content try { Content frontPageContent = new Content("Home", -1, frontpageContentType); frontPageContent.Template = frontpageContentType.AllowedTemplates.First(); frontPageContent.SetValue("slider", string.Join(",", productImages.Select(p => "umb://media/" + p.Key.ToString().Replace("-", "")))); frontPageContent.SetValue("store", store.Id); contentService.SaveAndPublishWithStatus(frontPageContent, raiseEvents: false); #region Create Cart Content cartContent = new Content("Cart content", frontPageContent.Id, cartContentType); cartContent.Template = cartContentType.AllowedTemplates.First(); contentService.SaveAndPublishWithStatus(cartContent, raiseEvents: false); Content informationContent = new Content("Information", cartContent.Id, cartStepContentType); informationContent.Template = templates.First(t => t.Alias.ToLowerInvariant() == "cartstep2"); contentService.SaveAndPublishWithStatus(informationContent, raiseEvents: false); Content shippingPaymentContent = new Content("Shipping/Payment", cartContent.Id, cartStepContentType); shippingPaymentContent.Template = templates.First(t => t.Alias.ToLowerInvariant() == "cartstep3"); contentService.SaveAndPublishWithStatus(shippingPaymentContent, raiseEvents: false); Content acceptContent = new Content("Accept", cartContent.Id, cartStepContentType); acceptContent.Template = templates.First(t => t.Alias.ToLowerInvariant() == "cartstep4"); contentService.SaveAndPublishWithStatus(acceptContent, raiseEvents: false); Content paymentContent = new Content("Payment", cartContent.Id, cartStepContentType); contentService.SaveAndPublishWithStatus(paymentContent); Content confirmationContent = new Content("Confirmation", cartContent.Id, cartStepContentType); confirmationContent.Template = templates.First(t => t.Alias.ToLowerInvariant() == "cartstep6"); contentService.SaveAndPublishWithStatus(confirmationContent, raiseEvents: false); #endregion #region Create Attributes Content variantAttributesContent = new Content("Variant attributes", frontPageContent.Id, attributesContentType); contentService.SaveAndPublishWithStatus(variantAttributesContent, raiseEvents: false); Content colorContent = new Content("Color", variantAttributesContent.Id, attributeGroupContentType); contentService.SaveAndPublishWithStatus(colorContent, raiseEvents: false); Content sizeContent = new Content("Size", variantAttributesContent.Id, attributeGroupContentType); contentService.SaveAndPublishWithStatus(sizeContent, raiseEvents: false); Content blackContent = new Content("Black", colorContent.Id, attributeContentType); contentService.SaveAndPublishWithStatus(blackContent, raiseEvents: false); Content whiteContent = new Content("White", colorContent.Id, attributeContentType); contentService.SaveAndPublishWithStatus(whiteContent, raiseEvents: false); Content blueContent = new Content("Blue", colorContent.Id, attributeContentType); contentService.SaveAndPublishWithStatus(blueContent, raiseEvents: false); Content largeContent = new Content("Large", sizeContent.Id, attributeContentType); contentService.SaveAndPublishWithStatus(largeContent, raiseEvents: false); Content mediumContent = new Content("Medium", sizeContent.Id, attributeContentType); contentService.SaveAndPublishWithStatus(mediumContent, raiseEvents: false); Content smallContent = new Content("Small", sizeContent.Id, attributeContentType); contentService.SaveAndPublishWithStatus(smallContent, raiseEvents: false); #endregion #region Create Products Content expensiveYachtsContent = new Content("Expensive Yachts", frontPageContent.Id, productListContentType); expensiveYachtsContent.Template = productListContentType.AllowedTemplates.First(); contentService.SaveAndPublishWithStatus(expensiveYachtsContent, raiseEvents: false); Content veryAxpensiveYachtsContent = new Content("Very expensive Yachts", frontPageContent.Id, productListContentType); veryAxpensiveYachtsContent.Template = productListContentType.AllowedTemplates.First(); contentService.SaveAndPublishWithStatus(veryAxpensiveYachtsContent, raiseEvents: false); Content summerYachtContent = new Content("Summer Yacht", expensiveYachtsContent, productContentType); summerYachtContent.Template = productContentType.AllowedTemplates.First(); summerYachtContent.SetValue("image", "umb://media/" + productImages[0].Key.ToString().Replace("-", "")); summerYachtContent.SetValue("productName", "Summer Yacht"); summerYachtContent.SetValue("sku", "p0001"); summerYachtContent.SetValue("priceJMD", "500"); summerYachtContent.SetValue("description", "<p>This is the product description.</p>"); summerYachtContent.SetValue("variants", "{\"variants\": [],\"variantGroupsOpen\":{}}"); contentService.SaveAndPublishWithStatus(summerYachtContent, raiseEvents: false); Content yachtWithSailsContent = new Content("Yacht with sails", expensiveYachtsContent, productContentType); yachtWithSailsContent.Template = productContentType.AllowedTemplates.First(); yachtWithSailsContent.SetValue("image", "umb://media/" + productImages[1].Key.ToString().Replace("-", "")); yachtWithSailsContent.SetValue("productName", "Yacht with sails"); yachtWithSailsContent.SetValue("sku", "p0002"); yachtWithSailsContent.SetValue("priceJMD", "1000"); yachtWithSailsContent.SetValue("description", "<p>This is the product description.</p>"); yachtWithSailsContent.SetValue("variants", "{\"variants\": [],\"variantGroupsOpen\":{}}"); contentService.SaveAndPublishWithStatus(yachtWithSailsContent, raiseEvents: false); Content motorDrivenYachtContent = new Content("Motor driven Yacht", veryAxpensiveYachtsContent, productContentType); motorDrivenYachtContent.Template = productContentType.AllowedTemplates.First(); motorDrivenYachtContent.SetValue("image", "umb://media/" + productImages[2].Key.ToString().Replace("-", "")); motorDrivenYachtContent.SetValue("productName", "Motor driven Yacht"); motorDrivenYachtContent.SetValue("sku", "p0003"); motorDrivenYachtContent.SetValue("priceJMD", "1500"); motorDrivenYachtContent.SetValue("description", "<p>This is the product description.</p>"); motorDrivenYachtContent.SetValue("variants", "{\"variants\": [],\"variantGroupsOpen\":{}}"); contentService.SaveAndPublishWithStatus(motorDrivenYachtContent, raiseEvents: false); Content oneMastedYachtContent = new Content("One masted yacht", veryAxpensiveYachtsContent, productContentType); oneMastedYachtContent.Template = productContentType.AllowedTemplates.First(); oneMastedYachtContent.SetValue("image", "umb://media/" + productImages[3].Key.ToString().Replace("-", "")); oneMastedYachtContent.SetValue("productName", "One masted yacht"); oneMastedYachtContent.SetValue("sku", "p0004"); oneMastedYachtContent.SetValue("priceJMD", "2000"); oneMastedYachtContent.SetValue("description", "<p>This is the product description.</p>"); oneMastedYachtContent.SetValue("variants", "{\"variants\": [],\"variantGroupsOpen\":{}}"); contentService.SaveAndPublishWithStatus(oneMastedYachtContent, raiseEvents: false); #endregion frontPageContent.SetValue("featuredProducts", string.Join(",", new List <string> { "umb://document/" + summerYachtContent.Key.ToString().Replace("-", ""), "umb://document/" + yachtWithSailsContent.Key.ToString().Replace("-", ""), "umb://document/" + motorDrivenYachtContent.Key.ToString().Replace("-", ""), "umb://document/" + oneMastedYachtContent.Key.ToString().Replace("-", ""), })); contentService.SaveAndPublishWithStatus(frontPageContent, raiseEvents: false); } catch (Exception ex) { LogHelper.Error <TeaCommerceStarterKitInstall>("Create content failed", ex); } #endregion return(true); }
public override object ConvertDbToEditor(Property property, PropertyType propertyType, IDataTypeService dataTypeService) { var propertyValue = property?.Value?.ToString(); if (propertyValue.IsNullOrWhiteSpace()) { return(string.Empty); } // Something weird is happening in core whereby ConvertDbToEditor is getting // called loads of times on publish, forcing the property value to get converted // again, which in tern screws up the values. To get round it, we create a // dummy property copying the original properties value, this way not overwriting // the original property value allowing it to be re-converted again later var prop2 = new Property(propertyType, property.Value); try { VortoValue value = null; // Does the value look like JSON and does it look like a vorto value? if (propertyValue.DetectIsJson() && propertyValue.IndexOf("dtdGuid") != -1) { value = JsonConvert.DeserializeObject <VortoValue>(propertyValue); } else { // Doesn't look like a vorto value so we are going to assume it got converted // from a normal prop editor to a vorto editor, so lets construct a VortoValue var dataTypeDef = dataTypeService.GetDataTypeDefinitionById(propertyType.DataTypeDefinitionId); string primaryLanguage = null; // Look for primary language in prevalues var preValues = dataTypeService.GetPreValuesCollectionByDataTypeId(dataTypeDef.Id)?.PreValuesAsDictionary; if (preValues != null) { // We need to store the current value inder a language key so try and find the best key to store it under primaryLanguage = preValues.ContainsKey("primaryLanguage") && !preValues["primaryLanguage"].Value.IsNullOrWhiteSpace() ? preValues["primaryLanguage"].Value : null; } // No explicit primary language set, so try and work out the best match if (primaryLanguage.IsNullOrWhiteSpace()) { var currentCulture = Thread.CurrentThread.CurrentUICulture.Name; var languages = umbraco.cms.businesslogic.language.Language.GetAllAsList() .Select(x => x.CultureAlias) .ToList(); // Check for an exact culture match primaryLanguage = languages.FirstOrDefault(x => x == currentCulture); // Check for a close match if (primaryLanguage.IsNullOrWhiteSpace()) { primaryLanguage = languages.FirstOrDefault(x => x.Contains(currentCulture)); } // Check for a close match if (primaryLanguage.IsNullOrWhiteSpace()) { primaryLanguage = languages.FirstOrDefault(x => currentCulture.Contains(x)); } // Couldn't find a good enough match, just select the first language if (primaryLanguage.IsNullOrWhiteSpace()) { primaryLanguage = languages.FirstOrDefault(); } } if (!primaryLanguage.IsNullOrWhiteSpace()) { value = new VortoValue { DtdGuid = dataTypeDef.Key, Values = new Dictionary <string, object> { { primaryLanguage, property.Value } } }; } } if (value?.Values != null) { var dtd = VortoHelper.GetTargetDataTypeDefinition(value.DtdGuid); if (dtd != null) { var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias); var propType = new PropertyType(dtd); var keys = value.Values.Keys.ToArray(); foreach (var key in keys) { var prop = new Property(propType, value.Values[key] == null ? null : value.Values[key].ToString()); var newValue = propEditor.ValueEditor.ConvertDbToEditor(prop, propType, dataTypeService); value.Values[key] = (newValue == null) ? null : JToken.FromObject(newValue); } prop2.Value = JsonConvert.SerializeObject(value); } else { LogHelper.Error <VortoPropertyValueEditor>($"Unabled to locate target DTD for source DTD ${value.DtdGuid}", null); } } } catch (Exception ex) { LogHelper.Error <VortoPropertyValueEditor>("Error converting DB value to Editor", ex); } return(base.ConvertDbToEditor(prop2, propertyType, dataTypeService)); }
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); } } }
/// <summary> /// Get a DataTypeDefinition for a Datatype by its DataTypeDefinitionId /// </summary> /// <param name="DtDefinitionId"></param> /// <returns></returns> public static DataTypeDefinition GetDataTypeDefinition(int DtDefinitionId) { return((DataTypeDefinition)umbDataTypeService.GetDataTypeDefinitionById(DtDefinitionId)); }
public IEnumerable <ILinkedEntity> GetLinkedEntities(object propertyValue) { if (propertyValue == null) { return(Enumerable.Empty <ILinkedEntity>()); } var entities = new List <ILinkedEntity>(); var contentTypes = new Dictionary <string, IContentType>(); var dataTypes = new Dictionary <int, IDataTypeDefinition>(); try { var items = JsonConvert.DeserializeObject <EmbeddedContentItem[]>(propertyValue.ToString()); foreach (EmbeddedContentItem item in items) { if (false == contentTypes.TryGetValue(item.ContentTypeAlias, out IContentType contentType)) { contentTypes[item.ContentTypeAlias] = contentType = _contentTypeService.GetContentType(item.ContentTypeAlias); } if (contentType == null) { continue; } foreach (PropertyType propertyType in contentType.PropertyTypes) { if (false == item.Properties.TryGetValue(propertyType.Alias, out object value)) { continue; } if (false == dataTypes.TryGetValue(propertyType.DataTypeDefinitionId, out IDataTypeDefinition dataTypeDefinition)) { dataTypes[propertyType.DataTypeDefinitionId] = dataTypeDefinition = _dataTypeService.GetDataTypeDefinitionById(propertyType.DataTypeDefinitionId); } if (dataTypeDefinition == null) { continue; } IPropertyParser parser = PropertyParserResolver.Current.Parsers.FirstOrDefault(x => x.IsParserFor(dataTypeDefinition)); if (parser != null) { entities.AddRange(parser.GetLinkedEntities(value)); } } } } catch (Exception exception) { _logger.Error <EmbeddedContentParser>("Error parsing embedded content", exception); } return(entities); }
private IDataTypeDefinition CreateNestedContentDataType(IDataTypeDefinition archetypeDataType) { var name = archetypeDataType.Name + " (NC)"; var alias = Alias(archetypeDataType.Name + "nc"); // TODO Umbraco method of creating aliases var existingDataType = _dataTypeService.GetDataTypeDefinitionByName(name); if (existingDataType != null) { return(existingDataType); } var preValue = _dataTypeService.GetPreValuesByDataTypeId(archetypeDataType.Id).FirstOrDefault(); var archetypePreValue = JsonConvert.DeserializeObject <ArchetypePreValue>(preValue); var contentType = new ContentType(-1); contentType.Name = name; contentType.Alias = alias; foreach (var fieldset in archetypePreValue.Fieldsets) { var propertyGroup = new PropertyGroup(); propertyGroup.Name = "Content"; foreach (var prop in fieldset.Properties) { var definition = _dataTypeService.GetDataTypeDefinitionById(prop.DataTypeGuid); propertyGroup.PropertyTypes.Add(new PropertyType(definition) { Name = prop.Label, Alias = prop.Alias, Mandatory = prop.Required, Description = prop.HelpText }); } contentType.PropertyGroups.Add(propertyGroup); } _contentTypeService.Save(contentType); var dataType = new DataTypeDefinition(NestedContentAlias); dataType.Name = contentType.Name; var preValues = new Dictionary <string, PreValue>(); preValues.Add("contentTypes", new PreValue(JsonConvert.SerializeObject( new NestedContentPreValue[] { new NestedContentPreValue { NcAlias = contentType.Alias, NcTabAlias = "Content", NameTemplate = archetypePreValue.Fieldsets.First().LabelTemplate } }, new JsonSerializerSettings { ContractResolver = _contractResolver }) )); preValues.Add("minItems", new PreValue("0")); preValues.Add("maxItems", new PreValue("0")); preValues.Add("confirmDeletes", new PreValue("0")); preValues.Add("showIcons", new PreValue("0")); preValues.Add("hideLabel", new PreValue(archetypePreValue.HidePropertyLabel ? "1" : "0")); _dataTypeService.SaveDataTypeAndPreValues(dataType, preValues); return(dataType); }
public static void ImportRemoveMissingProps(this IContentType item, XElement node) { // don't do this if the setting is set to false if (!uSyncSettings.docTypeSettings.DeletePropertyValues) { return; } List <string> propertiesToRemove = new List <string>(); Dictionary <string, string> propertiesToMove = new Dictionary <string, string>(); // go through the properties in the item foreach (var property in item.PropertyTypes) { // is this property in the xml ? XElement propertyNode = node.Element("GenericProperties") .Elements("GenericProperty") .Where(x => x.Element("Alias").Value == property.Alias) .SingleOrDefault(); if (propertyNode == null) { LogHelper.Info <uSync>("Removing {0} from {1}", () => property.Alias, () => item.Name); propertiesToRemove.Add(property.Alias); } else { // at this point we write our properties over those // in the db - because the import doesn't do this // for existing items. LogHelper.Debug <uSync>("Updating prop {0} for {1}", () => property.Alias, () => item.Alias); var legacyEditorId = Guid.Empty; var editorAlias = string.Empty; Guid.TryParse(propertyNode.Element("Type").Value, out legacyEditorId); if (legacyEditorId == Guid.Empty) { // new style id...? } var dataTypeDefinitionId = new Guid(propertyNode.Element("Definition").Value); IDataTypeService _dataTypeService = ApplicationContext.Current.Services.DataTypeService; IDataTypeDefinition dataTypeDefinition = null; try { dataTypeDefinition = _dataTypeService.GetDataTypeDefinitionById(dataTypeDefinitionId); if (dataTypeDefinition == null) { editorAlias = propertyNode.Element("Type").Value; // try to match on guid as alias is not unique dataTypeDefinition = _dataTypeService.GetDataTypeDefinitionByPropertyEditorAlias(editorAlias).Any(x => x.Key == dataTypeDefinitionId) ? _dataTypeService.GetDataTypeDefinitionByPropertyEditorAlias(editorAlias).First(x => x.Key == dataTypeDefinitionId) : _dataTypeService.GetDataTypeDefinitionByPropertyEditorAlias(editorAlias).FirstOrDefault(); } if (dataTypeDefinition != null && dataTypeDefinition.Key == dataTypeDefinitionId) { // all good, we are here.. } else { // we need to do even more looking... var dataTypeDefinitions = _dataTypeService.GetDataTypeDefinitionByControlId(legacyEditorId); if (dataTypeDefinition != null && dataTypeDefinitions.Any()) { dataTypeDefinition = dataTypeDefinitions.First(); } } } catch (Exception ex) { // getDataTypeDefinition can throw exceptions - when you have issues with legacy ids' // so we capture them, so we can carry on. LogHelper.Info <SyncDocType>("Error looking for the datatype {0}, you might be missing a package?", () => dataTypeDefinitionId); } if (dataTypeDefinition != null) { // now we set it in the DB // property.DataTypeDefinitionId = dataTypeDefinition.Id; // we can set both the id and alias, but we can't directly change the // underling database type, not sure if you can to be honest. if (property.DataTypeDefinitionId != dataTypeDefinition.Id) { LogHelper.Info <SyncDocType>("Updating the datatype Definition"); property.DataTypeDefinitionId = dataTypeDefinition.Id; property.PropertyEditorAlias = dataTypeDefinition.PropertyEditorAlias; } // TODO: make changes to the datatype import/export properly. } property.Name = propertyNode.Element("Name").Value; property.Description = propertyNode.Element("Description").Value; property.Mandatory = propertyNode.Element("Mandatory").Value.ToLowerInvariant().Equals("true"); property.ValidationRegExp = propertyNode.Element("Validation").Value; XElement sortOrder = propertyNode.Element("SortOrder"); if (sortOrder != null) { property.SortOrder = int.Parse(sortOrder.Value); } var tab = propertyNode.Element("Tab").Value; if (!string.IsNullOrEmpty(tab)) { var propGroup = item.PropertyGroups.First(x => x.Name == tab); if (!propGroup.PropertyTypes.Any(x => x.Alias == property.Alias)) { // if it's not in this prop group - we can move it it into it LogHelper.Info <uSync>("Moving {0} in {1} to {2}", () => property.Alias, () => item.Name, () => tab); propertiesToMove.Add(property.Alias, tab); } } } } foreach (string alias in propertiesToRemove) { LogHelper.Debug <uSync>("Removing {0}", () => alias); item.RemovePropertyType(alias); // if slow - save after every remove // on big sites, this increases the chances of your SQL server completing the operation in time... // /* * if (uSyncSettings.SlowUpdate) * { * LogHelper.Debug<uSync>("SlowMode: saving now {0}", () => item.Name); * _contentTypeService.Save(item); * } */ } foreach (KeyValuePair <string, string> movePair in propertiesToMove) { item.MovePropertyType(movePair.Key, movePair.Value); } if (propertiesToRemove.Count > 0 || propertiesToMove.Count > 0) { LogHelper.Debug <uSync>("Saving {0}", () => item.Name); _contentTypeService.Save(item); } }
/// <summary> /// Exports an <see cref="IContentType"/> item to xml as an <see cref="XElement"/> /// </summary> /// <param name="dataTypeService"></param> /// <param name="contentType">Content type to export</param> /// <returns><see cref="XElement"/> containing the xml representation of the IContentType object</returns> public XElement Serialize(IDataTypeService dataTypeService, IContentType contentType) { var info = new XElement("Info", new XElement("Name", contentType.Name), new XElement("Alias", contentType.Alias), new XElement("Icon", contentType.Icon), new XElement("Thumbnail", contentType.Thumbnail), new XElement("Description", contentType.Description), new XElement("AllowAtRoot", contentType.AllowedAsRoot.ToString()), new XElement("IsListView", contentType.IsContainer.ToString())); var masterContentType = contentType.ContentTypeComposition.FirstOrDefault(x => x.Id == contentType.ParentId); if (masterContentType != null) { info.Add(new XElement("Master", masterContentType.Alias)); } var compositionsElement = new XElement("Compositions"); var compositions = contentType.ContentTypeComposition; foreach (var composition in compositions) { compositionsElement.Add(new XElement("Composition", composition.Alias)); } info.Add(compositionsElement); var allowedTemplates = new XElement("AllowedTemplates"); foreach (var template in contentType.AllowedTemplates) { allowedTemplates.Add(new XElement("Template", template.Alias)); } info.Add(allowedTemplates); if (contentType.DefaultTemplate != null && contentType.DefaultTemplate.Id != 0) { info.Add(new XElement("DefaultTemplate", contentType.DefaultTemplate.Alias)); } else { info.Add(new XElement("DefaultTemplate", "")); } var structure = new XElement("Structure"); foreach (var allowedType in contentType.AllowedContentTypes) { structure.Add(new XElement("DocumentType", allowedType.Alias)); } var genericProperties = new XElement("GenericProperties"); foreach (var propertyType in contentType.PropertyTypes) { var definition = dataTypeService.GetDataTypeDefinitionById(propertyType.DataTypeDefinitionId); var propertyGroup = propertyType.PropertyGroupId == null ? null : contentType.PropertyGroups.FirstOrDefault(x => x.Id == propertyType.PropertyGroupId.Value); var genericProperty = new XElement("GenericProperty", new XElement("Name", propertyType.Name), new XElement("Alias", propertyType.Alias), new XElement("Type", propertyType.PropertyEditorAlias), new XElement("Definition", definition.Key), new XElement("Tab", propertyGroup == null ? "" : propertyGroup.Name), new XElement("Mandatory", propertyType.Mandatory.ToString()), new XElement("Validation", propertyType.ValidationRegExp), new XElement("Description", new XCData(propertyType.Description))); genericProperties.Add(genericProperty); } var tabs = new XElement("Tabs"); foreach (var propertyGroup in contentType.PropertyGroups) { var tab = new XElement("Tab", new XElement("Id", propertyGroup.Id.ToString(CultureInfo.InvariantCulture)), new XElement("Caption", propertyGroup.Name), new XElement("SortOrder", propertyGroup.SortOrder)); tabs.Add(tab); } return(new XElement("DocumentType", info, structure, genericProperties, tabs)); }
public IMemberType AddDialogueMemberType() { #region DataType Ids //-49 Umbraco.TrueFalse //-51 Umbraco.Integer //-87 Umbraco.TinyMCEv3 //-88 Umbraco.Textbox //-89 Umbraco.TextboxMultiple //-90 Umbraco.UploadField //-92 Umbraco.NoEdit //-36 Umbraco.DateTime //-37 Umbraco.ColorPickerAlias //-38 Umbraco.FolderBrowser //-39 Umbraco.DropDownMultiple //-40 Umbraco.RadioButtonList //-41 Umbraco.Date //-42 Umbraco.DropDown //-43 Umbraco.CheckBoxList //1034 Umbraco.ContentPickerAlias //1035 Umbraco.MediaPicker //1036 Umbraco.MemberPicker //1040 Umbraco.RelatedLinks //1041 Umbraco.Tags //1045 Umbraco.MultipleMediaPicker //1077 Apt.PartialPicker //1089 Umbraco.ImageCropper //1092 Umbraco.TinyMCEv3 //1103 Our.Umbraco.FilePicker //1104 Umbraco.MemberGroupPicker //1105 Apt.CssPicker //1128 Dialogue.ThemePicker //1132 Dialogue.Permissions //1147 Umbraco.MultipleTextstring #endregion var label = _dataTypeService.GetDataTypeDefinitionById(-92); var upload = _dataTypeService.GetDataTypeDefinitionById(-90); var textstring = _dataTypeService.GetDataTypeDefinitionById(-88); var textboxMultiple = _dataTypeService.GetDataTypeDefinitionById(-89); var truefalse = _dataTypeService.GetDataTypeDefinitionById(-49); var numeric = _dataTypeService.GetDataTypeDefinitionById(-51); var datetime = _dataTypeService.GetDataTypeDefinitionById(-36); // Profile, Settings, Social Tokens // Create the member Type var memType = new MemberType(-1) { Alias = AppConstants.MemberTypeAlias, Name = "Dialogue Member" }; // Create the Profile group/tab var profileGroup = new PropertyGroup { Name = "Profile", }; profileGroup.PropertyTypes.Add(new PropertyType(label) { Alias = "email", Name = "Email", SortOrder = 0, Description = "This is a bit rubbish, but it's the only way to get the email from the new member service at the current time" }); profileGroup.PropertyTypes.Add(new PropertyType(upload) { Alias = "avatar", Name = "Avatar", SortOrder = 0, Description = "" }); profileGroup.PropertyTypes.Add(new PropertyType(textstring) { Alias = "website", Name = "Website", SortOrder = 0, Description = "" }); profileGroup.PropertyTypes.Add(new PropertyType(textstring) { Alias = "twitter", Name = "Twitter", SortOrder = 0, Description = "" }); profileGroup.PropertyTypes.Add(new PropertyType(textboxMultiple) { Alias = "signature", Name = "Signature", SortOrder = 0, Description = "" }); profileGroup.PropertyTypes.Add(new PropertyType(datetime) { Alias = "lastActiveDate", Name = "Last Active Date", SortOrder = 0, Description = "" }); memType.PropertyGroups.Add(profileGroup); // Create the Settings group/tab var settingsGroup = new PropertyGroup { Name = "Settings", }; settingsGroup.PropertyTypes.Add(new PropertyType(truefalse) { Alias = "canEditOtherMembers", Name = "Can Edit Other Members", SortOrder = 0, Description = "Enable this and the user can edit other members posts, their profiles and ban members (Usually use in conjunction with moderate permissions)." }); settingsGroup.PropertyTypes.Add(new PropertyType(truefalse) { Alias = "disableEmailNotifications", Name = "Disable Email Notifications", SortOrder = 0, Description = "" }); settingsGroup.PropertyTypes.Add(new PropertyType(truefalse) { Alias = "disablePosting", Name = "Disable Posting", SortOrder = 0, Description = "" }); settingsGroup.PropertyTypes.Add(new PropertyType(truefalse) { Alias = "disablePrivateMessages", Name = "Disable Private Messages", SortOrder = 0, Description = "" }); settingsGroup.PropertyTypes.Add(new PropertyType(truefalse) { Alias = "disableFileUploads", Name = "Disable File Uploads", SortOrder = 0, Description = "" }); settingsGroup.PropertyTypes.Add(new PropertyType(numeric) { Alias = "postCount", Name = "Post Count", SortOrder = 0, Description = "The users post count. This is kept like this to help reduce SQL queries and improve performance of the forum" }); memType.PropertyGroups.Add(settingsGroup); // Create the Settings group/tab var socialGroup = new PropertyGroup { Name = "Social Tokens", }; socialGroup.PropertyTypes.Add(new PropertyType(textstring) { Name = "Facebook Access Token", Alias = "facebookAccessToken", SortOrder = 0, Description = "" }); socialGroup.PropertyTypes.Add(new PropertyType(textstring) { Name = "Facebook Id", Alias = "facebookId", SortOrder = 0, Description = "" }); socialGroup.PropertyTypes.Add(new PropertyType(textstring) { Name = "Google Access Token", Alias = "googleAccessToken", SortOrder = 0, Description = "" }); socialGroup.PropertyTypes.Add(new PropertyType(textstring) { Name = "Google Id", Alias = "googleId", SortOrder = 0, Description = "" }); memType.PropertyGroups.Add(socialGroup); // Add Slug memType.AddPropertyType(new PropertyType(textstring) { Name = "Slug", Alias = "slug", SortOrder = 0, Description = "This is what we use to look up the member in the front end" }); _memberTypeService.Save(memType); return(memType); }