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];
}
