/// <summary> /// Convert ContentPickerAlias data types with the given name /// /// Converts the content from ids to UDIs /// Swaps the data type alias itself over /// </summary> /// <param name="name"></param> public void Convert(string name) { var oldDataTypeDefinition = _dataTypeService.GetDataTypeDefinitionByName(name); oldDataTypeDefinition.Name = oldDataTypeDefinition.Name + " (Obsolete)"; _dataTypeService.Save(oldDataTypeDefinition); var oldPreValues = _dataTypeService.GetPreValuesCollectionByDataTypeId(oldDataTypeDefinition.Id); var newDataTypeDefinition = new DataTypeDefinition(_newDataTypeAlias); newDataTypeDefinition.Name = name; _dataTypeService.SaveDataTypeAndPreValues(newDataTypeDefinition, _preValueConversion == null ? new Dictionary <string, PreValue>() : _preValueConversion(oldPreValues.PreValuesAsDictionary)); var allContentTypes = _contentTypeService.GetAllContentTypes(); var contentTypesToConvert = allContentTypes .Where(c => c.PropertyTypes.Any(a => a.DataTypeDefinitionId == oldDataTypeDefinition.Id) || c.CompositionPropertyTypes.Any(a => a.DataTypeDefinitionId == oldDataTypeDefinition.Id)) .ToArray(); AddReplacementDataType(contentTypesToConvert, oldDataTypeDefinition, newDataTypeDefinition); ConvertContent(contentTypesToConvert, oldDataTypeDefinition); DeleteOldDataType(oldDataTypeDefinition); }
private void AddToPanelPickerAllowedEditors() { var panelPickerDataType = _dataTypeService.GetDataTypeDefinitionByName(PanelsInstallationConstants.DataTypeNames.PanelPicker); var preValuesDictionary = _dataTypeService.GetPreValuesCollectionByDataTypeId(panelPickerDataType.Id).PreValuesAsDictionary; AddAllowedEditor(preValuesDictionary, TableEditor); _dataTypeService.SavePreValues(panelPickerDataType, preValuesDictionary); }
private void AddToDefaultGridAllowedEditors() { var defaultGridDataType = _dataTypeService.GetDataTypeDefinitionByName(CoreInstallationConstants.DataTypeNames.ContentGrid); var preValuesDictionary = _dataTypeService.GetPreValuesCollectionByDataTypeId(defaultGridDataType.Id).PreValuesAsDictionary; GridInstallationHelper.AddAllowedEditorForOneColumnRow(preValuesDictionary, UserListAlias); _dataTypeService.SaveDataTypeAndPreValues(defaultGridDataType, preValuesDictionary); }
public PreValueCollection GetDataTypeOptions(string dataTypeName) { var dataType = _dataTypeService.GetDataTypeDefinitionByName(dataTypeName); if (dataType == null) { return(null); } return(_dataTypeService.GetPreValuesCollectionByDataTypeId(dataType.Id)); }
internal DataTypeInfo ResolveDataType(FluidityEditorFieldConfig fieldConfig) { var dtdKey = !fieldConfig.DataTypeName.IsNullOrWhiteSpace() ? fieldConfig.DataTypeName : fieldConfig.GetOrCalculateDefinititionId().ToString(); return(_cacheProvider.GetCacheItem <DataTypeInfo>($"fluidity_datatypeinfo_{dtdKey}", () => { IDataTypeDefinition dataTypeDefinition = null; if (!fieldConfig.DataTypeName.IsNullOrWhiteSpace()) { dataTypeDefinition = _dataTypeService.GetDataTypeDefinitionByName(fieldConfig.DataTypeName); } if (dataTypeDefinition == null) { var dataTypeId = fieldConfig.GetOrCalculateDefinititionId(); dataTypeDefinition = _dataTypeService.GetDataTypeDefinitionById(dataTypeId); } var preValues = _dataTypeService.GetPreValuesCollectionByDataTypeId(dataTypeDefinition.Id); var propEditor = _propertyEditorResolver.GetByAlias(dataTypeDefinition.PropertyEditorAlias); return new DataTypeInfo(dataTypeDefinition, propEditor, preValues); })); }
public static int?GetPrevalueIdForIMember(IMember im, string propertyAlias, string propertyValue) { if (propertyValue == "") { //Return nothing return(null); } else { //find the property on the content node by its alias Property prop = im.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); } }
internal DataTypeInfo ResolveDataType(FluidityEditorFieldConfig fieldConfig, bool isReadOnly = false) { var dtdKey = !fieldConfig.DataTypeName.IsNullOrWhiteSpace() ? fieldConfig.DataTypeName : fieldConfig.GetOrCalculateDefinititionId().ToString(); dtdKey += $"_{isReadOnly}"; return(_cacheProvider.GetCacheItem <DataTypeInfo>($"fluidity_datatypeinfo_{dtdKey}", () => { IDataTypeDefinition dataTypeDefinition = null; if (!fieldConfig.DataTypeName.IsNullOrWhiteSpace()) { dataTypeDefinition = _dataTypeService.GetDataTypeDefinitionByName(fieldConfig.DataTypeName); } if (dataTypeDefinition == null) { var dataTypeId = fieldConfig.DataTypeId == 0 && isReadOnly ? -92 // If readonly and no explicit datatype defined, default to label : fieldConfig.GetOrCalculateDefinititionId(); dataTypeDefinition = _dataTypeService.GetDataTypeDefinitionById(dataTypeId); } var preValues = _dataTypeService.GetPreValuesCollectionByDataTypeId(dataTypeDefinition.Id); var propEditor = _propertyEditorResolver.GetByAlias(dataTypeDefinition.PropertyEditorAlias); return new DataTypeInfo(dataTypeDefinition, propEditor, preValues); })); }
private string GetMailChimpApiKeyValue() { var dataType = _dataTypeService.GetDataTypeDefinitionByPropertyEditorAlias("SiteOcean.MailChimp.ListPicker").First(); var prevalues = _dataTypeService.GetPreValuesCollectionByDataTypeId(dataType.Id); return(prevalues.PreValuesAsDictionary["apiKey"].Value); }
/// <summary> /// Exports an <see cref="IDataTypeDefinition"/> item to xml as an <see cref="XElement"/> /// </summary> /// <param name="dataTypeService"></param> /// <param name="dataTypeDefinition">IDataTypeDefinition type to export</param> /// <returns><see cref="XElement"/> containing the xml representation of the IDataTypeDefinition object</returns> public XElement Serialize(IDataTypeService dataTypeService, IDataTypeDefinition dataTypeDefinition) { var prevalues = new XElement("PreValues"); var prevalueList = dataTypeService.GetPreValuesCollectionByDataTypeId(dataTypeDefinition.Id) .FormatAsDictionary(); var sort = 0; foreach (var pv in prevalueList) { var prevalue = new XElement("PreValue"); prevalue.Add(new XAttribute("Id", pv.Value.Id)); prevalue.Add(new XAttribute("Value", pv.Value.Value ?? "")); prevalue.Add(new XAttribute("Alias", pv.Key)); prevalue.Add(new XAttribute("SortOrder", sort)); prevalues.Add(prevalue); sort++; } var xml = new XElement("DataType", prevalues); xml.Add(new XAttribute("Name", dataTypeDefinition.Name)); //The 'ID' when exporting is actually the property editor alias (in pre v7 it was the IDataType GUID id) xml.Add(new XAttribute("Id", dataTypeDefinition.PropertyEditorAlias)); xml.Add(new XAttribute("Definition", dataTypeDefinition.Key)); xml.Add(new XAttribute("DatabaseType", dataTypeDefinition.DatabaseType.ToString())); return(xml); }
private void Synchronize(IDataTypeDefinition[] dataTypes, DataType model) { var dataType = _dataTypeFinder.Find(model, dataTypes).SingleOrDefault(); if (dataType == null) { // Create new data type. dataType = CreateDataType(model); _dataTypeService.SaveDataTypeAndPreValues(dataType, GetPreValues(model)); } else { // Update the data type and its pre-values. _dataTypeService.Save(UpdateDataTypeDefinition(dataType, model)); var existingPreValues = _dataTypeService.GetPreValuesCollectionByDataTypeId(dataType.Id).FormatAsDictionary(); var preValuesToSave = existingPreValues.Any() ? GetUpdatedPreValues(existingPreValues, model.PreValues) : GetPreValues(model); _dataTypeService.SavePreValues(dataType.Id, preValuesToSave); } // We get the data type once more to refresh it after saving it. dataType = _dataTypeService.GetDataTypeDefinitionByName(dataType.Name); // Set/update tracking. SetDataTypeId(model, dataType); }
private bool IsMultipleDataType(int dataTypeId, string propertyEditorAlias) { // GetPreValuesCollectionByDataTypeId is cached at repository level; // still, the collection is deep-cloned so this is kinda expensive, // better to cache here + trigger refresh in DataTypeCacheRefresher return(Storages.GetOrAdd(dataTypeId, id => { var preVals = _dataTypeService.GetPreValuesCollectionByDataTypeId(id).PreValuesAsDictionary; if (preVals.ContainsKey("multiPicker")) { var preValue = preVals .FirstOrDefault(x => string.Equals(x.Key, "multiPicker", StringComparison.InvariantCultureIgnoreCase)) .Value; return preValue != null && preValue.Value.TryConvertTo <bool>().Result; } //in some odd cases, the pre-values in the db won't exist but their default pre-values contain this key so check there var propertyEditor = PropertyEditorResolver.Current.GetByAlias(propertyEditorAlias); if (propertyEditor != null) { var preValue = propertyEditor.DefaultPreValues .FirstOrDefault(x => string.Equals(x.Key, "multiPicker", StringComparison.InvariantCultureIgnoreCase)) .Value; return preValue != null && preValue.TryConvertTo <bool>().Result; } return false; })); }
private IDictionary <string, PreValue> MergePreValuesWithExisting(DataTypeRegistration dataTypeRegistration, IDictionary <string, PreValue> codeFirstPreValues, ref bool modified) { bool preValuesChanged = false; IDictionary <string, PreValue> preValues = new Dictionary <string, PreValue>(); //Ensure that pre-value IDs stay the same (correlate by alias) if (dataTypeRegistration.Definition.Id != -1) { var existingValues = _service.GetPreValuesCollectionByDataTypeId(dataTypeRegistration.Definition.Id); if (existingValues.IsDictionaryBased) { var dict = existingValues.PreValuesAsDictionary; foreach (var value in codeFirstPreValues) { var match = dict.Where(x => x.Key == value.Key); if (match.Count() == 0) { preValues.Add(value); preValuesChanged = true; } else { var existing = match.First(); preValuesChanged = preValuesChanged || value.Value.Value != existing.Value.Value || (value.Value.SortOrder != 0 && value.Value.SortOrder != existing.Value.SortOrder); preValues.Add(existing.Key, new PreValue(existing.Value.Id, value.Value.Value, value.Value.SortOrder)); } } } } modified = modified || preValuesChanged; return(preValues); }
private static bool IsMultipleDataType(int dataTypeId) { IDataTypeService dataTypeService = ApplicationContext.Current.Services.DataTypeService; IDictionary <string, PreValue> preValues = dataTypeService .GetPreValuesCollectionByDataTypeId(dataTypeId) .PreValuesAsDictionary; PreValue maxNumberOfItems; if (preValues.TryGetValue("maxNumberOfItems", out maxNumberOfItems) && int.TryParse(maxNumberOfItems.Value, out _maxNumberOfItems)) { PreValue versionPreValue; Version version; // for backwards compatibility, always return true if version // is less than 2.0.0 if (preValues.TryGetValue("version", out versionPreValue) && Version.TryParse(versionPreValue.Value, out version) && version >= new Version(2, 0, 0)) { return(_maxNumberOfItems != 1); } } return(true); }
private EmbeddedContentConfig GetConfig(int dataTypeId) { using (_profilingLogger.DebugDuration <EmbeddedContentValueConverter>($"GetConfig({dataTypeId})")) { PreValueCollection preValues = _dataTypeService.GetPreValuesCollectionByDataTypeId(dataTypeId); PreValue configPreValue = preValues.PreValuesAsDictionary["embeddedContentConfig"]; return(JsonConvert.DeserializeObject <EmbeddedContentConfig>(configPreValue.Value)); } }
/// <summary> /// Updates the prevalues for the property editor /// </summary> /// <param name="prevalue">The new value</param> /// <param name="alias">The prevalue to update</param> public void UpdatePrevalueForEditor(string prevalue, string alias) { IDataTypeDefinition datatype = _dataTypeService.GetDataTypeDefinitionByPropertyEditorAlias(Alias).First(); IDictionary <string, PreValue> prevalues = _dataTypeService.GetPreValuesCollectionByDataTypeId(datatype.Id).PreValuesAsDictionary; prevalues[alias] = new PreValue(prevalue); _dataTypeService.SaveDataTypeAndPreValues(datatype, prevalues); }
public void Convert(string name) { var nestedContentDataType = _dataTypeService.GetDataTypeDefinitionByName(name); var preValues = _dataTypeService.GetPreValuesCollectionByDataTypeId(nestedContentDataType.Id).FormatAsDictionary(); nestedContentDataType.PropertyEditorAlias = "Umbraco.NestedContent"; _dataTypeService.SaveDataTypeAndPreValues(nestedContentDataType, preValues); }
protected void ConvertInnerContentEditorToDb(JObject item, IDataTypeService dataTypeService) { if (item == null) { return; } var contentType = InnerContentHelper.GetContentTypeFromItem(item); if (contentType == null) { return; } var propValueKeys = item.Properties().Select(x => x.Name).ToArray(); foreach (var propKey in propValueKeys) { var propType = contentType.CompositionPropertyTypes.FirstOrDefault(x => x.Alias == propKey); if (propType == null) { if (IsSystemPropertyKey(propKey) == false) { // Property missing so just delete the value item[propKey] = null; } } else { // Fetch the property types prevalue var propPreValues = dataTypeService.GetPreValuesCollectionByDataTypeId(propType.DataTypeDefinitionId); // Lookup the property editor var propEditor = PropertyEditorResolver.Current.GetByAlias(propType.PropertyEditorAlias); // Create a fake content property data object var contentPropData = new ContentPropertyData( item[propKey], propPreValues, new Dictionary <string, object>()); // Get the property editor to do it's conversion var newValue = propEditor.ValueEditor.ConvertEditorToDb(contentPropData, item[propKey]); // Store the value back item[propKey] = (newValue == null) ? null : JToken.FromObject(newValue); } } // Process children var childrenProp = item.Properties().FirstOrDefault(x => x.Name == "children"); if (childrenProp != null) { ConvertInnerContentEditorToDb(childrenProp.Value.Value <JArray>(), dataTypeService); } }
internal static void MergePreValues(JObject currentValue, IDataTypeService dataTypeService, int dataTypeId) { //need to lookup the pre-values for this data type //TODO: Change all singleton access to use ctor injection in v8!!! var dt = dataTypeService.GetPreValuesCollectionByDataTypeId(dataTypeId); if (dt != null && dt.IsDictionaryBased && dt.PreValuesAsDictionary.ContainsKey("crops")) { var cropsString = dt.PreValuesAsDictionary["crops"].Value; JArray preValueCrops; try { preValueCrops = JsonConvert.DeserializeObject <JArray>(cropsString); } catch (Exception ex) { LogHelper.Error <ImageCropperValueConverter>("Could not parse the string " + cropsString + " to a json object", ex); return; } //now we need to merge the crop values - the alias + width + height comes from pre-configured pre-values, // however, each crop can store it's own coordinates JArray existingCropsArray; if (currentValue["crops"] != null) { existingCropsArray = (JArray)currentValue["crops"]; } else { currentValue["crops"] = existingCropsArray = new JArray(); } foreach (var preValueCrop in preValueCrops.Where(x => x.HasValues)) { var found = existingCropsArray.FirstOrDefault(x => { if (x.HasValues && x["alias"] != null) { return(x["alias"].Value <string>() == preValueCrop["alias"].Value <string>()); } return(false); }); if (found != null) { found["width"] = preValueCrop["width"]; found["height"] = preValueCrop["height"]; } else { existingCropsArray.Add(preValueCrop); } } } }
/// <summary> /// Validates the data for each property /// </summary> /// <returns></returns> /// <remarks> /// All property data validation goes into the modelstate with a prefix of "Properties" /// </remarks> protected bool ValidatePropertyData(IDictionary <string, object> postedProperties, TPersisted content) { var hasError = false; if (postedProperties != null) { foreach (var p in postedProperties) { var propertyType = content.PropertyTypes.Single(x => x.Alias == p.Key); var editor = PropertyEditorResolver.Current.GetByAlias(propertyType.PropertyEditorAlias); if (editor == null) { var message = string.Format("The property editor with alias: {0} was not found for property with id {1}", propertyType.PropertyEditorAlias, content.Properties[p.Key].Id); LogHelper.Warn <ContentPropertyValidator <TPersisted> >(message); continue; } //get the posted value for this property var postedValue = p.Value; //get the pre-values for this property var preValues = _dataTypeService.GetPreValuesCollectionByDataTypeId(propertyType.DataTypeDefinitionId); foreach (var result in editor.ValueEditor.Validators.SelectMany(v => v.Validate(postedValue, preValues, editor))) { _modelState.AddPropertyError(result, p.Key); } //Now we need to validate the property based on the PropertyType validation (i.e. regex and required) // NOTE: These will become legacy once we have pre-value overrides. if (propertyType.Mandatory) { foreach (var result in editor.ValueEditor.RequiredValidator.Validate(postedValue, "", preValues, editor)) { hasError = true; _modelState.AddPropertyError(result, p.Key); } } if (propertyType.ValidationRegExp.IsNullOrWhiteSpace() == false) { foreach (var result in editor.ValueEditor.RegexValidator.Validate(postedValue, propertyType.ValidationRegExp, preValues, editor)) { hasError = true; _modelState.AddPropertyError(result, p.Key); } } } } return(!hasError); }
protected IDictionary <string, PreValue> GetPreValues(Property property) { var preVals = _dataTypeService.GetPreValuesCollectionByDataTypeId(property.PropertyType.DataTypeDefinitionId); if (preVals != null) { var dictionary = preVals.FormatAsDictionary(); return(dictionary); } return(null); }
public static PreValueCollection GetPreValue(IDataTypeService service, int dataTypeDefinitionId) { try { return(service.GetPreValuesCollectionByDataTypeId(dataTypeDefinitionId)); } catch { return(null); } }
public static int?getPrevalueId(string dataTypeName, string dataTypeValue) { // Instantiate datatype service IDataTypeService dtService = ApplicationContext.Current.Services.DataTypeService; // Obtain prevalue collection from datatypes IDataTypeDefinition dtDefinition = dtService.GetDataTypeDefinitionByName(dataTypeName); PreValueCollection pvCollection = dtService.GetPreValuesCollectionByDataTypeId(dtDefinition.Id); return(pvCollection.PreValuesAsDictionary.FirstOrDefault(preValue => string.Equals(preValue.Value.Value, dataTypeValue)).Value.Id); }
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()); }
private IEnumerable <int> NestedContentAliasWithContentType(string alias) { var nestedContents = _dataTypeService.GetDataTypeDefinitionByPropertyEditorAlias(NestedContentAlias); foreach (var dataType in nestedContents) { var preValues = _dataTypeService.GetPreValuesCollectionByDataTypeId(dataType.Id).FormatAsDictionary(); var contentTypes = JsonConvert.DeserializeObject <NestedContentPreValue[]>(preValues["contentTypes"].Value, _serializerSettings); if (contentTypes.Any(n => n.NcAlias.Equals(alias, StringComparison.CurrentCultureIgnoreCase))) { yield return(dataType.Id); } } }
private void UpdateDatatypePreValues(IDataTypeService dataTypeService, string dataTypeName, string assemblyFullNamePreValue, string enumFullNamePreValue) { var dataType = dataTypeService.GetDataTypeDefinitionByName(dataTypeName); if (dataType != null) { var preValues = dataTypeService.GetPreValuesCollectionByDataTypeId(dataType.Id); var dictionary = preValues.FormatAsDictionary(); dictionary[FolderConstants.PreValueAssemblyAlias].Value = assemblyFullNamePreValue; dictionary[FolderConstants.PreValueEnumAlias].Value = enumFullNamePreValue; dataTypeService.SaveDataTypeAndPreValues(dataType, dictionary); } }
/// <summary> /// Discovers if the slider is set to range mode. /// </summary> /// <param name="dataTypeId"> /// The data type id. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> private bool IsRangeDataType(int dataTypeId) { // GetPreValuesCollectionByDataTypeId is cached at repository level; // still, the collection is deep-cloned so this is kinda expensive, // better to cache here + trigger refresh in DataTypeCacheRefresher return(Storages.GetOrAdd(dataTypeId, id => { var preValue = _dataTypeService.GetPreValuesCollectionByDataTypeId(id) .PreValuesAsDictionary .FirstOrDefault(x => string.Equals(x.Key, "enableRange", StringComparison.InvariantCultureIgnoreCase)) .Value; return preValue != null && preValue.Value.TryConvertTo <bool>().Result; })); }
private List <PreValue> GetPreValues(int dataTypeId) { List <Umbraco.Core.Models.PreValue> result = new List <Umbraco.Core.Models.PreValue>(); var preValues = _service.GetPreValuesCollectionByDataTypeId(dataTypeId); if (preValues.IsDictionaryBased) { result.AddRange(preValues.PreValuesAsDictionary.Values.OrderBy(x => x.SortOrder)); } else { result.AddRange(preValues.PreValuesAsArray.OrderBy(x => x.SortOrder)); } return(result); }
private bool IsMultipleDataType(int dataTypeId, out int maxNumber) { // GetPreValuesCollectionByDataTypeId is cached at repository level; // still, the collection is deep-cloned so this is kinda expensive, // better to cache here + trigger refresh in DataTypeCacheRefresher maxNumber = Storages.GetOrAdd(dataTypeId, id => { var preValues = _dataTypeService.GetPreValuesCollectionByDataTypeId(id).PreValuesAsDictionary; return(preValues.TryGetValue("maxNumber", out var maxNumberPreValue) ? maxNumberPreValue.Value.TryConvertTo <int>().Result : 0); }); return(maxNumber != 1); }
/// <summary> /// Exports an <see cref="IDataTypeDefinition"/> item to xml as an <see cref="XElement"/> /// </summary> /// <param name="dataTypeService"></param> /// <param name="dataTypeDefinition">IDataTypeDefinition type to export</param> /// <returns><see cref="XElement"/> containing the xml representation of the IDataTypeDefinition object</returns> public XElement Serialize(IDataTypeService dataTypeService, IDataTypeDefinition dataTypeDefinition) { var prevalues = new XElement("PreValues"); var prevalueList = dataTypeService.GetPreValuesCollectionByDataTypeId(dataTypeDefinition.Id) .FormatAsDictionary(); var sort = 0; foreach (var pv in prevalueList) { var prevalue = new XElement("PreValue"); prevalue.Add(new XAttribute("Id", pv.Value.Id)); prevalue.Add(new XAttribute("Value", pv.Value.Value ?? "")); prevalue.Add(new XAttribute("Alias", pv.Key)); prevalue.Add(new XAttribute("SortOrder", sort)); prevalues.Add(prevalue); sort++; } var xml = new XElement("DataType", prevalues); xml.Add(new XAttribute("Name", dataTypeDefinition.Name)); //The 'ID' when exporting is actually the property editor alias (in pre v7 it was the IDataType GUID id) xml.Add(new XAttribute("Id", dataTypeDefinition.PropertyEditorAlias)); xml.Add(new XAttribute("Definition", dataTypeDefinition.Key)); xml.Add(new XAttribute("DatabaseType", dataTypeDefinition.DatabaseType.ToString())); var folderNames = string.Empty; if (dataTypeDefinition.Level != 1) { //get url encoded folder names var folders = dataTypeService.GetContainers(dataTypeDefinition) .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); }
protected virtual bool IsMultiPicker(int dataTypeId) { var preValues = _dataTypeService.GetPreValuesCollectionByDataTypeId(dataTypeId); if (preValues.PreValuesAsDictionary.TryGetValue("multiPicker", out var preValue)) { return(preValue.Value.TryConvertTo <bool>().Result); } if (preValues.PreValuesAsDictionary.TryGetValue("maxNumber", out preValue) || preValues.PreValuesAsDictionary.TryGetValue("maxItems", out preValue)) { var attempt = preValue.Value.TryConvertTo <int>(); return(false == attempt.Success || attempt.Result != 1); } return(false); }