protected string DisplaySingleProperty(ObjectAndControlData controlData, IDictionary <string, string> data)
{
if (Request.IsAjaxRequest())
{
var nakedObject = controlData.GetNakedObject(Facade);
if (controlData.SubAction == ObjectAndControlData.SubActionType.Redisplay)
{
var assocs = nakedObject.Specification.Properties.Where(p => p.IsCollection && !p.Specification.IsParseable);
var item = assocs.SingleOrDefault(a => data.ContainsKey(a.Id));
return(item == null ? null : item.Id);
}
if (controlData.ActionId == null)
{
var assocs = nakedObject.Specification.Properties.Where(p => !p.IsCollection || p.Specification.IsParseable);
var item = assocs.SingleOrDefault(a => data.ContainsKey(a.Id));
return(item == null ? null : item.Id);
}
{
var parms = controlData.GetAction(Facade).Parameters;
var item = parms.SingleOrDefault(p => data.ContainsKey(p.Id));
return(item == null ? null : item.Id);
}
}
return(null);
}
private ActionResult SelectOnAction(ObjectAndControlData controlData)
{
IActionSpec nakedObjectAction = controlData.GetAction(NakedObjectsContext);
INakedObject contextNakedObject = FilterCollection(controlData.GetNakedObject(NakedObjectsContext), controlData);
return(SelectSingleItem(contextNakedObject, nakedObjectAction, controlData, controlData.DataDict));
}
public virtual ActionResult EditObject(ObjectAndControlData controlData, FormCollection form)
{
Decrypt(form);
controlData.Form = form;
var nakedObject = controlData.GetNakedObject(Facade);
SetExistingCollectionFormats(form);
if (nakedObject.IsNotPersistent)
{
RefreshTransient(nakedObject, form);
}
switch (controlData.SubAction)
{
case (ObjectAndControlData.SubActionType.Action):
SetNewCollectionFormats(controlData);
return(ActionOnNotPersistentObject(controlData));
case (ObjectAndControlData.SubActionType.None):
AddAttemptedValuesNew(nakedObject, controlData);
return(View("ObjectEdit", nakedObject.GetDomainObject()));
case (ObjectAndControlData.SubActionType.Pager):
SetNewCollectionFormats(controlData);
return(AppropriateView(controlData, nakedObject));
case (ObjectAndControlData.SubActionType.Redisplay):
return(Redisplay(controlData));
}
Log.ErrorFormat("SubAction handling not implemented in EditObject for {0}", controlData.SubAction.ToString());
throw new NotImplementedException(controlData.SubAction.ToString());
}
private ActionResult ApplyEdit(ObjectAndControlData controlData)
{
var nakedObject = controlData.GetNakedObject(Facade);
var viewName = ApplyEdit(nakedObject, controlData) ? "ObjectView" : "ObjectEdit";
return(View(viewName, nakedObject.GetDomainObject()));
}
private ActionResult Find(ObjectAndControlData controlData)
{
string spec = controlData.DataDict["spec"];
string contextObjectId = controlData.DataDict["contextObjectId"];
string propertyName = controlData.DataDict["propertyName"];
string contextActionId = controlData.DataDict["contextActionId"];
var objectSet = Session.CachedObjectsOfType(Facade, Facade.GetDomainType(spec)).ToList();
if (!objectSet.Any())
{
Log.InfoFormat("No Cached objects of type {0} found", spec);
Facade.MessageBroker.AddWarning("No objects of appropriate type viewed recently");
}
var contextNakedObject = FilterCollection(GetNakedObjectFromId(contextObjectId), controlData);
var contextAction = string.IsNullOrEmpty(contextActionId) ? null : contextNakedObject.Specification.GetActionLeafNodes().Single(a => a.Id == contextActionId);
if (objectSet.Count == 1)
{
var selectedItem = new Dictionary <string, string> {
{ propertyName, GetObjectId(objectSet.Single()) }
};
return(SelectSingleItem(contextNakedObject, contextAction, controlData, selectedItem));
}
return(View(Request.IsAjaxRequest() ? "PropertyEdit" : "FormWithSelections", new FindViewModel {
ActionResult = objectSet, ContextObject = contextNakedObject.GetDomainObject(), ContextAction = contextAction, PropertyName = propertyName
}));
}
private ActionResult ActionOnNotPersistentObject(ObjectAndControlData controlData)
{
string targetActionId = controlData.DataDict["targetActionId"];
string targetObjectId = controlData.DataDict["targetObjectId"];
INakedObject targetNakedObject = NakedObjectsContext.GetNakedObjectFromId(targetObjectId);
if (targetNakedObject.Spec.IsCollection)
{
INakedObject filteredNakedObject = FilterCollection(targetNakedObject, controlData);
var metamodel = NakedObjectsContext.MetamodelManager.Metamodel;
IObjectSpecImmutable elementSpecImmut =
filteredNakedObject.Spec.GetFacet <ITypeOfFacet>().GetValueSpec(filteredNakedObject, metamodel);
var elementSpec = NakedObjectsContext.MetamodelManager.GetSpecification(elementSpecImmut) as IObjectSpec;
Trace.Assert(elementSpec != null);
var targetAction = elementSpec.GetCollectionContributedActions().Single(a => a.Id == targetActionId);
if (!filteredNakedObject.GetAsEnumerable(NakedObjectsContext.NakedObjectManager).Any())
{
NakedObjectsContext.MessageBroker.AddWarning("No objects selected");
return(AppropriateView(controlData, targetNakedObject, targetAction));
}
// force any result to not be queryable
filteredNakedObject.SetNotQueryable(true);
return(ExecuteAction(controlData, filteredNakedObject, targetAction));
}
else
{
var targetAction = NakedObjectsContext.GetActions(targetNakedObject).Single(a => a.Id == targetActionId);
return(ExecuteAction(controlData, targetNakedObject, targetAction));
}
}
private ActionResult ApplyAction(ObjectAndControlData controlData)
{
var targetNakedObject = FilterCollection(controlData.GetNakedObject(NakedObjectsContext), controlData);
var targetAction = controlData.GetAction(NakedObjectsContext);
CheckConcurrency(targetNakedObject, null, controlData, (z, x, y) => IdHelper.GetConcurrencyActionInputId(x, targetAction, y));
if (targetNakedObject.IsNotPersistent())
{
RefreshTransient(targetNakedObject, controlData.Form);
}
// do after any parameters set by contributed action so this takes priority
SetSelectedParameters(targetAction);
if (ValidateParameters(targetNakedObject, targetAction, controlData))
{
targetNakedObject.SetNotQueryable(targetAction.IsContributedMethod);
var parms = GetParameterValues(targetAction, controlData);
return(AppropriateView(controlData, Execute(targetAction, targetNakedObject, parms.ToArray()), targetAction));
}
var property = DisplaySingleProperty(controlData, controlData.DataDict);
return(View(property == null ? "ActionDialog" : "PropertyEdit", new FindViewModel {
ContextObject = targetNakedObject.Object, ContextAction = targetAction, PropertyName = property
}));
}
public virtual ActionResult Details(ObjectAndControlData controlData, FormCollection form)
{
Decrypt(form);
controlData.Form = form;
Debug.Assert(controlData.SubAction == ObjectAndControlData.SubActionType.Redisplay ||
controlData.SubAction == ObjectAndControlData.SubActionType.Details ||
controlData.SubAction == ObjectAndControlData.SubActionType.Cancel ||
controlData.SubAction == ObjectAndControlData.SubActionType.None);
var nakedObject = FilterCollection(controlData.GetNakedObject(Facade), controlData);
SetExistingCollectionFormats(form);
SetNewCollectionFormats(controlData);
nakedObject.SetIsNotQueryableState(true);
if (controlData.SubAction == ObjectAndControlData.SubActionType.Cancel && nakedObject.IsTransient && nakedObject.IsUserPersistable)
{
// remove from cache and return to last object
Session.RemoveFromCache(Facade, nakedObject, ObjectCache.ObjectFlag.BreadCrumb);
return(AppropriateView(controlData, null));
}
string property = DisplaySingleProperty(controlData, controlData.DataDict);
return(AppropriateView(controlData, nakedObject, null, property));
}
public virtual ActionResult Action(ObjectAndControlData controlData)
{
return(View("ActionDialog", new FindViewModel {
ContextObject = controlData.GetNakedObject(NakedObjectsContext).Object,
ContextAction = controlData.GetAction(NakedObjectsContext)
}));
}
internal void AddAttemptedValuesNew(IObjectFacade nakedObject, ObjectAndControlData controlData, IAssociationFacade parent = null)
{
foreach (var assoc in nakedObject.Specification.Properties.Where(p => p.IsUsable(nakedObject).IsAllowed&& p.IsVisible(nakedObject) || p.IsConcurrency))
{
string name = GetFieldInputId(parent, nakedObject, assoc);
string value = GetValueFromForm(controlData, name) as string;
if (value != null)
{
AddAttemptedValue(name, value);
}
}
foreach (var assoc in nakedObject.Specification.Properties.Where(p => p.IsConcurrency))
{
string name = GetConcurrencyFieldInputId(parent, nakedObject, assoc);
string value = GetValueFromForm(controlData, name) as string;
if (value != null)
{
AddAttemptedValue(name, value);
}
}
foreach (var assoc in (nakedObject.Specification.Properties.Where(p => p.IsInline)))
{
var inlineNakedObject = assoc.GetValue(nakedObject);
AddAttemptedValuesNew(inlineNakedObject, controlData, assoc);
}
}
private ActionResult ActionOnNotPersistentObject(ObjectAndControlData controlData)
{
string targetActionId = controlData.DataDict["targetActionId"];
string targetObjectId = controlData.DataDict["targetObjectId"];
var targetNakedObject = GetNakedObjectFromId(targetObjectId);
if (targetNakedObject.Specification.IsCollection)
{
var filteredNakedObject = FilterCollection(targetNakedObject, controlData);
var elementSpec = targetNakedObject.ElementSpecification;
Trace.Assert(elementSpec != null);
var targetAction = elementSpec.GetCollectionContributedActions().Single(a => a.Id == targetActionId);
if (!filteredNakedObject.ToEnumerable().Any())
{
Facade.MessageBroker.AddWarning("No objects selected");
return(AppropriateView(controlData, targetNakedObject));
}
// force any result to not be queryable
filteredNakedObject.SetIsNotQueryableState(true);
return(ExecuteAction(controlData, filteredNakedObject, targetAction));
}
else
{
var oid = Facade.OidTranslator.GetOidTranslation(targetNakedObject);
var targetAction = Facade.GetObjectAction(oid, targetActionId).Action;
//var targetAction = NakedObjectsContext.GetActions(targetNakedObject).Single(a => a.Id == targetActionId);
return(ExecuteAction(controlData, targetNakedObject, targetAction));
}
}
private ActionResult SelectOnAction(ObjectAndControlData controlData)
{
var nakedObjectAction = controlData.GetAction(Facade);
var contextNakedObject = FilterCollection(controlData.GetNakedObject(Facade), controlData);
return(SelectSingleItem(contextNakedObject, nakedObjectAction, controlData, controlData.DataDict));
}
private static int GetPage(ObjectAndControlData controlData)
{
if (controlData.DataDict.ContainsKey(IdConstants.PageKey))
{
return(int.Parse(controlData.DataDict[IdConstants.PageKey]));
}
return(!string.IsNullOrEmpty(controlData.Page) ? int.Parse(controlData.Page) : 1);
}
internal void SetPagingValues(ObjectAndControlData controlData, IObjectFacade nakedObject)
{
if (nakedObject.Specification.IsCollection)
{
int sink1, sink2;
CurrentlyPaging(controlData, nakedObject.Count(), out sink1, out sink2);
}
}
internal ArgumentsContextFacade GetParameterValues(IActionFacade action, ObjectAndControlData controlData)
{
var values = action.Parameters.Select(parm => new { Id = IdHelper.GetParameterInputId(action, parm), Parm = parm }).ToDictionary(a => a.Parm.Id, a => GetParameterValue(a.Parm, a.Id, controlData));
return(new ArgumentsContextFacade {
Values = values, ValidateOnly = false
});
}
private ActionResult InitialAction(ObjectAndControlData controlData)
{
var nakedObject = controlData.GetNakedObject(Facade);
var nakedObjectAction = controlData.GetAction(Facade);
CheckConcurrency(nakedObject, null, controlData, (z, x, y) => IdHelper.GetConcurrencyActionInputId(x, nakedObjectAction, y));
return(ExecuteAction(controlData, nakedObject, nakedObjectAction));
}
public virtual ActionResult ClearHistoryOthers(string id, ObjectAndControlData controlData)
{
var nakedObject = GetNakedObjectFromId(id);
Session.RemoveOthersFromCache(Facade, nakedObject.GetDomainObject(), ObjectCache.ObjectFlag.BreadCrumb);
SetNewCollectionFormats(controlData);
SetControllerName(nakedObject.GetDomainObject());
return(AppropriateView(controlData, nakedObject));
}
public virtual ActionResult Details(ObjectAndControlData controlData)
{
Assert.AssertTrue(controlData.SubAction == ObjectAndControlData.SubActionType.Details ||
controlData.SubAction == ObjectAndControlData.SubActionType.None);
INakedObject nakedObject = FilterCollection(controlData.GetNakedObject(NakedObjectsContext), controlData);
SetNewCollectionFormats(controlData);
return(AppropriateView(controlData, nakedObject));
}
private ActionResult ApplyAction(ObjectAndControlData controlData)
{
var targetNakedObject = FilterCollection(controlData.GetNakedObject(Facade), controlData);
var targetAction = controlData.GetAction(Facade);
CheckConcurrency(targetNakedObject, null, controlData, (z, x, y) => IdHelper.GetConcurrencyActionInputId(x, targetAction, y));
if (targetNakedObject.IsNotPersistent)
{
RefreshTransient(targetNakedObject, controlData.Form);
}
// do after any parameters set by contributed action so this takes priority
SetSelectedParameters(targetAction);
var ac = GetParameterValues(targetAction, controlData);
ActionResultContextFacade ar;
if (targetNakedObject.Specification.IsCollection && !targetNakedObject.Specification.IsParseable)
{
var oids = targetNakedObject.ToEnumerable().Select(no => Facade.OidTranslator.GetOidTranslation(no)).ToArray();
var spec = targetNakedObject.ElementSpecification;
ar = Facade.ExecuteListAction(oids, spec, targetAction.Id, ac);
}
else
{
var oid = Facade.OidTranslator.GetOidTranslation(targetNakedObject);
ar = Facade.ExecuteObjectAction(oid, targetAction.Id, ac);
}
if (!HasError(ar))
{
targetNakedObject.SetIsNotQueryableState(targetAction.IsContributed);
return(AppropriateView(controlData, GetResult(ar), targetAction));
}
foreach (var parm in ar.ActionContext.VisibleParameters)
{
if (!string.IsNullOrEmpty(parm.Reason))
{
ModelState.AddModelError(IdHelper.GetParameterInputId(targetAction, parm.Parameter), parm.Reason);
}
}
if (!(string.IsNullOrEmpty(ar.ActionContext.Reason)))
{
ModelState.AddModelError("", ar.ActionContext.Reason);
}
var property = DisplaySingleProperty(controlData, controlData.DataDict);
return(View(property == null ? "ActionDialog" : "PropertyEdit", new FindViewModel {
ContextObject = targetNakedObject.GetDomainObject(), ContextAction = targetAction, PropertyName = property
}));
}
private ActionResult Redisplay(ObjectAndControlData controlData)
{
SetNewCollectionFormats(controlData);
var property = DisplaySingleProperty(controlData, controlData.DataDict);
var isEdit = bool.Parse(controlData.DataDict["editMode"]);
var nakedObject = controlData.GetNakedObject(Facade);
return(property == null?View(isEdit? "ObjectEdit" : "ObjectView", nakedObject.GetDomainObject()) :
View(isEdit ? "PropertyEdit" : "PropertyView", new PropertyViewModel(nakedObject.GetDomainObject(), property)));
}
public virtual ActionResult Action(ObjectAndControlData controlData)
{
var no = controlData.GetNakedObject(Facade);
var action = controlData.GetAction(Facade);
return(View("ActionDialog", new FindViewModel {
ContextObject = no.GetDomainObject(),
ContextAction = action
}));
}
private ActionResult ActionAsFind(ObjectAndControlData controlData)
{
string targetActionId = controlData.DataDict["targetActionId"];
string targetObjectId = controlData.DataDict["targetObjectId"];
string contextObjectId = controlData.DataDict["contextObjectId"];
string propertyName = controlData.DataDict["propertyName"];
string contextActionId = controlData.DataDict["contextActionId"];
var targetNakedObject = GetNakedObjectFromId(targetObjectId);
var contextNakedObject = FilterCollection(GetNakedObjectFromId(contextObjectId), controlData);
var targetAction = targetNakedObject.Specification.GetActionLeafNodes().Single(a => a.Id == targetActionId);
var contextAction = string.IsNullOrEmpty(contextActionId) ? null : contextNakedObject.Specification.GetActionLeafNodes().Single(a => a.Id == contextActionId);
SetContextObjectAsParameterValue(targetAction, contextNakedObject);
if (targetAction.ParameterCount == 0)
{
var oid = Facade.OidTranslator.GetOidTranslation(targetNakedObject);
var context = Facade.ExecuteObjectAction(oid, targetAction.Id, new ArgumentsContextFacade {
Values = new Dictionary <string, object>(),
ValidateOnly = false
});
var result = GetResult(context);
IEnumerable resultAsEnumerable = GetResultAsEnumerable(result, contextAction, propertyName);
if (resultAsEnumerable.Cast <object>().Count() == 1 && !result.IsTransient)
{
var selectedItem = new Dictionary <string, string> {
{ propertyName, GetObjectId(resultAsEnumerable.Cast <object>().Single()) }
};
return(SelectSingleItem(contextNakedObject, contextAction, controlData, selectedItem));
}
string view = Request.IsAjaxRequest() ? "PropertyEdit" : "FormWithSelections";
return(View(view, new FindViewModel {
ActionResult = resultAsEnumerable,
TargetObject = targetNakedObject.GetDomainObject(),
ContextObject = contextNakedObject.GetDomainObject(),
TargetAction = (targetAction),
ContextAction = (contextAction),
PropertyName = propertyName
}));
}
SetDefaults(targetNakedObject, targetAction);
return(View(Request.IsAjaxRequest() ? "PropertyEdit" : "FormWithFinderDialog", new FindViewModel {
TargetObject = targetNakedObject.GetDomainObject(),
ContextObject = contextNakedObject.GetDomainObject(),
TargetAction = (targetAction),
ContextAction = (contextAction),
PropertyName = propertyName
}));
}
private ActionResult InvokeActionAsSave(ObjectAndControlData controlData)
{
var form = controlData.Form;
string targetActionId = controlData.DataDict["targetActionId"];
string targetObjectId = controlData.DataDict["targetObjectId"];
string contextObjectId = controlData.DataDict["contextObjectId"];
string propertyName = controlData.DataDict["propertyName"];
string contextActionId = controlData.DataDict["contextActionId"];
string subEditObjectId = controlData.DataDict["subEditObjectId"];
var targetNakedObject = GetNakedObjectFromId(targetObjectId);
var contextNakedObject = FilterCollection(GetNakedObjectFromId(contextObjectId), controlData);
var targetAction = targetNakedObject.Specification.GetActionLeafNodes().Single(a => a.Id == targetActionId);
var contextAction = string.IsNullOrEmpty(contextActionId) ? null : contextNakedObject.Specification.GetActionLeafNodes().Single(a => a.Id == contextActionId);
var subEditObject = GetNakedObjectFromId(subEditObjectId);
var oid = Facade.OidTranslator.GetOidTranslation(subEditObject);
var ac = ConvertForSave(subEditObject, controlData);
var result = Facade.PutObject(oid, ac);
foreach (var p in result.VisibleProperties)
{
string key = GetFieldInputId(null, subEditObject, p.Property);
if (!string.IsNullOrEmpty(p.Reason))
{
// kludge to keep ui the same
string reason = p.Reason == MvcUi.Mandatory ? MvcUi.Mandatory : MvcUi.InvalidEntry;
ModelState.AddModelError(key, reason);
}
AddAttemptedValue(key, p.Property.Specification.IsParseable ? p.ProposedValue : p.ProposedObjectFacade.GetDomainObject <object>());
}
if (!string.IsNullOrEmpty(result.Reason))
{
ModelState.AddModelError(string.Empty, result.Reason);
}
// tempting to try to associate the new object at once - however it is still transient until the end of the
// transaction and so association may not work (possible persistent to transient). By doing this we split into two transactions
// and so all OK.
IEnumerable resultAsEnumerable = new List <object> {
result.Target.GetDomainObject()
};
return(View(Request.IsAjaxRequest() ? "PropertyEdit" : "FormWithSelections", new FindViewModel {
ActionResult = resultAsEnumerable,
TargetObject = targetNakedObject.GetDomainObject(),
ContextObject = contextNakedObject.GetDomainObject(),
TargetAction = targetAction,
ContextAction = contextAction,
PropertyName = propertyName
}));
}
public virtual ActionResult Details(ObjectAndControlData controlData)
{
Debug.Assert(controlData.SubAction == ObjectAndControlData.SubActionType.Details ||
controlData.SubAction == ObjectAndControlData.SubActionType.None);
var nakedObject = controlData.GetNakedObject(Facade);
nakedObject = FilterCollection(nakedObject, controlData);
SetNewCollectionFormats(controlData);
return(AppropriateView(controlData, nakedObject));
}
private static object GetValueFromForm(ObjectAndControlData controlData, string name)
{
var form = controlData.Form;
if (form.GetValue(name) != null)
{
return(((string[])form.GetValue(name).RawValue).First());
}
return(controlData.Files.ContainsKey(name) ? controlData.Files[name] : null);
}
internal IObjectFacade Page(IObjectFacade nakedObject, int collectionSize, ObjectAndControlData controlData)
{
int page, pageSize;
if (CurrentlyPaging(controlData, collectionSize, out page, out pageSize) && !nakedObject.IsPaged)
{
return(nakedObject.Page(page, pageSize));
}
// one page of full collection
return(nakedObject.Page(1, collectionSize));
}
private ActionResult ApplyEdit(ObjectAndControlData controlData)
{
string viewName = "ObjectEdit";
var nakedObject = controlData.GetNakedObject(NakedObjectsContext);
if (ValidateChanges(nakedObject, controlData))
{
viewName = ApplyChanges(nakedObject, controlData) ? "ObjectView" : "ObjectEdit";
}
return(View(viewName, nakedObject.Object));
}
internal void SetNewCollectionFormats(ObjectAndControlData controlData)
{
KeyValuePair <string, string>[] formats = controlData.DataDict.Where(kvp => IsFormat(kvp.Value)).ToArray();
if (formats.Any())
{
formats.ForEach(kvp => ViewData[kvp.Key] = kvp.Value);
}
else if (!string.IsNullOrWhiteSpace(controlData.Format))
{
ViewData[IdConstants.CollectionFormat] = controlData.Format;
}
}
private ActionResult InvokeActionAsFind(ObjectAndControlData controlData)
{
string targetActionId = controlData.DataDict["targetActionId"];
string targetObjectId = controlData.DataDict["targetObjectId"];
string contextObjectId = controlData.DataDict["contextObjectId"];
string propertyName = controlData.DataDict["propertyName"];
string contextActionId = controlData.DataDict["contextActionId"];
INakedObject targetNakedObject = NakedObjectsContext.GetNakedObjectFromId(targetObjectId);
INakedObject contextNakedObject = FilterCollection(NakedObjectsContext.GetNakedObjectFromId(contextObjectId), controlData);
IActionSpec targetAction = NakedObjectsContext.GetActions(targetNakedObject).Single(a => a.Id == targetActionId);
IActionSpec contextAction = string.IsNullOrEmpty(contextActionId) ? null : NakedObjectsContext.GetActionFromId(contextActionId);
SetContextObjectAsParameterValue(targetAction, contextNakedObject);
if (ValidateParameters(targetNakedObject, targetAction, controlData))
{
IEnumerable <INakedObject> parms = GetParameterValues(targetAction, controlData);
INakedObject result = targetAction.Execute(targetNakedObject, parms.ToArray());
if (result != null)
{
IEnumerable resultAsEnumerable = !result.Spec.IsCollection ? new List <object> {
result.Object
} : (IEnumerable)result.Object;
if (resultAsEnumerable.Cast <object>().Count() == 1)
{
var selectedItem = new Dictionary <string, string> {
{ propertyName, NakedObjectsContext.GetObjectId(resultAsEnumerable.Cast <object>().Single()) }
};
return(SelectSingleItem(contextNakedObject, contextAction, controlData, selectedItem));
}
string view = Request.IsAjaxRequest() ? "PropertyEdit" : "FormWithSelections";
return(View(view, new FindViewModel {
ActionResult = resultAsEnumerable,
TargetObject = targetNakedObject.Object,
ContextObject = contextNakedObject.Object,
TargetAction = targetAction,
ContextAction = contextAction,
PropertyName = propertyName
}));
}
}
return(View(Request.IsAjaxRequest() ? "PropertyEdit" : "FormWithFinderDialog", new FindViewModel {
TargetObject = targetNakedObject.Object,
ContextObject = contextNakedObject.Object,
TargetAction = targetAction,
ContextAction = contextAction,
PropertyName = propertyName
}));
}
private ActionResult ApplyEditAction(ObjectAndControlData controlData)
{
var nakedObject = controlData.GetNakedObject(NakedObjectsContext);
var ok = ValidateChanges(nakedObject, controlData) && ApplyChanges(nakedObject, controlData);
if (ok)
{
string targetActionId = controlData.DataDict["targetActionId"];
IActionSpec targetAction = NakedObjectsContext.GetActions(nakedObject).Single(a => a.Id == targetActionId);
return(ExecuteAction(controlData, nakedObject, targetAction));
}
return(View("ViewModel", nakedObject.Object));
}
