C# ModelStateDictionary.AddModelError方法代码示例

 public static bool IsValidBooleanField(ModelStateDictionary modelState, string display, string field, string value, bool required = false)
 {
     bool ret = false;
     bool result;
     if (value.IsNullOrEmpty())
     {
         if (required)
         {
             modelState.AddModelError(field, "กรุณาใส่" + display);
         }
         else
         {
             ret = true;
         }
     }
     else if (!bool.TryParse(value, out result))
     {
         modelState.AddModelError(field, display + "มีค่าไม่ถูกต้อง");
     }
     else
     {
         ret = true;
     }
     return ret;
 }

        public override void OnActionExecuting(HttpActionContext actionContext)
        {
            base.OnActionExecuting(actionContext);

            var options = actionContext.ActionArguments.Where(p => p.Value is ODataQueryOptions).Select(p => p.Value).OfType<ODataQueryOptions>().FirstOrDefault();

            if (options == null)
            {
                return;
            }

            var modelDictionary = new ModelStateDictionary();

            if (options.Skip != null)
            {
                if (options.Skip.Value < MinSkipValue)
                {
                    modelDictionary.AddModelError("Skip", String.Format("Value must be greater than or equal {0}", MinSkipValue));
                }
            }

            if (options.Top != null)
            {
                if (options.Top.Value < MinTopValue)
                {
                    modelDictionary.AddModelError("Top", String.Format("Value must be greater than or equal {0}", MinTopValue));
                }
            }

            if (modelDictionary.Count > 0)
            {
                actionContext.Response = actionContext.Request.CreateErrorResponse(HttpStatusCode.BadRequest, modelDictionary);
            }
        }

        public void WriteXml_WritesValidXml()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.AddModelError("key1", "Test Error 1");
            modelState.AddModelError("key1", "Test Error 2");
            modelState.AddModelError("key2", "Test Error 3");
            var serializableError = new SerializableError(modelState);
            var outputStream = new MemoryStream();

            // Act
            using (var xmlWriter = XmlWriter.Create(outputStream))
            {
                var dataContractSerializer = new DataContractSerializer(typeof(SerializableErrorWrapper));
                dataContractSerializer.WriteObject(xmlWriter, new SerializableErrorWrapper(serializableError));
            }
            outputStream.Position = 0;
            var res = new StreamReader(outputStream, Encoding.UTF8).ReadToEnd();

            // Assert
            var expectedContent =
                TestPlatformHelper.IsMono ?
                    "<?xml version=\"1.0\" encoding=\"utf-8\"?><Error xmlns:i=\"" +
                    "http://www.w3.org/2001/XMLSchema-instance\"><key1>Test Error 1 Test Error 2</key1>" +
                    "<key2>Test Error 3</key2></Error>" :
                    "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
                    "<Error><key1>Test Error 1 Test Error 2</key1><key2>Test Error 3</key2></Error>";

            Assert.Equal(expectedContent, res);
        }

        public void Validate(ModelStateDictionary modelState, string modelPrefix, decimal? totalMarks)
        {
            if (!this.IsSet)
            {
                return;
            }

            if (string.IsNullOrWhiteSpace(this.Grade))
            {
                modelState.AddModelError(modelPrefix + ".Grade", "Grade is required.");
            }

            if (!this.MinResult.HasValue)
            {
                modelState.AddModelError(modelPrefix + ".MinResult", "Minium required result is required.");
            }
            else
            {
                if (this.MinResult < 0)
                {
                    modelState.AddModelError(modelPrefix + ".MinResult", "Min result cannot be negative.");
                }

                if (totalMarks.HasValue && this.MinResult > totalMarks)
                {
                    modelState.AddModelError(modelPrefix + ".MinResult", "Min result must be less than total marks.");
                }
            }
        }

        public void AddModelError_WithErrorString_AddsTooManyModelErrors_WhenMaxErrorsIsReached()
        {
            // Arrange
            var expected = "The maximum number of allowed model errors has been reached.";
            var dictionary = new ModelStateDictionary
            {
                MaxAllowedErrors = 5
            };
            var provider = new EmptyModelMetadataProvider();
            var metadata = provider.GetMetadataForProperty(typeof(string), nameof(string.Length));
            dictionary.AddModelError("key1", "error1");
            dictionary.AddModelError("key2", new Exception(), metadata);
            dictionary.AddModelError("key3", new Exception(), metadata);
            dictionary.AddModelError("key4", "error4");
            dictionary.AddModelError("key5", "error5");

            // Act and Assert
            Assert.True(dictionary.HasReachedMaxErrors);
            Assert.Equal(5, dictionary.ErrorCount);
            var error = Assert.Single(dictionary[string.Empty].Errors);
            Assert.IsType<TooManyModelErrorsException>(error.Exception);
            Assert.Equal(expected, error.Exception.Message);

            // TooManyModelErrorsException added instead of key5 error.
            Assert.DoesNotContain("key5", dictionary.Keys);
        }

        public void Validate(ModelStateDictionary modelState, string prefix, decimal? totalMarks)
        {
            if (string.IsNullOrWhiteSpace(this.Surname))
            {
                modelState.AddModelError(prefix + ".Surname", "Surname cannot be blank.");
            }

            if (string.IsNullOrWhiteSpace(this.Forenames))
            {
                modelState.AddModelError(prefix + ".Forenames", "Forenames cannot be blank.");
            }

            if (!this.Result.HasValue)
            {
                return;
            }

            if (this.Result < 0)
            {
                modelState.AddModelError(prefix + ".Result", "Result must be a positive number.");
            }

            if (totalMarks.HasValue && this.Result > totalMarks)
            {
                modelState.AddModelError(prefix + ".Result", "Result cannot be greater than the total marks.");
            }
        }

        public void StartRegistrationForFamilyMember(int id, ModelStateDictionary modelState)
        {
            modelState.Clear(); // ensure we pull form fields from our model, not MVC's
            HistoryAdd("Register");
            int index = List.Count - 1;
            var p = LoadExistingPerson(id, index);

            if(p.NeedsToChooseClass())
                return;

            p.ValidateModelForFind(modelState, id, selectFromFamily: true);
            if (!modelState.IsValid)
                return;

            List[index] = p;

            if (p.ManageSubscriptions() && p.Found == true)
                return;

            if (p.org != null && p.Found == true)
            {
                if (!SupportMissionTrip)
                    p.IsFilled = p.org.RegLimitCount(DbUtil.Db) >= p.org.Limit;
                if (p.IsFilled)
                    modelState.AddModelError(this.GetNameFor(mm => mm.List[List.IndexOf(p)].Found),
                        "Sorry, but registration is filled.");
                if (p.Found == true)
                    p.FillPriorInfo();
                return;
            }
            if (p.org == null && p.ComputesOrganizationByAge())
                modelState.AddModelError(this.GetNameFor(mm => mm.List[id].Found), p.NoAppropriateOrgError);
        }

        public static void ValidateCreditCardInfo(ModelStateDictionary modelState, PaymentForm pf)
        {
            if (pf.SavePayInfo && pf.CreditCard.HasValue() && pf.CreditCard.StartsWith("X"))
                return;

            if (!ValidateCard(pf.CreditCard, pf.SavePayInfo))
            {
                modelState.AddModelError("CreditCard", "The card number is invalid.");
            }
            if (!pf.Expires.HasValue())
            {
                modelState.AddModelError("Expires", "The expiration date is required.");
                return;
            }

            var exp = DbUtil.NormalizeExpires(pf.Expires);
            if (exp == null)
                modelState.AddModelError("Expires", "The expiration date format is invalid (MMYY).");

            if (!pf.CVV.HasValue())
            {
                modelState.AddModelError("CVV", "The CVV is required.");
                return;
            }

            var cvvlen = pf.CVV.GetDigits().Length;
            if (cvvlen < 3 || cvvlen > 4)
                modelState.AddModelError("CVV", "The CVV must be a 3 or 4 digit number.");
        }

        public void WithModelStateForShouldThrowExceptionWhenModelStateHasSameErrors()
        {
            Test.AssertException<ModelErrorAssertionException>(
                () =>
                {
                    var requestModelWithErrors = TestObjectFactory.GetRequestModelWithErrors();
                    var modelState = new ModelStateDictionary();
                    modelState.AddModelError("Integer", "The field Integer must be between 1 and 2147483647.");
                    modelState.AddModelError("RequiredString", "The RequiredString field is required.");

                    MyController<MvcController>
                        .Instance()
                        .Calling(c => c.BadRequestWithModelState(requestModelWithErrors))
                        .ShouldReturn()
                        .BadRequest()
                        .WithModelStateError(modelStateError => modelStateError
                            .For<RequestModel>()
                            .ContainingErrorFor(m => m.Integer).ThatEquals("The field Integer 1 must be between 1 and 2147483647.")
                            .AndAlso()
                            .ContainingErrorFor(m => m.RequiredString).BeginningWith("The RequiredString")
                            .AndAlso()
                            .ContainingErrorFor(m => m.RequiredString).EndingWith("required.")
                            .AndAlso()
                            .ContainingErrorFor(m => m.RequiredString).Containing("field")
                            .AndAlso()
                            .ContainingNoErrorFor(m => m.NonRequiredString));
                },
                "When calling BadRequestWithModelState action in MvcController expected error message for key Integer to be 'The field Integer 1 must be between 1 and 2147483647.', but instead found 'The field Integer must be between 1 and 2147483647.'.");
        }

		public void Validate(ModelStateDictionary modelStateDictionary, IUserService userService, string ip)
		{
			if (!IsCoppa)
				modelStateDictionary.AddModelError("IsCoppa", Resources.MustBe13);
			if (!IsTos)
				modelStateDictionary.AddModelError("IsTos", Resources.MustAcceptTOS);
			userService.IsPasswordValid(Password, modelStateDictionary);
			if (Password != PasswordRetype)
				modelStateDictionary.AddModelError("PasswordRetype", Resources.RetypeYourPassword);
			if (String.IsNullOrWhiteSpace(Name))
				modelStateDictionary.AddModelError("Name", Resources.NameRequired);
			else if (userService.IsNameInUse(Name))
				modelStateDictionary.AddModelError("Name", Resources.NameInUse);
			if (String.IsNullOrWhiteSpace(Email))
				modelStateDictionary.AddModelError("Email", Resources.EmailRequired);
			else
				if (!Email.IsEmailAddress())
					modelStateDictionary.AddModelError("Email", Resources.ValidEmailAddressRequired);
				else if (Email != null && userService.IsEmailInUse(Email))
					modelStateDictionary.AddModelError("Email", Resources.EmailInUse);
			if (Email != null && userService.IsEmailBanned(Email))
				modelStateDictionary.AddModelError("Email", Resources.EmailBanned);
			if (userService.IsIPBanned(ip))
				modelStateDictionary.AddModelError("Email", Resources.IPBanned);
		}

        public void Validate(ModelStateDictionary mdlState)
        {
            base.Validate();

            foreach (var tags in _nameTags)
            {
                var error = tags.Value.ValidationError;
                if (error != null)
                {
                    var strError = string.Join(", ", error.Errors);
                    if (!string.IsNullOrWhiteSpace(strError))
                    {
                        if (tags.Value is DataObjectViewModel)
                        {
                            // Special case DatObject: remove any key
                            mdlState.AddModelError("", strError);
                        }
                        else
                        {
                            mdlState.AddModelError(tags.Key, strError);
                        }
                    }
                }
            }
        }

        public SignUpViewModel SignUp(SignUpActionData actionData)
        {
            var viewModel = new SignUpViewModel();

            var modelStates = new ModelStateDictionary();

            foreach (var reason in actionData.RegistrationFailureReasons) {
                switch (reason) {
                    case RegistrationFailureReason.UsernameNotAvailable:
                        modelStates.AddModelError("username", GetRegistrationFailureReasonText(RegistrationFailureReason.UsernameNotAvailable));
                        break;
                    case RegistrationFailureReason.PasswordsDoNotMatch:
                        modelStates.AddModelError("passwordConfirmation", GetRegistrationFailureReasonText(RegistrationFailureReason.PasswordsDoNotMatch));
                        break;
                    case RegistrationFailureReason.EmailsDoNotMatch:
                        modelStates.AddModelError("email", GetRegistrationFailureReasonText(RegistrationFailureReason.EmailsDoNotMatch));
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
            }

            IEnumerable<string> errors = actionData.RegistrationFailureReasons.Select(GetRegistrationFailureReasonText);
            viewModel.Errors = errors;
            viewModel.ModelState = modelStates;
            return viewModel;
        }

 public static bool IsValidEmailField(ModelStateDictionary modelState, string display, string field, string value, int maxLength, bool required = false)
 {
     bool ret = false;
     if (value.IsNullOrEmpty())
     {
         if (required)
         {
             modelState.AddModelError(field, "กรุณาใส่" + display);
         }
         else
         {
             ret = true;
         }
     }
     else if (value.Length > maxLength)
     {
         modelState.AddModelError(field, string.Format("{0}ต้องมีความยาวไม่เกิน {1} ตัวอักษร", display, maxLength));
     }
     else if (!new EmailAddressAttribute().IsValid(value))
     {
         modelState.AddModelError(field, string.Format("{0}มีรูปแบบไม่ถูกต้อง", display));
     }
     else
     {
         ret = true;
     }
     return ret;
 }

 public static void ValidateBankAccountInfo(ModelStateDictionary ModelState, string Routing, string Account)
 {
     if (!checkABA(Routing))
         ModelState.AddModelError("Routing", "invalid routing number");
     if (!Account.HasValue())
         ModelState.AddModelError("Account", "need account number");
     else if (!Account.StartsWith("X") && Account.Length <= 4)
         ModelState.AddModelError("Account", "please enter entire account number with any leading zeros");
 }

        public static void HandleErrorDict(ModelStateDictionary stateDictionary, Dictionary<string, string> validationsDictionary)
        {
            if (validationsDictionary.Any()) {
                stateDictionary.AddModelError(String.Empty, "Please review and correct the noted errors.");
            }

            foreach (KeyValuePair<string, string> valuePair in validationsDictionary) {
                stateDictionary.AddModelError(valuePair.Key, valuePair.Value);
            }
        }