AssessmentAnywhere.Models.AssessmentGradeBoundaries.UpdateModel.Validate C# (CSharp) Метод

        public void Validate(ModelStateDictionary modelState)
        {
            if (TotalMarks.HasValue && TotalMarks < 0)
            {
                modelState.AddModelError("TotalMarks", "Total marks must be a positive number");
            }

            if (HasNewBoundary)
            {
                NewBoundary.Validate(modelState, "NewBoundary", TotalMarks);

                if (this.Boundaries.Any(b => b.Grade == NewBoundary.Grade))
                {
                    modelState.AddModelError("NewBoundary.Grade", "Boundary grade must be unique.");
                }

                if (this.Boundaries.Any(b => b.MinResult == NewBoundary.MinResult))
                {
                    modelState.AddModelError("NewBoundary.MinResult", "Boundary minimum required result must be unique.");
                }
            }

            for (int i = 0; i < Boundaries.Count; i++)
            {
                var prefix = string.Format("Boundaries[{0}]", i);
                Boundaries[i].Validate(modelState, prefix, TotalMarks);
            }

            var duplicateGrades = this.Boundaries.Where(b1 => this.Boundaries.Count(b2 => b2.Grade == b1.Grade) > 1);
            foreach (var duplicateGrade in duplicateGrades)
            {
                var i = this.Boundaries.IndexOf(duplicateGrade);
                var key = string.Format("Boundaries[{0}].Grade", i);
                modelState.AddModelError(key, "Boundary grade must be unique.");
            }

            var duplicateMinResults =
                this.Boundaries.Where(b1 => this.Boundaries.Count(b2 => b2.MinResult == b1.MinResult) > 1);
            foreach (var duplicateMinResult in duplicateMinResults)
            {
                var i = this.Boundaries.IndexOf(duplicateMinResult);
                var key = string.Format("Boundaries[{0}].MinResult", i);
                modelState.AddModelError(key, "Boundary minimum required result must be unique.");
            }
        }

        public ActionResult Update(Guid id, UpdateModel model)
        {
            // Validate
            model.Validate(this.ModelState);

            var assessment = this.assessmentsRepo.Open(id);

            if (!ModelState.IsValid)
            {
                var editBoundaries = model.Boundaries.Select(b => new GradeBoundary(b.Grade, b.MinResult)).ToList();
                var newBoundary = (model.NewBoundary == null)
                                      ? GradeBoundary.New
                                      : new GradeBoundary(model.NewBoundary.Grade, model.NewBoundary.MinResult);
                var viewModel = new EditModel(id, assessment.Name, model.TotalMarks, editBoundaries, newBoundary);

                return this.View("Edit", viewModel);
            }

            // ReSharper disable PossibleInvalidOperationException
            var boundariesToSave = model.Boundaries.Select(b => new Boundary(b.Grade, b.MinResult.Value)).ToList();
            if (model.HasNewBoundary)
            {
                boundariesToSave.Add(new Boundary(model.NewBoundary.Grade, model.NewBoundary.MinResult.Value));
            }
            // ReSharper restore PossibleInvalidOperationException

            // Write changes to repos.
            bool hasBoundaries;
            var boundaries = this.gradeBoundariesRepo.TryOpen(id, out hasBoundaries);

            if (!hasBoundaries)
            {
                boundaries = this.gradeBoundariesRepo.Create(id);
            }

            if (model.TotalMarks != assessment.TotalMarks)
            {
                assessment.SetTotalMarks(model.TotalMarks);
            }

            boundaries.SetBoundaries(boundariesToSave);

            return this.RedirectToAction("Edit", new { id });
        }