コード例 #1
0
            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;

                    if (Regex.IsMatch(asString, "^([0-9a-f]{3}|[0-9a-f]{6})$", RegexOptions.IgnoreCase) == false)
                    {
                        yield return new ValidationResult("The value " + asString + " is not a valid hex color", 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()
                            });
                    }
                }
            }
 /// <summary>
 /// Always
 /// </summary>
 /// <param name="defaultPreVals"></param>
 /// <param name="persistedPreVals"></param>
 /// <returns></returns>
 public override IDictionary<string, object> ConvertDbToEditor(IDictionary<string, object> defaultPreVals, PreValueCollection persistedPreVals)
 {
     var returnVal = base.ConvertDbToEditor(defaultPreVals, persistedPreVals);
     //always add the multiple param to true
     returnVal["multiple"] = "1";
     return returnVal;
 }
コード例 #3
0
        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.AsPreValueDictionary();
            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");
            }
        }
コード例 #4
0
		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;
		}
コード例 #5
0
            /// <summary>
            /// Need to deal with the legacy way of storing pre-values and turn them into nice values for the editor
            /// </summary>
            /// <param name="defaultPreVals"></param>
            /// <param name="persistedPreVals"></param>
            /// <returns></returns>
            public override IDictionary<string, object> ConvertDbToEditor(IDictionary<string, object> defaultPreVals, PreValueCollection persistedPreVals)
            {
                var preVals = persistedPreVals.FormatAsDictionary();
                var stringVal = preVals.Any() ? preVals.First().Value.Value : "";
                var returnVal = new Dictionary<string, object> { { "min", 0 }, { "max", 0 } };
                if (stringVal.IsNullOrWhiteSpace() == false)
                {
                    try
                    {
                        var json = JsonConvert.DeserializeObject<JObject>(stringVal);
                        if (json["Minimum"] != null)
                        {
                            //by default pre-values are sent out with an id/value pair
                            returnVal["min"] = json["Minimum"].Value<int>();
                        }
                        if (json["Maximum"] != null)
                        {
                            returnVal["max"] = json["Maximum"].Value<int>();
                        }
                    }
                    catch (Exception e)
                    {
                        //this shouldn't happen unless there's already a bad formatted pre-value
                        LogHelper.WarnWithException<MultipleTextStringPreValueEditor>("Could not deserialize value to json " + stringVal, e);
                        return returnVal;
                    }
                }

                return returnVal;
            }
コード例 #6
0
            /// <summary>
            /// This ensures the multiPicker pre-val is set based on the maxNumber of nodes set
            /// </summary>
            /// <param name="defaultPreVals"></param>
            /// <param name="persistedPreVals"></param>
            /// <returns></returns>
            /// <remarks>
            /// Due to compatibility with 7.0.0 the multiPicker pre-val might already exist in the db, but we've removed that setting in 7.0.1 so we need to detect it and if it is
            /// there, then we'll set the maxNumber to '1'
            /// </remarks>
            public override IDictionary<string, object> ConvertDbToEditor(IDictionary<string, object> defaultPreVals, PreValueCollection persistedPreVals)
            {
                var result = base.ConvertDbToEditor(defaultPreVals, persistedPreVals);

                //backwards compatibility check
                if (result.ContainsKey("multiPicker") && result["multiPicker"].ToString() == "0")
                {
                    result["maxNumber"] = "1";
                }

                //set the multiPicker val correctly depending on the maxNumber
                var asNumber = result["maxNumber"].TryConvertTo<int>();
                if (asNumber.Success)
                {
                    if (asNumber.Result <= 1)
                    {
                        result["multiPicker"] = "0";
                    }
                    else
                    {
                        result["multiPicker"] = "1";
                    }
                }

                return result;
            }
コード例 #7
0
 /// <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);
 }
コード例 #8
0
        /// <summary>
        /// The editor is expecting a json array for a field with a key named "items" so we need to format the persisted values
        /// to this format to be used in the editor.
        /// </summary>
        /// <param name="defaultPreVals"></param>
        /// <param name="persistedPreVals"></param>
        /// <returns></returns>
        public override IDictionary<string, object> ConvertDbToEditor(IDictionary<string, object> defaultPreVals, PreValueCollection persistedPreVals)
        {
            var dictionary = persistedPreVals.FormatAsDictionary();
            var arrayOfVals = dictionary.Select(item => item.Value).ToList();

            //the items list will be a dictionary of it's id -> value we need to use the id for persistence for backwards compatibility
            return new Dictionary<string, object> { { "items", arrayOfVals.ToDictionary(x => x.Id, x => x.Value) } };
        }
コード例 #9
0
 /// <summary>
 /// Chuck all the values into one field so devs can see what is stored there - we want this in case we've converted a legacy proeprty editor over to a label
 /// we should still show the pre-values stored for the data type.
 /// </summary>
 /// <param name="defaultPreVals"></param>
 /// <param name="persistedPreVals"></param>
 /// <returns></returns>
 public override IDictionary<string, object> ConvertDbToEditor(IDictionary<string, object> defaultPreVals, PreValueCollection persistedPreVals)
 {
     var existing = base.ConvertDbToEditor(defaultPreVals, persistedPreVals);
     //convert to a list, easier to enumerate on the editor
     var asList = existing.Select(e => new KeyValuePair<string, object>(e.Key, e.Value)).ToList();
     var result = new Dictionary<string, object> { { "values", asList } };
     return result;
 }
コード例 #10
0
            /// <summary>
            /// Need to change how we persist the values so they are compatible with the legacy way we store values
            /// </summary>
            /// <param name="editorValue"></param>
            /// <param name="currentValue"></param>
            /// <returns></returns>
            public override IDictionary<string, PreValue> ConvertEditorToDb(IDictionary<string, object> editorValue, PreValueCollection currentValue)
            {
                //the values from the editor will be min/max fieds and we need to format to json in one field
                var min = (editorValue.ContainsKey("min") ? editorValue["min"].ToString() : "0").TryConvertTo<int>();
                var max = (editorValue.ContainsKey("max") ? editorValue["max"].ToString() : "0").TryConvertTo<int>();

                var json = JObject.FromObject(new {Minimum = min.Success ? min.Result : 0, Maximum = max.Success ? max.Result : 0});

                return new Dictionary<string, PreValue> { { "0", new PreValue(json.ToString(Formatting.None)) } };
            }
コード例 #11
0
 public override IEnumerable<ValidationResult> Validate(object value, string config, PreValueCollection preValues, PropertyEditor editor)
 {
     if (value != null && value.ToString() != string.Empty)
     {
         var result = value.TryConvertTo<int>();
         if (result.Success == false)
         {
             yield return new ValidationResult("The value " + value + " is not a valid integer", new[] { "value" });
         }
     }
 }
コード例 #12
0
        public override IEnumerable<ValidationResult> Validate(object value, string config, PreValueCollection preValues, PropertyEditor editor)
        {
            var asString = value.ToString();

            var emailVal = new EmailAddressAttribute();

            if (emailVal.IsValid(asString) == false)
            {
                //TODO: localize these!
                yield return new ValidationResult("Email is invalid", new[] { "value" });
            }
        }
コード例 #13
0
        public override IEnumerable<ValidationResult> Validate(object value, string config, PreValueCollection preValues, PropertyEditor editor)
        {
            //TODO: localize these!
            if (config.IsNullOrWhiteSpace() == false && value != null)
            {
                var asString = value.ToString();

                var regex = new Regex(config);

                if (regex.IsMatch(asString) == false)
                {
                    yield return new ValidationResult("Value is invalid, it does not match the correct pattern", new[] { "value" });
                }                
            }
            
        }
コード例 #14
0
        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;
            }
        }
コード例 #15
0
        /// <summary>
        /// Performs the validation
        /// </summary>
        /// <param name="value"></param>
        /// <param name="config">Can be a json formatted string containing properties: 'delimiter' and 'pattern'</param>
        /// <param name="preValues">The current pre-values stored for the data type</param>
        /// <param name="editor"></param>
        /// <returns></returns>
        public override IEnumerable<ValidationResult> Validate(object value, string config, PreValueCollection preValues, PropertyEditor editor)
        {
            //TODO: localize these!
            if (value != null)
            {
                var delimiter = ",";
                Regex regex = null;
                if (config.IsNullOrWhiteSpace() == false)
                {
                    var json = JsonConvert.DeserializeObject<JObject>(config);
                    if (json["delimiter"] != null)
                    {
                        delimiter = json["delimiter"].ToString();
                    }
                    if (json["pattern"] != null)
                    {
                        var regexPattern = json["pattern"].ToString();
                        regex = new Regex(regexPattern);
                    }
                }

                var stringVal = value.ToString();
                var split = stringVal.Split(new[] { delimiter }, StringSplitOptions.RemoveEmptyEntries);
                for (var i = 0; i < split.Length; i++)
                {
                    var s = split[i];
                    //next if we have a regex statement validate with that
                    if (regex != null)
                    {
                        if (regex.IsMatch(s) == false)
                        {
                            yield return new ValidationResult("The item at index " + i + " did not match the expression " + regex,
                                new[]
                                {
                                    //make the field name called 'value0' where 0 is the index
                                    "value" + i
                                });
                        }
                    }
                }
            }

        }
コード例 #16
0
        public override IEnumerable<ValidationResult> Validate(object value, string config, PreValueCollection preValues, PropertyEditor editor)
        {
            //TODO: localize these!

            if (value == null)
            {
                yield return new ValidationResult("Value cannot be null", new[] {"value"});
            }
            else
            {
                var asString = value.ToString();
                if (asString.IsNullOrWhiteSpace())
                {
                    yield return new ValidationResult("Value cannot be empty", new[] { "value" });
                }
            }

            
        }
コード例 #17
0
        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" 
                                                      });
            }
        }
コード例 #18
0
        public static void ConvertPreValueCollectionFromV011(PreValueCollection preValueCollection)
        {
            if (preValueCollection == null)
            {
                return;
            }

            var persistedPreValuesAsDictionary = preValueCollection.AsPreValueDictionary();

            // 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"]
                    )
                );
        }
コード例 #19
0
ファイル: ArchetypeHelper.cs プロジェクト: jbreuer/Archetype
        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();
            }
        }
コード例 #20
0
        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"
                                                          });   
                }
            }

        }
コード例 #21
0
        /// <summary>
        /// Need to format the delimited posted string to individual values
        /// </summary>
        /// <param name="editorValue"></param>
        /// <param name="currentValue"></param>
        /// <returns>
        /// A string/string dictionary since all values that need to be persisted in the database are strings.
        /// </returns>
        /// <remarks>
        /// This is mostly because we want to maintain compatibility with v6 drop down property editors that store their prevalues in different db rows.
        /// </remarks>
        public override IDictionary<string, PreValue> ConvertEditorToDb(IDictionary<string, object> editorValue, PreValueCollection currentValue)
        {
            var val = editorValue["items"] as JArray;
            var result = new Dictionary<string, PreValue>();
            
            if (val == null)
            {
                return result;
            }

            try
            {
                var index = 0;

                //get all values in the array that are not empty 
                foreach (var item in val.OfType<JObject>()
                    .Where(jItem => jItem["value"] != null)
                    .Select(jItem => new
                        {
                            idAsString = jItem["id"] == null ? "0" : jItem["id"].ToString(), 
                            valAsString = jItem["value"].ToString()
                        })
                    .Where(x => x.valAsString.IsNullOrWhiteSpace() == false))
                {
                    var id = 0;
                    int.TryParse(item.idAsString, out id);
                    result.Add(index.ToInvariantString(), new PreValue(id, item.valAsString));
                    index++;
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error<ValueListPreValueEditor>("Could not deserialize the posted value: " + val, ex);                
            }

            return result;
        }
コード例 #22
0
        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, string>;
            Assert.IsNotNull(items);
            Assert.AreEqual("Item 1", items[1]);
            Assert.AreEqual("Item 2", items[2]);
            Assert.AreEqual("Item 3", items[3]);
        }
コード例 #23
0
            /// <summary>
            /// Take the posted values and convert them to a semi-colon separated list so that its backwards compatible
            /// </summary>
            /// <param name="editorValue"></param>
            /// <param name="currentValue"></param>
            /// <returns></returns>
            public override IDictionary<string, PreValue> ConvertEditorToDb(IDictionary<string, object> editorValue, PreValueCollection currentValue)
            {
                var result = base.ConvertEditorToDb(editorValue, currentValue);

                //this should just be a dictionary of values, we want to re-format this so that it is just one value in the dictionary that is 
                // semi-colon delimited
                var values = result.Select(item => item.Value.Value).ToList();

                result.Clear();
                result.Add("thumbs", new PreValue(string.Join(";", values)));
                return result;
            }
コード例 #24
0
            /// <summary>
            /// Format the persisted value to work with our multi-val editor.
            /// </summary>
            /// <param name="defaultPreVals"></param>
            /// <param name="persistedPreVals"></param>
            /// <returns></returns>
            public override IDictionary<string, object> ConvertDbToEditor(IDictionary<string, object> defaultPreVals, PreValueCollection persistedPreVals)
            {
                var result = new Dictionary<string, object>();

                //the pre-values just take up one field with a semi-colon delimiter so we'll just parse
                var dictionary = persistedPreVals.FormatAsDictionary();
                if (dictionary.Any())
                {
                    //there should only be one val
                    var delimited = dictionary.First().Value.Value.Split(new[] {';'}, StringSplitOptions.RemoveEmptyEntries);
                    for (var index = 0; index < delimited.Length; index++)
                    {
                        result.Add(index.ToInvariantString(), delimited[index]);
                    }
                }

                //the items list will be a dictionary of it's id -> value we need to use the id for persistence for backwards compatibility
                return new Dictionary<string, object> { { "items", result } };
            }
コード例 #25
0
ファイル: ArchetypeHelper.cs プロジェクト: jbreuer/Archetype
 private ArchetypePreValue GetArchetypePreValueFromPreValuesCollection(PreValueCollection dataTypePreValues)
 {
     var preValueAsString = dataTypePreValues.PreValuesAsDictionary.First().Value.Value;
     var preValue = JsonConvert.DeserializeObject<ArchetypePreValue>(preValueAsString, _jsonSettings);
     return preValue;
 }
コード例 #26
0
 /// <summary>
 /// Validates the object with the resolved ValueValidator found for this type
 /// </summary>
 /// <param name="value"></param>
 /// <param name="preValues">The current pre-values stored for the data type</param>
 /// <param name="editor">The property editor instance that we are validating for</param>
 /// <returns></returns>
 public IEnumerable<ValidationResult> Validate(object value, PreValueCollection preValues, PropertyEditor editor)
 {
     return ValidatorInstance.Validate(value, Config, preValues, editor);
 }
コード例 #27
0
 /// <summary>
 /// A method to format the posted values from the editor to the values to be persisted
 /// </summary>
 /// <param name="editorValue"></param>
 /// <param name="currentValue">
 /// The current value that has been persisted to the database for this pre-value editor. This value may be usesful for 
 /// how the value then get's deserialized again to be re-persisted. In most cases it will probably not be used.
 /// </param>
 /// <returns></returns>
 /// <remarks>
 /// By default this will just return the Posted editorValue.
 /// 
 /// This can be overridden if perhaps you have a comma delimited string posted value but want to convert those to individual rows, or to convert
 /// a json structure to multiple rows.
 /// </remarks>
 public virtual IDictionary<string, PreValue> ConvertEditorToDb(IDictionary<string, object> editorValue, PreValueCollection currentValue)
 {
     //convert to a string based value to be saved in the db
     return editorValue.ToDictionary(x => x.Key, x => new PreValue(x.Value == null ? null : x.Value.ToString()));
 }
コード例 #28
0
        /// <summary>
        /// This can be used to re-format the currently saved pre-values that will be passed to the editor,
        /// by default this returns the merged default and persisted pre-values.
        /// </summary>
        /// <param name="defaultPreVals">
        /// The default/static pre-vals for the property editor
        /// </param>
        /// <param name="persistedPreVals">
        /// The persisted pre-vals for the property editor
        /// </param>
        /// <returns></returns>
        /// <remarks>
        /// This is generally not going to be used by anything unless a property editor wants to change the merging
        /// functionality or needs to convert some legacy persisted data, or convert the string values to strongly typed values in json (i.e. booleans)
        /// 
        /// IMPORTANT! When using this method the default pre values dictionary should not be modified which would change the property editor's global 
        /// singleton pre-values!
        /// </remarks>
        public virtual IDictionary<string, object> ConvertDbToEditor(IDictionary<string, object> defaultPreVals, PreValueCollection persistedPreVals)
        {
            //we'll make a copy since we'll merge into the defaults - but we don't want to overwrite the global singleton ones passed in!
            var defaultPreValCopy = new Dictionary<string, object>();
            if (defaultPreVals != null)
            {
                defaultPreValCopy = new Dictionary<string, object>(defaultPreVals);
            }

            if (persistedPreVals.IsDictionaryBased)
            {
                //we just need to merge the dictionaries now, the persisted will replace default.
                foreach (var item in persistedPreVals.PreValuesAsDictionary)
                {
                    //The persisted dictionary contains values of type PreValue which contain the ID and the Value, we don't care
                    // about the Id, just the value so ignore the id.
                    defaultPreValCopy[item.Key] = item.Value.Value;
                }
                //now we're going to try to see if any of the values are JSON, if they are we'll convert them to real JSON objects
                // so they can be consumed as real json in angular!
                ConvertItemsToJsonIfDetected(defaultPreValCopy);

                return defaultPreValCopy;
            }

            //it's an array so need to format it 
            var result = new Dictionary<string, object>();
            var asArray = persistedPreVals.PreValuesAsArray.ToArray();
            for (var i = 0; i < asArray.Length; i++)
            {
                //each item is of type PreValue but we don't want the ID, just the value so ignore the ID
                result.Add(i.ToInvariantString(), asArray[i].Value);
            }

            //now we're going to try to see if any of the values are JSON, if they are we'll convert them to real JSON objects
            // so they can be consumed as real json in angular!
            ConvertItemsToJsonIfDetected(result);

            return result;
        }
コード例 #29
0
 public IEnumerable<ValidationResult> Validate(object value, PreValueCollection preValues, PropertyEditor editor)
 {
     return Validate(value, null, preValues, editor);
 }
コード例 #30
0
 /// <summary>
 /// Performs the validation against the value
 /// </summary>
 /// <param name="value">
 /// Depending on what is being validated, this value can be a json structure (JObject, JArray, etc...) representing an editor's model, it could be a single
 /// string representing an editor's model.
 /// </param>
 /// <param name="config">
 /// An object that is used to configure the validator. An example could be a regex 
 /// expression if the validator was a regex validator. This is defined in the manifest along with
 /// the definition of the validator.
 /// </param>
 /// <param name="preValues">The current pre-values stored for the data type</param>
 /// <param name="editor">The property editor instance that is being validated</param>
 /// <returns>
 /// Returns a list of validation results. If a result does not have a field name applied to it then then we assume that 
 /// the validation message applies to the entire property type being validated. If there is a field name applied to a 
 /// validation result we will try to match that field name up with a field name on the item itself.
 /// </returns>
 public abstract IEnumerable<ValidationResult> Validate(object value, string config, PreValueCollection preValues, PropertyEditor editor);