C# ApplicationData.SetValue方法代码示例

            public void ContinueAfterShownControl()
            {
                ApplicationData applicationData = new ApplicationData();
                applicationData.SetValue("Hide_trigger", "No", true);

                ValidationResults results = new ValidationResults();
                this.validator.Validate(applicationData, results);
                Assert.AreEqual(false, results.IsValid);
            }

            public void CurrentSubpageValidationFail()
            {
                ApplicationData data = new ApplicationData
                                           {
                                               { "User_name", string.Empty },
                                               { "Staff_name", "ABC" }
                                           };

                var subGroup = this.subpageControlList.FindRecursive<GroupControl>(x => x.Id == 1);
                var subControlList = new ControlList { subGroup };

                var validator = new ApplicationValidator(subControlList, validatorList: this.validatorList);
                var results = validator.Validate(new Application(data));

                Assert.IsFalse(results.IsValid);

                // Test other group
                data.SetValue("User_name", "ABC");
                data.SetValue("Staff_name", string.Empty);

                subGroup = this.subpageControlList.FindRecursive<GroupControl>(x => x.Id == 2);
                subControlList = new ControlList { subGroup };

                validator = new ApplicationValidator(subControlList, validatorList: this.validatorList);
                results = validator.Validate(new Application(data));

                Assert.IsFalse(results.IsValid);
            }

 /// <summary>
 /// Populates <paramref name="target"/> with values from <paramref name="response"/> as defined by <paramref name="map"/>.
 /// </summary>
 /// <param name="response">The response object from which to get values.</param>
 /// <param name="map">A field map definition.</param>
 /// <param name="target">The target object to populate with mapped key/values.</param>
 private void MapPropertyField(HttpWebResponse response, MappedField map, ApplicationData target)
 {
     PropertyInfo info = response.GetType().GetProperty(map.Source);
     object propertyValue = info.GetValue(response);
     target.SetValue(map.Target, propertyValue);
 }

        /// <summary>
        /// Populates <paramref name="target"/> with values from <paramref name="source"/> and <paramref name="response"/>
        /// as defined by <paramref name="fieldMap"/>. It also returns a new <see cref="Newtonsoft.Json.Linq.JObject"/> with mapped values.
        /// </summary>
        /// <param name="source">The response body from which to get values.</param>
        /// <param name="response">The response object from which to get values.</param>
        /// <param name="fieldMap">A definition of field mappings.</param>
        /// <param name="target">The target object to populate with mapped key/values.</param>
        /// <returns>A new <see cref="Newtonsoft.Json.Linq.JObject"/> with mapped values.</returns>
        public JObject MapObject(JObject source, HttpWebResponse response, MappedFieldList fieldMap, ApplicationData target)
        {
            JObject outObject = new JObject();
            IEnumerable<MappedField> validMappings = fieldMap.Where(m => !string.IsNullOrEmpty(m.Target) && !string.IsNullOrEmpty(m.Source));

            foreach (MappedField map in validMappings)
            {
                switch (map.MapType)
                {
                    case MapType.Content:
                        JToken token = source.SelectToken(map.Source);
                        if (token != null)
                        {
                            outObject.Add(map.Target, token);
                            if (target != null)
                            {
                                if (token.Type == JTokenType.Array && token.First().Type == JTokenType.Object)
                                {
                                    var repeater = new NestedDictionary[token.Children().Count()];
                                    var i = 0;
                                    foreach (var row in token)
                                    {
                                        repeater[i] = new NestedDictionary();

                                        foreach (JProperty fieldProp in row.OfType<JProperty>())
                                        {
                                            object targetValue = fieldProp.Value.Type == JTokenType.Array ? fieldProp.Value.Values<string>().ToArray() as object : fieldProp.Value.ToString();
                                            if (repeater[i].ContainsKey(fieldProp.Name))
                                            {
                                                repeater[i][fieldProp.Name] = targetValue;
                                            }
                                            else
                                            {
                                                repeater[i].Add(fieldProp.Name, targetValue);
                                            }
                                        }

                                        i++;
                                    }

                                    target.SetValue(map.Target, repeater);
                                }
                                else
                                {
                                    object targetValue = token.Type == JTokenType.Array ? token.Values<string>().ToArray() as object : token.Value<string>();
                                    target.SetValue(map.Target, targetValue, true);
                                }
                            }
                        }

                        break;

                    case MapType.Property:
                        this.MapPropertyField(response, map, target);
                        break;

                    default:
                        throw new InvalidOperationException(string.Format(ExceptionMessages.InvalidMapType, map.MapType));
                }
            }

            return outObject;
        }

        /// <summary>
        /// Creates a new application, and populates it with data, returning the newly created application.
        /// </summary>
        /// <param name="sessionData">The session data.</param>
        /// <param name="parameters">The parameters to populate within application data.</param>
        /// <returns>The newly created application.</returns>
        public Application PrePopulateApplication(SessionData sessionData, NameValueCollection parameters)
        {
            string formId = parameters["formId"];
            if (formId == null)
            {
                return null;
            }

            RetrieveApplicationResponse applicationResponse = this.CreateApplicationSecure(sessionData, formId, true);

            Application application = applicationResponse.Application;
            ProductDefinition product = applicationResponse.Product;

            if (!product.AllowPrepopulate)
            {
                return application;
            }

            ApplicationData updateFrom = new ApplicationData();
            IEnumerable<ValueControl> prePopulateControls = product.FormDefinition.Pages.AllControls.FindAllRecursive<ValueControl>(x => x.AllowPrepopulate);
            foreach (ValueControl prePopulateControl in prePopulateControls)
            {
                if (parameters[prePopulateControl.Name] != null)
                {
                    updateFrom.SetValue(prePopulateControl.Name, parameters[prePopulateControl.Name], true);
                }
                else if (prePopulateControl.ParentId != null)
                {
                    RepeaterControl parent = product.FormDefinition.Pages.AllControls.FindRecursive<RepeaterControl>(x => x.Id == prePopulateControl.ParentId);
                    if (parent == null)
                    {
                        continue;
                    }

                    Regex repeaterFormat = new Regex(string.Format(Constants.RepeaterRegexPattern, prePopulateControl.Name));
                    IEnumerable<string> parentParams = parameters.AllKeys.Where(x => repeaterFormat.IsMatch(x));
                    foreach (string parentParam in parentParams)
                    {
                        string parentPath = this.DetermineRepeaterPath(parentParam, repeaterFormat);
                        if (parentPath != null)
                        {
                            updateFrom.SetValue(parentPath, parameters[parentParam], true);
                        }
                    }
                }
            }

            if (updateFrom.Count != 0)
            {
                application.ApplicationData = updateFrom;
                this.SaveApplication(sessionData, application);
            }

            return application;
        }