public PropertyContext(object target, INakedObjectAssociation property, bool isEdit, PropertyContext parentContext = null) : base(target) { Property = property; IsPropertyEdit = isEdit; IsEdit = isEdit; ParentContext = parentContext; }
private static string GetFieldInputId(INakedObject nakedObject, INakedObjectAssociation property) { string fieldId; if (nakedObject.Oid is AggregateOid) { var aoid = ((AggregateOid) nakedObject.Oid); INakedObjectAssociation parent = aoid.ParentOid.Specification.Properties.Where(p => p.Id == aoid.FieldName).SingleOrDefault(); fieldId = IdHelper.GetInlineFieldInputId(parent, nakedObject, property); } else { fieldId = IdHelper.GetFieldInputId(nakedObject, property); } return fieldId; }
private static INakedObject SetupReference(INakedObjectAssociation field, IOid referenceOid, Data fieldData, INakedObject nakedObject) { Log.DebugFormat("Setting up field {0} with {1}", field, referenceOid); INakedObject reference = null; if (fieldData == null) { INakedObject adapter = PersistorUtils.RecreateInstance(referenceOid, field.Specification); if (!adapter.ResolveState.IsDestroyed()) { nakedObject.ResolveState.Handle(Events.DestroyEvent); } ((IOneToOneAssociation)field).InitAssociation(nakedObject, adapter); Log.Warn("No data found for " + referenceOid + " so field '" + field.Name + "' not set in object '" + nakedObject + "'"); } else { reference = PersistorUtils.RecreateInstance(referenceOid, SpecFor(fieldData)); ((IOneToOneAssociation)field).InitAssociation(nakedObject, reference); } return(reference); }
private static void InitInlineObjectSetupReference(INakedObject nakedObject, ObjectData data, INakedObjectAssociation field) { var fieldData = (Data)data.GetField(field.Id); IOid referenceOid = fieldData.Oid; INakedObject reference = SetupReference(field, referenceOid, fieldData, nakedObject); Persistor.InitInlineObject(nakedObject.Object, reference.Object); }
public int CountField(INakedObject nakedObject, INakedObjectAssociation association) { return(association.GetNakedObject(nakedObject).GetAsEnumerable().Count()); }
public NakedObjectAssociationWrapper(INakedObjectAssociation assoc, INakedObjectsSurface surface) { this.assoc = assoc; Surface = surface; }
public void SetupFields(INakedObjectAssociation[] fields) { assocs = fields; }
internal void ValidateAssociation(INakedObject nakedObject, IOneToOneAssociation oneToOneAssoc, object attemptedValue, INakedObjectAssociation parent = null) { string key = GetFieldInputId(parent, nakedObject, oneToOneAssoc); try { INakedObject valueNakedObject = GetNakedObjectValue(oneToOneAssoc, nakedObject, attemptedValue); IConsent consent = oneToOneAssoc.IsAssociationValid(nakedObject, valueNakedObject); if (!consent.IsAllowed) { ModelState.AddModelError(key, consent.Reason); } } catch (InvalidEntryException) { ModelState.AddModelError(key, MvcUi.InvalidEntry); } catch (ArgumentException) { // Always expect newValue to be non-null for a parseable field as it should always be included // in the form so this is an unexpected result for a parseable field ModelState.AddModelError(key, MvcUi.InvalidEntry); } finally { AddAttemptedValue(key, attemptedValue); } }
internal void RefreshTransient(INakedObject nakedObject, FormCollection form, INakedObjectAssociation parent = null) { if (nakedObject.Oid.IsTransient) { // use oid to catch transient aggregates foreach (INakedObjectAssociation assoc in nakedObject.Specification.Properties.Where(p => !p.IsReadOnly)) { // TODO change this to use GetValueFromForm foreach (string item in form.AllKeys) { string name = GetFieldInputId(parent, nakedObject, assoc); if (name == item) { object newValue = ((string[]) form.GetValue(item).RawValue).First(); if (assoc.Specification.IsParseable) { try { var oneToOneAssoc = ((IOneToOneAssociation) assoc); INakedObject value = assoc.Specification.GetFacet<IParseableFacet>().ParseTextEntry((string) newValue); oneToOneAssoc.SetAssociation(nakedObject, value); } catch (InvalidEntryException) { ModelState.AddModelError(name, MvcUi.InvalidEntry); } } else if (assoc.IsObject) { INakedObject value = FrameworkHelper.GetNakedObjectFromId((string) newValue); var oneToOneAssoc = ((IOneToOneAssociation) assoc); oneToOneAssoc.SetAssociation(nakedObject, value); } } } } foreach (IOneToManyAssociation assoc in nakedObject.Specification.Properties.Where(p => p.IsCollection)) { string name = IdHelper.GetCollectionItemId(nakedObject, assoc); ValueProviderResult items = form.GetValue(name); if (items != null && assoc.Count(nakedObject) == 0) { var itemIds = (string[]) items.RawValue; var values = itemIds.Select(FrameworkHelper.GetNakedObjectFromId).ToArray(); var collection = assoc.GetNakedObject(nakedObject); collection.Specification.GetFacet<ICollectionFacet>().Init(collection, values); } } foreach (INakedObjectAssociation assoc in nakedObject.Specification.Properties.Where(p => p.IsInline)) { var inlineNakedObject = assoc.GetNakedObject(nakedObject); RefreshTransient(inlineNakedObject, form, assoc); } } }
public static string GetInlineFieldId( INakedObjectAssociation parent, INakedObject owner, INakedObjectAssociation assoc) { return parent.Id + sep + GetObjectId(owner) + sep + assoc.Id; }
internal void AddAttemptedValues(INakedObject nakedObject, ObjectAndControlData controlData, INakedObjectAssociation parent = null) { foreach (INakedObjectAssociation assoc in nakedObject.Specification.Properties.Where(p => (IsUsable(p, nakedObject) && IsVisible(p, nakedObject)) || IsConcurrency(p))) { string name = GetFieldInputId(parent, nakedObject, assoc); string value = GetValueFromForm(controlData, name) as string; if (value != null) { AddAttemptedValue(name, value); } } foreach (INakedObjectAssociation assoc in nakedObject.Specification.Properties.Where(IsConcurrency)) { string name = GetConcurrencyFieldInputId(parent, nakedObject, assoc); string value = GetValueFromForm(controlData, name) as string; if (value != null) { AddAttemptedValue(name, value); } } foreach (INakedObjectAssociation assoc in nakedObject.Specification.Properties.Where(p => p.IsInline)) { var inlineNakedObject = assoc.GetNakedObject(nakedObject); AddAttemptedValues(inlineNakedObject, controlData, assoc); } }
public static string GetConcurrencyActionInputId(INakedObject owner, INakedObjectAction action, INakedObjectAssociation assoc) { return GetActionId(owner, action) + sep + assoc.Id + sep + concurrencyName; }
public static string GetInlineConcurrencyFieldInputId(INakedObjectAssociation parent, INakedObject owner, INakedObjectAssociation assoc) { return GetInlineFieldId(parent, owner, assoc) + sep + concurrencyName; }
public static string GetConcurrencyFieldInputId(INakedObject owner, INakedObjectAssociation assoc) { return GetFieldId(owner, assoc) + sep + concurrencyName; }
public static string GetInlineFieldInputId(INakedObjectAssociation parent, INakedObject owner, INakedObjectAssociation assoc) { return GetInlineFieldId(parent, owner, assoc) + sep + InputOrSelect(assoc.Specification); }
public static string GetFieldAutoCompleteId(string id, INakedObject owner, INakedObjectAssociation assoc) { return assoc.Specification.IsParseable ? id : id + sep + autoCompleteName; }
internal static bool IsVisible(INakedObjectAssociation assoc, INakedObject nakedObject) { return assoc.IsVisible(NakedObjectsContext.Session, nakedObject); }
public static string GetCollectionItemId(INakedObject owner, INakedObjectAssociation assoc) { return GetObjectId(owner) + sep + assoc.Id + sep + "Item"; }
public static string GetFieldId(INakedObject owner, INakedObjectAssociation assoc) { return GetObjectId(owner) + sep + assoc.Id; }
internal static bool IsUsable(INakedObjectAssociation assoc, INakedObject nakedObject) { return assoc.IsUsable(NakedObjectsContext.Session, nakedObject).IsAllowed; }
public string GetConcurrencyActionInputId(INakedObjectAssociation nakedObjectAssociation) { return IdHelper.GetConcurrencyActionInputId(Target, Action, nakedObjectAssociation); }
internal static bool IsConcurrency(INakedObjectAssociation assoc) { return assoc.ContainsFacet<IConcurrencyCheckFacet>(); }
internal static INakedObject GetNakedObjectValue(INakedObjectAssociation assoc, INakedObject targetNakedObject, object value) { if (value == null) { return null; } var fromStreamFacet = assoc.Specification.GetFacet<IFromStreamFacet>(); if (fromStreamFacet != null) { var httpPostedFileBase = (HttpPostedFileBase)value; return fromStreamFacet.ParseFromStream(httpPostedFileBase.InputStream, httpPostedFileBase.ContentType, httpPostedFileBase.FileName); } var stringValue = value as string; if (assoc.Specification.IsParseable) { return assoc.Specification.GetFacet<IParseableFacet>().ParseTextEntry(stringValue); } if (assoc.IsObject) { return FrameworkHelper.GetNakedObjectFromId(stringValue); } // collection return null; }
private static string GetConcurrencyFieldInputId(INakedObjectAssociation parent, INakedObject nakedObject, INakedObjectAssociation assoc) { return parent == null ? IdHelper.GetConcurrencyFieldInputId(nakedObject, assoc) : IdHelper.GetInlineConcurrencyFieldInputId(parent, nakedObject, assoc); }
internal void CheckConcurrency(INakedObject nakedObject, INakedObjectAssociation parent, ObjectAndControlData controlData, Func<INakedObjectAssociation, INakedObject, INakedObjectAssociation, string> idFunc) { var concurrencyFields = nakedObject.Specification.Properties.Where(p => p.ContainsFacet<IConcurrencyCheckFacet>()).ToList(); if (!nakedObject.ResolveState.IsTransient() && concurrencyFields.Any() ) { IEnumerable<Tuple<INakedObjectAssociation, object>> fieldsAndMatchingValues = GetFieldsAndMatchingValues(nakedObject, parent, concurrencyFields, controlData, idFunc); foreach (var pair in fieldsAndMatchingValues) { if (pair.Item1.Specification.IsParseable) { INakedObject currentValue = pair.Item1.GetNakedObject(nakedObject); INakedObject concurrencyValue = pair.Item1.Specification.GetFacet<IParseableFacet>().ParseInvariant(pair.Item2 as string); if (concurrencyValue != null && currentValue != null) { if (concurrencyValue.TitleString() != currentValue.TitleString()) { throw new ConcurrencyException(nakedObject, null); } } else if (concurrencyValue == null && currentValue == null) { // OK } else { throw new ConcurrencyException(nakedObject, null); } } } } }
public ITestProperty CreateTestProperty(INakedObjectAssociation field, ITestHasActions owningObject) { return new TestProperty(field, owningObject, this); }
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; }
public static INakedObject CreateAggregatedAdapterClone(INakedObject parent, INakedObjectAssociation field, object obj) { return CreateAggregatedAdapter(parent, field.Id + ":CLONE", obj); }
private static void GetUsableAndVisibleFields(INakedObject nakedObject, ObjectAndControlData controlData, INakedObjectAssociation parent, out List<INakedObjectAssociation> usableAndVisibleFields, out List<Tuple<INakedObjectAssociation, object>> fieldsAndMatchingValues) { usableAndVisibleFields = nakedObject.Specification.Properties.Where(p => IsUsable(p, nakedObject) && IsVisible(p, nakedObject)).ToList(); fieldsAndMatchingValues = GetFieldsAndMatchingValues(nakedObject, parent, usableAndVisibleFields, controlData, GetFieldInputId).ToList(); }
/* * The ObjectData holds all references for internal collections, so the object should haves its internal * collection populated by this method. */ public virtual void ResolveField(INakedObject nakedObject, INakedObjectAssociation field) { Log.DebugFormat("ResolveField nakedobject: {0} field: {1}", nakedObject, field); field.GetNakedObject(nakedObject); ResolveImmediately(nakedObject); }
internal bool ApplyChanges(INakedObject nakedObject, ObjectAndControlData controlData, INakedObjectAssociation parent = null) { List<INakedObjectAssociation> usableAndVisibleFields; List<Tuple<INakedObjectAssociation, object>> fieldsAndMatchingValues; GetUsableAndVisibleFields(nakedObject, controlData, parent, out usableAndVisibleFields, out fieldsAndMatchingValues); foreach (var pair in fieldsAndMatchingValues) { INakedObject value = GetNakedObjectValue(pair.Item1, nakedObject, pair.Item2); if (!pair.Item1.IsCollection) { SetAssociation(nakedObject, (IOneToOneAssociation)pair.Item1, value, pair.Item2); } } ValidateOrApplyInlineChanges(nakedObject, controlData, nakedObject.Specification.Properties, ApplyChanges); if (nakedObject.ResolveState.IsTransient()) { CanPersist(nakedObject, usableAndVisibleFields); if (ModelState.IsValid) { if (nakedObject.Specification.Persistable == Persistable.USER_PERSISTABLE) { NakedObjectsContext.ObjectPersistor.MakePersistent(nakedObject); } else { NakedObjectsContext.ObjectPersistor.ObjectChanged(nakedObject); } } } return ModelState.IsValid; }
private static void InitEncodeable(INakedObject nakedObject, ObjectData data, INakedObjectAssociation field, INakedObjectSpecification fieldSpecification) { INakedObject nakedObjectValue; string valueData = data.Value(field.Id); if (valueData == null || valueData.Equals("NULL")) { nakedObjectValue = null; } else { nakedObjectValue = fieldSpecification.GetFacet <IEncodeableFacet>().FromEncodedString(valueData); } ((IOneToOneAssociation)field).InitAssociation(nakedObject, nakedObjectValue); }
private static IEnumerable<Tuple<INakedObjectAssociation, object>> GetFieldsAndMatchingValues(INakedObject nakedObject, INakedObjectAssociation parent, IEnumerable<INakedObjectAssociation> associations, ObjectAndControlData controlData, Func<INakedObjectAssociation, INakedObject, INakedObjectAssociation, string> idFunc) { foreach (INakedObjectAssociation assoc in associations.Where(a => !a.IsInline)) { string name = idFunc(parent, nakedObject, assoc); object newValue = GetValueFromForm(controlData, name); yield return new Tuple<INakedObjectAssociation, object>(assoc, newValue); } }
private void InitObjectSetupReference(INakedObject nakedObject, ObjectData data, INakedObjectAssociation field) { var referenceOid = (IOid)data.GetField(field.Id); if (referenceOid != null) { Data fieldData = dataManager.LoadData(referenceOid); INakedObject reference = SetupReference(field, referenceOid, fieldData, nakedObject); } }
internal void AddErrorAndAttemptedValue(INakedObject nakedObject, string newValue, INakedObjectAssociation assoc, string errorText, INakedObjectAssociation parent = null) { string key = GetFieldInputId(parent, nakedObject, assoc); ModelState.AddModelError(key, errorText); AddAttemptedValue(key, assoc.Specification.IsParseable ? (object)newValue : FrameworkHelper.GetNakedObjectFromId(newValue)); }
private void InitObjectSetupCollection(INakedObject nakedObject, ObjectData data, INakedObjectAssociation field) { /* * The internal collection is already a part of the object, and therefore cannot be recreated, but its * oid must be set */ IList <IOid> refs = (IList <IOid>)data.GetField(field.Id) ?? new List <IOid>(); INakedObject collection = field.GetNakedObject(nakedObject); collection.ResolveState.Handle(Events.StartResolvingEvent); var elements = new List <INakedObject>(); foreach (IOid elementOid in refs) { INakedObject adapter = Persistor.GetAdapterFor(elementOid) ?? GetObject(elementOid, null); elements.Add(adapter); } ICollectionFacet facet = collection.GetCollectionFacetFromSpec(); facet.Init(collection, elements.ToArray()); collection.ResolveState.Handle(Events.EndResolvingEvent); }
public INakedObject GetField(INakedObjectAssociation field) { return fieldContents[field.Id]; }