public static void ConvertItemValueFromV011(JObject item, int dtdId, ref PreValueCollection preValues) { var contentTypeAlias = GetContentTypeAliasFromItem(item); if (contentTypeAlias != null) { // the item is already in >v0.1.1 format return; } // old style (v0.1.1) data, let's attempt a conversion // - get the prevalues (if they're not loaded already) preValues = preValues ?? GetPreValuesCollectionByDataTypeId(dtdId); // - convert the prevalues (if necessary) ConvertPreValueCollectionFromV011(preValues); // - get the content types prevalue as JArray var preValuesAsDictionary = preValues.PreValuesAsDictionary.ToDictionary(x => x.Key, x => x.Value.Value); if (!preValuesAsDictionary.ContainsKey(ContentTypesPreValueKey) || string.IsNullOrEmpty(preValuesAsDictionary[ContentTypesPreValueKey]) != false) { return; } var preValueContentTypes = JArray.Parse(preValuesAsDictionary[ContentTypesPreValueKey]); if (preValueContentTypes.Any()) { // the only thing we can really do is assume that the item is the first available content type item[NestedContentPropertyEditor.ContentTypeAliasPropertyKey] = preValueContentTypes.First().Value <string>("ncAlias"); } }
private static string contentReplace(string content, IContentBase entity) { var ptypes = entity.PropertyTypes; string contenttypename = ApplicationContext.Current.Services.EntityService.Get(entity.ContentTypeId, true).Name; foreach (var ptype in ptypes) { PreValueCollection coll = ApplicationContext.Current.Services.DataTypeService.GetPreValuesCollectionByDataTypeId(ptype.DataTypeDefinitionId); if (coll.PreValuesAsDictionary.Count == 0) { string value = entity.GetValue <string>(ptype.Alias); content = content.Replace("{{" + contenttypename + "." + ptype.Alias + "}}", entity.GetValue <string>(ptype.Alias)); } else { foreach (var item in coll.PreValuesAsDictionary) { var kk = entity.GetValue <int>(ptype.Alias); if (item.Value.Id.Equals(entity.GetValue <int>(ptype.Alias))) { string strval = item.Value.Value; content = content.Replace("{{" + contenttypename + "." + ptype.Alias + "}}", strval); } } } } return(content); }
private ArchetypePreValue GetArchetypePreValueFromPreValuesCollection(PreValueCollection dataTypePreValues) { var preValueAsString = dataTypePreValues.PreValuesAsDictionary.First().Value.Value; var preValue = JsonConvert.DeserializeObject <ArchetypePreValue>(preValueAsString, _jsonSettings); return(preValue); }
public IEnumerable <ValidationResult> Validate(object value, PreValueCollection preValues, PropertyEditor editor) { //now check the file type var asJson = value as JObject; if (asJson == null) { yield break; } if (asJson["selectedFiles"] == null) { yield break; } var fileNames = asJson["selectedFiles"].ToString().Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries); foreach (var fileName in fileNames) { if (ValidateFileExtension(fileName) == false) { yield return(new ValidationResult(ui.Text("errors", "dissallowedMediaType"), new[] { //we only store a single value for this editor so the 'member' or 'field' // we'll associate this error with will simply be called 'value' "value" })); } } }
public static string GetRowOptionsDocType(PreValueCollection preValueCollection, string cellId) { var preValueDict = preValueCollection.PreValuesAsDictionary.ToDictionary(x => x.Key, x => x.Value.Value); // Check the grid config if (preValueDict.ContainsKey("gridConfig")) { var gridConfig = JsonConvert.DeserializeObject <Dictionary <string, Dictionary <string, object> > >( preValueDict["gridConfig"].ToString(CultureInfo.InvariantCulture)); if (gridConfig != null && gridConfig.ContainsKey(cellId) && gridConfig[cellId].ContainsKey("rowOptionsDocType")) { return(gridConfig[cellId]["rowOptionsDocType"].ToString()); } } // Check the default config if (preValueDict.ContainsKey("defaultConfig")) { var defaultConfig = JsonConvert.DeserializeObject <Dictionary <string, object> >( preValueDict["defaultConfig"].ToString(CultureInfo.InvariantCulture)); if (defaultConfig != null && defaultConfig.ContainsKey("rowOptionsDocType")) { return(defaultConfig["rowOptionsDocType"].ToString()); } } return(null); }
private EmbeddedContentPropertyDisplay GetProperty(PropertyType propertyType, object value) { var property = new EmbeddedContentPropertyDisplay { Editor = propertyType.PropertyEditorAlias, Label = UmbracoDictionaryTranslate(propertyType.Name), Description = UmbracoDictionaryTranslate(propertyType.Description), Alias = propertyType.Alias, Value = value }; PropertyEditor propertyEditor = _propertyEditorResolver.GetByAlias(propertyType.PropertyEditorAlias); PreValueCollection preValues = _dataTypeService.GetPreValuesCollectionByDataTypeId(propertyType.DataTypeDefinitionId); property.Value = propertyEditor.ValueEditor.ConvertDbToEditor( new Property(propertyType, value?.ToString()), propertyType, _dataTypeService ); propertyEditor.ValueEditor.ConfigureForDisplay(preValues); property.Config = propertyEditor.PreValueEditor.ConvertDbToEditor(propertyEditor.DefaultPreValues, preValues); property.View = propertyEditor.ValueEditor.View; property.HideLabel = propertyEditor.ValueEditor.HideLabel; property.Validation.Mandatory = propertyType.Mandatory; property.Validation.Pattern = propertyType.ValidationRegExp; return(property); }
public IEnumerable <ValidationResult> Validate(object value, PreValueCollection preValues, PropertyEditor editor) { var json = value as JArray; if (json == null) { yield break; } //get all values in the array that are not empty (we'll remove empty values when persisting anyways) var groupedValues = json.OfType <JObject>() .Where(jItem => jItem["value"] != null) .Select((jItem, index) => new { value = jItem["value"].ToString(), index = index }) .Where(asString => asString.value.IsNullOrWhiteSpace() == false) .GroupBy(x => x.value); foreach (var g in groupedValues.Where(g => g.Count() > 1)) { yield return(new ValidationResult("The value " + g.Last().value + " must be unique", new[] { //we'll make the server field the index number of the value so it can be wired up to the view "item_" + g.Last().index.ToInvariantString() })); } }
public static T Map <T>(this PreValueCollection preValues) where T : class, new() { var preValuesDictionary = preValues.PreValuesAsDictionary; return(preValuesDictionary.Map <T>()); }
public IEnumerable <ValidationResult> Validate(object value, PreValueCollection preValues, PropertyEditor editor) { var results = new List <ValidationResult>(); var model = JsonConvert.DeserializeObject <PropertyListValue>(value?.ToString()); if (model == null) { return(results); } bool getIntValue(string alias, out int number) { number = 0; return(preValues.PreValuesAsDictionary.ContainsKey(alias) && int.TryParse(preValues.PreValuesAsDictionary[alias].Value, out number) && number > 0); } if (preValues.IsDictionaryBased) { var dict = preValues.PreValuesAsDictionary; if (getIntValue(PreValueKeys.MinItems, out int minItems) && model.Values.Count < minItems) { results.Add(new ValidationResult($"There are {model.Values.Count} items in the list, when the minimum is set to {minItems}.")); } if (getIntValue(PreValueKeys.MaxItems, out int maxItems) && model.Values.Count > maxItems) { results.Add(new ValidationResult($"There are {model.Values.Count} items in the list, when the maximum is set to {maxItems}.")); } } var meta = GetInnerPropertyMetaData(model.DataTypeGuid); if (meta == null) { return(results); } var validators = meta.Item3; if (validators == null || validators.Any() == false) { return(results); } foreach (var itemValue in model.Values) { // TODO: Consider what Mandatory and RegExp mean in the context of Property List, and how they should be handled. foreach (var validator in validators) { results.AddRange(validator.Validate(itemValue, meta.Item1, meta.Item2)); } } return(results); }
/// <summary> /// Used when configured as an IPropertyValidator /// </summary> /// <param name="value"></param> /// <param name="preValues"></param> /// <param name="editor"></param> /// <returns></returns> public IEnumerable <ValidationResult> Validate(object value, PreValueCollection preValues, PropertyEditor editor) { if (_regex == null) { throw new InvalidOperationException("This validator is not configured as a " + typeof(IPropertyValidator)); } return(Validate(value, _regex, preValues, editor)); }
/// <summary> /// This is called to configure the editor for display with it's prevalues, useful when properties need to change dynamically /// depending on what is in the pre-values. /// </summary> /// <param name="preValues"></param> /// <remarks> /// This cannot be used to change the value being sent to the editor, ConfigureEditor will be called *after* ConvertDbToEditor, pre-values /// should not be used to modify values. /// </remarks> public virtual void ConfigureForDisplay(PreValueCollection preValues) { if (preValues == null) { throw new ArgumentNullException("preValues"); } _preVals = preValues; }
public static string GetMetaDataDocType(PreValueCollection preValueCollection) { var preValueDict = preValueCollection.PreValuesAsDictionary.ToDictionary(x => x.Key, x => x.Value.Value); return(preValueDict.ContainsKey("metaDataDocType") ? preValueDict["metaDataDocType"] : ""); }
public override void ConfigureForDisplay(PreValueCollection preValues) { base.ConfigureForDisplay(preValues); if (preValues.PreValuesAsDictionary.ContainsKey(PreValueKeys.HideLabel)) { HideLabel = preValues.PreValuesAsDictionary[PreValueKeys.HideLabel].Value == "1"; } }
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)); } }
public override void ConfigureForDisplay(PreValueCollection preValues) { base.ConfigureForDisplay(preValues); if (preValues.PreValuesAsDictionary.ContainsKey(InnerContentConstants.HideLabelPreValueKey)) { HideLabel = preValues.PreValuesAsDictionary[InnerContentConstants.HideLabelPreValueKey].Value == "1"; } }
private string GetValue(PreValueCollection preValues, string key) { PreValue preValue; if (!preValues.PreValuesAsDictionary.TryGetValue(key, out preValue)) { return(null); } return(preValue.Value); }
public static int GetPreValueIdByValue(this PreValueCollection preValue, string value) { try { return(preValue.PreValuesAsDictionary.Where(b => b.Value.Value == value).FirstOrDefault().Value.Id); } catch { return(-1); } }
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 override void ConfigureForDisplay(PreValueCollection preValues) { base.ConfigureForDisplay(preValues); if (preValues.PreValuesAsDictionary.ContainsKey("hideLabel")) { var boolAttempt = preValues.PreValuesAsDictionary["hideLabel"].Value.TryConvertTo <bool>(); if (boolAttempt.Success) { HideLabel = boolAttempt.Result; } } }
private void SetPreValueInternal(IDataTypeDefinition dataType, PreValueCollection preValues, string name, string newValue) { var dictionary = preValues.FormatAsDictionary(); var existing = dictionary.GetValueOrDefault(name); if (existing != null) { var oldValue = existing.Value; existing.Value = newValue; Logger.Log("DataType: '{0}', changed setting '{1}': '{2}' => '{3}'.", dataType.Name, name, oldValue, newValue); return; } preValues.PreValuesAsDictionary[name] = new PreValue(newValue); Logger.Log("DataType: '{0}', added setting '{1}': '{2}'.", dataType.Name, name, newValue); }
private bool HasPrevalues(PreValueCollection preVals) { if (preVals.PreValuesAsDictionary["crops"] == null || preVals.PreValuesAsDictionary["crops"].Value.IsNullOrWhiteSpace()) { return(false); } try { var array = JsonConvert.DeserializeObject <JArray>(preVals.PreValuesAsDictionary["crops"].Value); return(array.Count > 0); } catch (Exception) { return(false); } }
public static void ConvertPreValueCollectionFromV011(PreValueCollection preValueCollection) { if (preValueCollection == null) { return; } var persistedPreValuesAsDictionary = preValueCollection.PreValuesAsDictionary.ToDictionary(x => x.Key, x => x.Value.Value); // do we have a "docTypeGuid" prevalue and no "contentTypes" prevalue? if (persistedPreValuesAsDictionary.ContainsKey("docTypeGuid") == false || persistedPreValuesAsDictionary.ContainsKey(ContentTypesPreValueKey)) { // the prevalues are already in >v0.1.1 format return; } // attempt to parse the doc type guid Guid guid; if (Guid.TryParse(persistedPreValuesAsDictionary["docTypeGuid"], out guid) == false) { // this shouldn't happen... but just in case. return; } // find the content type var contentType = ApplicationContext.Current.Services.ContentTypeService.GetAllContentTypes().FirstOrDefault(c => c.Key == guid); if (contentType == null) { return; } // add a prevalue in the format expected by the new (>0.1.1) content type picker/configurator preValueCollection.PreValuesAsDictionary[ContentTypesPreValueKey] = new PreValue( string.Format(@"[{{""ncAlias"": ""{0}"", ""ncTabAlias"": ""{1}"", ""nameTemplate"": ""{2}"", }}]", contentType.Alias, persistedPreValuesAsDictionary["tabAlias"], persistedPreValuesAsDictionary["nameTemplate"] ) ); }
/// <summary> /// Gets the JSON configuration file from the property with the given alias, by reading it's data type's pre values. /// </summary> /// <param name="pageId">The of the page containing the PartialSorter.</param> /// <param name="propertyAlias">The PartialSorter property alias.</param> /// <returns>The loaded JSON configuration file.</returns> public static JObject GetConfiguration(int pageId, string propertyAlias) { JObject config = GetCachedConfig(JsonConfigs, pageId, propertyAlias); if (config == null) { ServiceContext services = ApplicationContext.Current.Services; IContentService contentService = services.ContentService; IContent settingsPage = contentService.GetById(pageId); PropertyType property = settingsPage.ContentType.PropertyTypes.FirstOrDefault(p => p.Alias == propertyAlias); if (property != null) { PreValueCollection preValues = services.DataTypeService.GetPreValuesCollectionByDataTypeId(property.DataTypeDefinitionId); PreValue jsonConfigUrl; if (preValues.PreValuesAsDictionary.TryGetValue("jsonConfigUrl", out jsonConfigUrl) && !String.IsNullOrWhiteSpace(jsonConfigUrl.Value)) { string url = jsonConfigUrl.Value; if (!url.StartsWith("~")) { url = String.Format("{0}{1}", url.StartsWith("/") ? "~" : "~/", url); } string json; using (StreamReader sr = new StreamReader(HttpContext.Current.Server.MapPath(url))) { json = sr.ReadToEnd(); } config = JObject.Parse(json); SetCachedConfig(JsonConfigs, pageId, propertyAlias, config); } } } return(config); }
public IEnumerable <ValidationResult> Validate(object value, PreValueCollection preValues, PropertyEditor editor) { //don't validate if empty if (value == null || value.ToString().IsNullOrWhiteSpace()) { yield break; } DateTime dt; if (DateTime.TryParse(value.ToString(), out dt) == false) { yield return(new ValidationResult(string.Format("The string value {0} cannot be parsed into a DateTime", value), new[] { //we only store a single value for this editor so the 'member' or 'field' // we'll associate this error with will simply be called 'value' "value" })); } }
public static IContentType GetContentTypeFromPreValue(PreValueCollection preValues) { var preValuesDict = preValues.AsPreValueDictionary(); Guid contentTypeGuid; if (!preValuesDict.ContainsKey("docTypeGuid") || !Guid.TryParse(preValuesDict["docTypeGuid"], out contentTypeGuid)) { return(null); } var contentTypeAlias = ApplicationContext.Current.Services.ContentTypeService.GetAliasByGuid(Guid.Parse(preValuesDict["docTypeGuid"])); var contentType = ApplicationContext.Current.Services.ContentTypeService.GetContentType(contentTypeAlias); if (contentType == null || contentType.PropertyTypes == null) { return(null); } return(contentType); }
public override void ConfigureForDisplay(PreValueCollection preValues) { using (_profilingLogger.DebugDuration <EmbeddedContentPropertyEditor>("ConfigureForDisplay()")) { List <IContentType> contentTypes = _contentTypeService.GetAllContentTypes().ToList(); PreValue configPreValue = preValues.PreValuesAsDictionary["embeddedContentConfig"]; JObject config = JObject.Parse(configPreValue.Value); config["configureForDisplay"] = true; foreach (var item in config["documentTypes"].ToList()) { var contentType = contentTypes.FirstOrDefault(x => x.Alias == item["documentTypeAlias"].Value <string>()); if (contentType == null) { item.Remove(); continue; } if (string.IsNullOrEmpty(item.Value <string>("nameTemplate"))) { PropertyType propertyType = contentType.CompositionPropertyGroups .OrderBy(x => x.SortOrder) .FirstOrDefault() ?.PropertyTypes .OrderBy(x => x.SortOrder) .FirstOrDefault(); if (propertyType != null) { item["nameTemplate"] = $"{{{{{propertyType.Alias}}}}}"; } } } configPreValue.Value = config.ToString(); } base.ConfigureForDisplay(preValues); }
internal ArchetypeModel DeserializeJsonToArchetype(string sourceJson, PreValueCollection dataTypePreValues) { try { var archetype = JsonConvert.DeserializeObject <ArchetypeModel>(sourceJson, _jsonSettings); try { // Get list of configured properties and their types and map them to the deserialized archetype model var preValue = GetArchetypePreValueFromPreValuesCollection(dataTypePreValues); RetrieveAdditionalProperties(ref archetype, preValue); } catch (Exception ex) { } return(archetype); } catch { return(new ArchetypeModel()); } }
public void DropDownPreValueEditor_Format_Data_For_Editor() { var defaultVals = new Dictionary <string, object>(); var persisted = new PreValueCollection(new Dictionary <string, PreValue> { { "item1", new PreValue(1, "Item 1") }, { "item2", new PreValue(2, "Item 2") }, { "item3", new PreValue(3, "Item 3") } }); var editor = new ValueListPreValueEditor(); var result = editor.ConvertDbToEditor(defaultVals, persisted); Assert.AreEqual(1, result.Count); Assert.IsTrue(result.ContainsKey("items")); var items = result["items"] as IDictionary <int, IDictionary <string, object> >; Assert.IsNotNull(items); Assert.AreEqual("Item 1", items[1]["value"]); Assert.AreEqual("Item 2", items[2]["value"]); Assert.AreEqual("Item 3", items[3]["value"]); }
public IEnumerable <ValidationResult> Validate(object value, PreValueCollection preValues, PropertyEditor editor) { var json = value as JArray; if (json == null) { yield break; } //validate each item which is a json object for (var index = 0; index < json.Count; index++) { var i = json[index]; var jItem = i as JObject; if (jItem == null || jItem["value"] == null) { continue; } //NOTE: we will be removing empty values when persisting so no need to validate var asString = jItem["value"].ToString(); if (asString.IsNullOrWhiteSpace()) { continue; } int parsed; if (int.TryParse(asString, out parsed) == false) { yield return(new ValidationResult("The value " + asString + " is not a valid number", new[] { //we'll make the server field the index number of the value so it can be wired up to the view "item_" + index.ToInvariantString() })); } } }
public void Can_Deep_Clone() { var d = new PreValueCollection(new Dictionary <string, PreValue> { { "blah1", new PreValue(1, "test1", 1) }, { "blah2", new PreValue(2, "test1", 3) }, { "blah3", new PreValue(3, "test1", 2) } }); var a = new PreValueCollection(new[] { new PreValue(1, "test1", 1), new PreValue(2, "test1", 3), new PreValue(3, "test1", 2) }); var clone1 = (PreValueCollection)d.DeepClone(); var clone2 = (PreValueCollection)a.DeepClone(); Action <PreValueCollection, PreValueCollection> assert = (orig, clone) => { Assert.AreNotSame(orig, clone); var oDic = orig.FormatAsDictionary(); var cDic = clone.FormatAsDictionary(); Assert.AreEqual(oDic.Keys.Count(), cDic.Keys.Count()); foreach (var k in oDic.Keys) { Assert.AreNotSame(oDic[k], cDic[k]); Assert.AreEqual(oDic[k].Id, cDic[k].Id); Assert.AreEqual(oDic[k].SortOrder, cDic[k].SortOrder); Assert.AreEqual(oDic[k].Value, cDic[k].Value); } }; assert(d, clone1); assert(a, clone2); }
public ContentPropertyData(object value, PreValueCollection preValues, IDictionary<string, object> additionalData) { Value = value; PreValues = preValues; AdditionalData = new ReadOnlyDictionary<string, object>(additionalData); }