public override object ConvertEditorToDb(ContentPropertyData editorValue, object currentValue) { if (editorValue.Value == null || editorValue.Value.ToString().IsNullOrWhiteSpace()) { return(string.Empty); } try { var value = JsonConvert.DeserializeObject <VortoValue>(editorValue.Value.ToString()); if (value.Values != null) { var dtd = VortoHelper.GetTargetDataTypeDefinition(value.DtdGuid); var preValues = ApplicationContext.Current.Services.DataTypeService.GetPreValuesCollectionByDataTypeId(dtd.Id); var propEditor = PropertyEditorResolver.Current.GetByAlias(dtd.PropertyEditorAlias); var keys = value.Values.Keys.ToArray(); foreach (var key in keys) { var propData = new ContentPropertyData(value.Values[key], preValues, new Dictionary <string, object>()); var newValue = propEditor.ValueEditor.ConvertEditorToDb(propData, value.Values[key]); value.Values[key] = (newValue == null) ? null : JToken.FromObject(newValue); } } return(JsonConvert.SerializeObject(value)); } catch (Exception ex) { LogHelper.Error <VortoPropertyValueEditor>("Error converting DB value to Editor", ex); } return(base.ConvertEditorToDb(editorValue, currentValue)); }
public override string ConvertDbToString(Property property, PropertyType propertyType, IDataTypeService dataTypeService) { if (property.Value == null) { return(string.Empty); } try { var value = JsonConvert.DeserializeObject <VortoValue>(property.Value.ToString()); 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; } property.Value = JsonConvert.SerializeObject(value); } catch (Exception ex) { LogHelper.Error <VortoPropertyValueEditor>("Error converting DB value to String", ex); } return(base.ConvertDbToString(property, propertyType, dataTypeService)); }
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); 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.ConvertDbToString(prop, propType, dataTypeService); value.Values[key] = 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 String", ex); } return(base.ConvertDbToString(prop2, propertyType, dataTypeService)); }
public override object ConvertDbToEditor(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) { 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.ConvertDbToEditor(prop, propType, dataTypeService); value.Values[key] = (newValue == null) ? null : JToken.FromObject(newValue); } prop2.Value = JsonConvert.SerializeObject(value); } } catch (Exception ex) { LogHelper.Error <VortoPropertyValueEditor>("Error converting DB value to Editor", ex); } return(base.ConvertDbToEditor(prop2, propertyType, dataTypeService)); }
private static T DoInnerGetVortoValue <T>(this IPublishedContent content, string propertyAlias, string cultureName = null, bool recursive = false, T defaultValue = default(T)) { if (content.HasValue(propertyAlias)) { var prop = content.GetProperty(propertyAlias); var vortoModel = prop.Value as VortoValue; if (vortoModel != null && vortoModel.Values != null) { // Get the serialized value var bestMatchCultureName = vortoModel.FindBestMatchCulture(cultureName); if (!bestMatchCultureName.IsNullOrWhiteSpace() && vortoModel.Values.ContainsKey(bestMatchCultureName) && vortoModel.Values[bestMatchCultureName] != null && !vortoModel.Values[bestMatchCultureName].ToString().IsNullOrWhiteSpace()) { var value = vortoModel.Values[bestMatchCultureName]; // Get target datatype var targetDataType = VortoHelper.GetTargetDataTypeDefinition(vortoModel.DtdGuid); // Umbraco has the concept of a IPropertyEditorValueConverter which it // also queries for property resolvers. However I'm not sure what these // are for, nor can I find any implementations in core, so am currently // just ignoring these when looking up converters. // NB: IPropertyEditorValueConverter not to be confused with // IPropertyValueConverter which are the ones most people are creating var properyType = CreateDummyPropertyType( targetDataType.Id, targetDataType.PropertyEditorAlias, content.ContentType); var inPreviewMode = UmbracoContext.Current != null ? UmbracoContext.Current.InPreviewMode : false; // Try convert data to source // We try this first as the value is stored as JSON not // as XML as would occur in the XML cache as in the act // of concerting to XML this would ordinarily get called // but with JSON it doesn't, so we try this first var converted1 = properyType.ConvertDataToSource(value, inPreviewMode); if (converted1 is T) { return((T)converted1); } var convertAttempt = converted1.TryConvertTo <T>(); if (convertAttempt.Success) { return(convertAttempt.Result); } // Try convert source to object // If the source value isn't right, try converting to object var converted2 = properyType.ConvertSourceToObject(converted1, inPreviewMode); if (converted2 is T) { return((T)converted2); } convertAttempt = converted2.TryConvertTo <T>(); if (convertAttempt.Success) { return(convertAttempt.Result); } // Try just converting convertAttempt = value.TryConvertTo <T>(); if (convertAttempt.Success) { return(convertAttempt.Result); } // Still not right type so return default value return(defaultValue); } } } return(recursive && content.Parent != null ? content.Parent.DoInnerGetVortoValue <T>(propertyAlias, cultureName, recursive, defaultValue) : defaultValue); }
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)); }
private static T DoGetVortoValue <T>(this IPublishedContent content, string propertyAlias, string cultureName = null, bool recursive = false, T defaultValue = default(T)) { if (cultureName == null) { cultureName = Thread.CurrentThread.CurrentUICulture.Name; } if (content.HasVortoValue(propertyAlias, cultureName, recursive)) { var prop = content.GetProperty(propertyAlias, recursive); if (prop.Value is VortoValue) { // Get the serialized value var vortoModel = prop.Value as VortoValue; var value = vortoModel.Values[cultureName]; // If the value is of type T, just return it //if (value is T) // return (T)value; // Get target datatype var targetDataType = VortoHelper.GetTargetDataTypeDefinition(vortoModel.DtdGuid); // Umbraco has the concept of a IPropertyEditorValueConverter which it // also queries for property resolvers. However I'm not sure what these // are for, nor can I find any implementations in core, so am currently // just ignoring these when looking up converters. // NB: IPropertyEditorValueConverter not to be confused with // IPropertyValueConverter which are the ones most people are creating var properyType = CreateDummyPropertyType(targetDataType.Id, targetDataType.PropertyEditorAlias, content.ContentType); var converters = PropertyValueConvertersResolver.Current.Converters.ToArray(); // In umbraco, there are default value converters that try to convert the // value if all else fails. The problem is, they are also in the list of // converters, and the means for filtering these out is internal, so // we currently have to try ALL converters to see if they can convert // rather than just finding the most appropreate. If the ability to filter // out default value converters becomes public, the following logic could // and probably should be changed. foreach (var converter in converters.Where(x => x.IsConverter(properyType))) { // Convert the type using a found value converter var value2 = converter.ConvertDataToSource(properyType, value, false); // If the value is of type T, just return it if (value2 is T) { return((T)value2); } // Value is not final value type, so try a regular type conversion aswell var convertAttempt = value2.TryConvertTo <T>(); if (convertAttempt.Success) { return(convertAttempt.Result); } } // Value is not final value type, so try a regular type conversion var convertAttempt2 = value.TryConvertTo <T>(); if (convertAttempt2.Success) { return(convertAttempt2.Result); } return(default(T)); } if (prop.Value is T) { return((T)prop.Value); } return(default(T)); } return(defaultValue); }