private void Validate(INakedObject adapter)
 {
     if (adapter.Spec.ContainsFacet <IValidateProgrammaticUpdatesFacet>())
     {
         string state = adapter.ValidToPersist();
         if (state != null)
         {
             throw new PersistFailedException(string.Format(Resources.NakedObjects.PersistStateError, adapter.Spec.ShortName, adapter.TitleString(), state));
         }
     }
 }
Example #2
0
        public string ValidToPersist()
        {
            var objectSpec = Spec as IObjectSpec;

            Trace.Assert(objectSpec != null);

            IAssociationSpec[] properties = objectSpec.Properties;
            foreach (IAssociationSpec property in properties)
            {
                INakedObject referencedObject = property.GetNakedObject(this);
                if (property.IsUsable(this).IsAllowed&& property.IsVisible(this))
                {
                    if (property.IsMandatory && property.IsEmpty(this))
                    {
                        return(string.Format(Resources.NakedObjects.PropertyMandatory, objectSpec.ShortName, property.Name));
                    }
                    var associationSpec = property as IOneToOneAssociationSpec;
                    if (associationSpec != null)
                    {
                        IConsent valid = associationSpec.IsAssociationValid(this, referencedObject);
                        if (valid.IsVetoed)
                        {
                            return(string.Format(Resources.NakedObjects.PropertyInvalid, objectSpec.ShortName, associationSpec.Name, valid.Reason));
                        }
                    }
                }
                if (property is IOneToOneAssociationSpec)
                {
                    if (referencedObject != null && referencedObject.ResolveState.IsTransient())
                    {
                        string referencedObjectMessage = referencedObject.ValidToPersist();
                        if (referencedObjectMessage != null)
                        {
                            return(referencedObjectMessage);
                        }
                    }
                }
            }

            var validateFacet = objectSpec.GetFacet <IValidateObjectFacet>();

            return(validateFacet == null ? null : validateFacet.Validate(this));
        }
Example #3
0
 private  bool IsReferenceValidToPersist(INakedObject target1) {
     if (target1.ResolveState.IsTransient() ||
         (target1.Oid is AggregateOid && ((AggregateOid)target1.Oid).ParentOid.IsTransient)) {
         string validToPersist = target1.ValidToPersist();
         if (validToPersist != null) {
             ModelState.AddModelError("", validToPersist);
             return false;
         }
     }
     return true;
 }
Example #4
0
        internal bool ValidateChanges(INakedObject nakedObject, ObjectAndControlData controlData, INakedObjectAssociation parent = null) {
            List<INakedObjectAssociation> usableAndVisibleFields;
            List<Tuple<INakedObjectAssociation, object>> fieldsAndMatchingValues;
            GetUsableAndVisibleFields(nakedObject, controlData, parent, out usableAndVisibleFields, out fieldsAndMatchingValues);

            CheckConcurrency(nakedObject, parent, controlData, GetConcurrencyFieldInputId);

            fieldsAndMatchingValues.ForEach(pair => AddAttemptedValue(GetFieldInputId(parent, nakedObject, pair.Item1), pair.Item2));

            // check mandatory fields first to emulate WPF UI behaviour where no validation takes place until 
            // all mandatory fields are set. 
            foreach (var pair in fieldsAndMatchingValues) {
                var result = pair.Item2;
                var stringResult = result as string;

                if (pair.Item1.IsMandatory && (result == null || (result is string && string.IsNullOrEmpty(stringResult)))) {
                    AddErrorAndAttemptedValue(nakedObject, stringResult, pair.Item1, MvcUi.Mandatory, parent);
                }
            }

            if (ModelState.IsValid) {
                ValidateOrApplyInlineChanges(nakedObject, controlData, usableAndVisibleFields, ValidateChanges);
            }

            if (ModelState.IsValid) {
                foreach (var pair in fieldsAndMatchingValues) {
                    if (!pair.Item1.IsCollection) {
                        ValidateAssociation(nakedObject, (IOneToOneAssociation) pair.Item1, pair.Item2, parent);
                    }
                }
            }

            if (ModelState.IsValid) {
                INakedObjectValidation[] validators = nakedObject.Specification.ValidateMethods();

                foreach (INakedObjectValidation validator in validators) {
                    string[] parmNames = validator.ParameterNames;
                 
                    var matchingparms = parmNames.Select(pn => fieldsAndMatchingValues.Single(t => t.Item1.Id.ToLower() == pn)).ToList();

                    if (matchingparms.Count() == parmNames.Count()) {
                        string result = validator.Execute(nakedObject, matchingparms.Select(t => GetNakedObjectValue(t.Item1, nakedObject, t.Item2)).ToArray());

                        if (!string.IsNullOrEmpty(result)) {                         
                            ModelState.AddModelError(string.Empty, result);
                        }
                    }
                }
            }

            if (ModelState.IsValid) {
                if (nakedObject.Specification.ContainsFacet<IValidateProgrammaticUpdatesFacet>()) {
                    string state = nakedObject.ValidToPersist();
                    if (state != null) {
                        ModelState.AddModelError(string.Empty, state);
                    }
                }
            }

            return ModelState.IsValid;
        }