private static Tuple<IActionSpec, string>[] GetOverloadedActionsAndUIds(IActionSpec[] actions) {
IActionSpec[] overloadedActions = actions.Where(a => actions.Count(ac => ac.Id == a.Id) > 1).ToArray();
if (overloadedActions.Any()) {
return overloadedActions.Select(a => new Tuple<IActionSpec, string>(a, GetUniqueSuffix(a, actions))).ToArray();
}
return new Tuple<IActionSpec, string>[] {};
}
public CollectionMemento(ILifecycleManager lifecycleManager, INakedObjectManager nakedObjectManager, IMetamodelManager metamodel, INakedObjectAdapter target, IActionSpec actionSpec, INakedObjectAdapter[] parameters)
: this(lifecycleManager, nakedObjectManager, metamodel) {
Target = target;
Action = actionSpec;
Parameters = parameters;
if (Target.Spec.IsViewModel) {
lifecycleManager.PopulateViewModelKeys(Target);
}
}
public ActionFacade(IActionSpec action, IFrameworkFacade frameworkFacade, INakedObjectsFramework framework, string overloadedUniqueId) {
FacadeUtils.AssertNotNull(action, "Action is null");
FacadeUtils.AssertNotNull(framework, "framework is null");
FacadeUtils.AssertNotNull(overloadedUniqueId, "overloadedUniqueId is null");
FacadeUtils.AssertNotNull(frameworkFacade, "FrameworkFacade is null");
this.action = action;
this.framework = framework;
this.overloadedUniqueId = overloadedUniqueId;
FrameworkFacade = frameworkFacade;
}
public TestAction(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, ITransactionManager transactionManager, string contributor, IActionSpec actionSpec, ITestHasActions owningObject, ITestObjectFactory factory, INakedObjectManager manager, IMessageBroker messageBroker) {
SubMenu = contributor;
this.metamodelManager = metamodelManager;
this.session = session;
this.lifecycleManager = lifecycleManager;
this.transactionManager = transactionManager;
this.messageBroker = messageBroker;
this.owningObject = owningObject;
this.factory = factory;
this.manager = manager;
this.actionSpec = actionSpec;
}
private IDictionary <string, INakedObject> GetOtherValues(IActionSpec action)
{
var results = new Dictionary <string, INakedObject>();
var parms = new FormCollection(HttpContext.Request.Params);
Decrypt(parms);
foreach (IActionParameterSpec parm in action.Parameters)
{
string[] values = GetRawValues(parms, IdHelper.GetParameterInputId(action, parm));
results[parm.Id.ToLower()] = GetValue(values, parm, parm.Spec);
}
return(results);
}
private ActionResult SelectSingleItem(INakedObject nakedObject, IActionSpec action, ObjectAndControlData controlData, IDictionary <string, string> selectedItem)
{
var property = DisplaySingleProperty(controlData, selectedItem);
if (action == null)
{
SetSelectedReferences(nakedObject, selectedItem);
return(property == null?View("ObjectEdit", nakedObject.Object) :
View("PropertyEdit", new PropertyViewModel(nakedObject.Object, property)));
}
SetSelectedParameters(nakedObject, action, selectedItem);
return(View(property == null ? "ActionDialog" : "PropertyEdit", new FindViewModel {
ContextObject = nakedObject.Object, ContextAction = action, PropertyName = property
}));
}
public IActionParameterSpec CreateParameter(IActionParameterSpecImmutable parameterSpecImmutable, IActionSpec actionSpec, int index) {
Assert.AssertNotNull(framework);
IObjectSpecImmutable specification = parameterSpecImmutable.Specification;
if (specification.IsParseable) {
return new ActionParseableParameterSpec(framework.MetamodelManager, index, actionSpec, parameterSpecImmutable, framework.NakedObjectManager, framework.Session, framework.Persistor);
}
if (specification.IsObject) {
return new OneToOneActionParameter(framework.MetamodelManager, index, actionSpec, parameterSpecImmutable, framework.NakedObjectManager, framework.Session, framework.Persistor);
}
if (specification.IsCollection) {
return new OneToManyActionParameter(framework.MetamodelManager, index, actionSpec, parameterSpecImmutable, framework.NakedObjectManager, framework.Session, framework.Persistor);
}
throw new UnknownTypeException(Log.LogAndReturn($"{specification}"));
}
public static ActionResultModel Create(INakedObjectsFramework framework, IActionSpec action, INakedObject nakedObject, int page, int pageSize, string format)
{
var result = (IEnumerable)nakedObject.Object;
Type genericType = result.GetType().IsGenericType ? result.GetType().GetGenericArguments().First() : typeof(object);
Type armGenericType = result is IQueryable ? typeof(ActionResultModelQ <>) : typeof(ActionResultModel <>);
Type armType = armGenericType.MakeGenericType(genericType);
var arm = (ActionResultModel)Activator.CreateInstance(armType, action, result);
INakedObject noArm = framework.NakedObjectManager.CreateAdapter(arm, null, null);
noArm.SetATransientOid(new CollectionMemento(framework.LifecycleManager, framework.NakedObjectManager, framework.MetamodelManager, (CollectionMemento)nakedObject.Oid, new object[] { }));
arm.Page = page;
arm.PageSize = pageSize;
arm.Format = format;
return(arm);
}
public void CollectionMemento()
{
mocks.ViewDataContainer.Object.ViewData["Services"] = NakedObjectsFramework.GetServices();
INakedObjectAdapter service = NakedObjectsFramework.ServicesManager.GetService("ClaimRepository");
IActionSpec action = service.Spec.GetActions().Single(a => a.Id == "FindMyClaims");
INakedObjectAdapter[] parms = new[] { null, "" }.Select(o => NakedObjectsFramework.NakedObjectManager.CreateAdapter(o, null, null)).ToArray();
var cm = CollectionMementoHelper.TestMemento(NakedObjectsFramework.LifecycleManager, NakedObjectsFramework.NakedObjectManager, NakedObjectsFramework.MetamodelManager, service, action, parms);
var claims = (IEnumerable)cm.RecoverCollection().Object;
Assert.AreEqual(5, claims.Cast <object>().Count());
Assert.AreEqual(cm, cm.RecoverCollection().Oid);
}
public void TestActionObjectCollectionParmEmpty()
{
TestDomainObject target = NakedObjectsFramework.Persistor.Instances <TestDomainObject>().Single(i => i.Id == 1);
INakedObjectAdapter targetNo = NakedObjectsFramework.NakedObjectManager.CreateAdapter(target, null, null);
IActionSpec actionSpec = targetNo.Spec.GetActions().Single(a => a.Id == "Action5");
var rawParm = new List <TestDomainObject>();
INakedObjectAdapter parm = NakedObjectsFramework.NakedObjectManager.CreateAdapter(rawParm, null, null);
var memento = new CollectionMemento(NakedObjectsFramework.LifecycleManager, NakedObjectsFramework.NakedObjectManager, NakedObjectsFramework.MetamodelManager, targetNo, actionSpec, new[] { parm });
RoundTrip(memento);
RecoverCollection(target.Action5(rawParm), memento, NakedObjectsFramework.NakedObjectManager);
}
public virtual JsonResult GetActionCompletions(string id, string actionName, int parameterIndex, string autoCompleteParm)
{
INakedObject nakedObject = NakedObjectsContext.GetNakedObjectFromId(id);
IActionSpec action = NakedObjectsContext.GetActions(nakedObject).SingleOrDefault(a => a.Id == actionName);
IList <object> completions = new List <object>();
IActionParameterSpec p = action.Parameters[parameterIndex];
if (p.IsAutoCompleteEnabled)
{
INakedObject[] nakedObjectCompletions = p.GetCompletions(nakedObject, autoCompleteParm);
completions = nakedObjectCompletions.Select(no => GetCompletionData(no, p.Spec)).ToList();
}
return(Jsonp(completions));
}
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"];
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 (targetAction.ParameterCount == 0)
{
INakedObject result = Execute(targetAction, targetNakedObject, new INakedObject[] {});
IEnumerable resultAsEnumerable = GetResultAsEnumerable(result, contextAction, propertyName);
if (resultAsEnumerable.Cast <object>().Count() == 1 && result.ResolveState.IsPersistent())
{
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
}));
}
SetDefaults(targetNakedObject, targetAction);
return(View(Request.IsAjaxRequest() ? "PropertyEdit" : "FormWithFinderDialog", new FindViewModel {
TargetObject = targetNakedObject.Object,
ContextObject = contextNakedObject.Object,
TargetAction = targetAction,
ContextAction = contextAction,
PropertyName = propertyName
}));
}
protected internal ActionParameterSpec(IMetamodelManager metamodel, int number, IActionSpec actionSpec, IActionParameterSpecImmutable actionParameterSpecImmutable, INakedObjectManager manager, ISession session, IObjectPersistor persistor)
{
Assert.AssertNotNull(metamodel);
Assert.AssertNotNull(actionSpec);
Assert.AssertNotNull(actionParameterSpecImmutable);
Assert.AssertNotNull(manager);
Assert.AssertNotNull(session);
Assert.AssertNotNull(persistor);
this.metamodel = metamodel;
this.number = number;
parentAction = actionSpec;
this.actionParameterSpecImmutable = actionParameterSpecImmutable;
this.manager = manager;
this.session = session;
this.persistor = persistor;
}
public static IActionSpec GetOverloadedAction(string actionName, ITypeSpec spec)
{
IActionSpec action = null;
IActionSpec[] actions = spec.GetActionLeafNodes();
Tuple <IActionSpec, string>[] overloadedActions = GetOverloadedActionsAndUIds(actions);
if (overloadedActions.Any())
{
Tuple <IActionSpec, string> matchingAction = overloadedActions.SingleOrDefault(oa => oa.Item1.Id + oa.Item2 == actionName);
if (matchingAction != null)
{
action = matchingAction.Item1;
}
}
return(action);
}
public void CollectionMementoToStringWithEnum()
{
mocks.ViewDataContainer.Object.ViewData["Services"] = NakedObjectsFramework.GetServices();
INakedObject service = NakedObjectsFramework.ServicesManager.GetService("ClaimRepository");
IActionSpec action = service.Spec.GetObjectActions().Single(a => a.Id == "FindMyClaimsByEnumStatus");
INakedObject[] parms = new[] { (object)ClaimStatusEnum.New }.Select(o => NakedObjectsFramework.NakedObjectManager.CreateAdapter(o, null, null)).ToArray();
var cm = new CollectionMemento(NakedObjectsFramework.LifecycleManager, NakedObjectsFramework.NakedObjectManager, NakedObjectsFramework.MetamodelManager, service, action, parms);
string[] strings = cm.ToEncodedStrings();
var cm2 = new CollectionMemento(NakedObjectsFramework.LifecycleManager, NakedObjectsFramework.NakedObjectManager, NakedObjectsFramework.MetamodelManager, strings);
var claims = (IEnumerable)cm2.RecoverCollection().Object;
Assert.AreEqual(2, claims.Cast <object>().Count());
Assert.AreEqual(cm2, cm2.RecoverCollection().Oid);
}
private static string GetUniqueSuffix(IActionSpec action, IActionSpec[] actions) {
IActionSpec[] overloadedActions = actions.Where(a => a.Id == action.Id && actions.Count(ac => ac.Id == a.Id) > 1).ToArray();
if (overloadedActions.Any()) {
var actionAndParms = overloadedActions.Select(a => new Tuple<IActionSpec, string>(a, ((Func<IActionSpec, string>) (act => act.Parameters.Aggregate("", (acc, p) => a + p.Id + p.Spec.FullName)))(a)));
int index = 0;
var orderedActions = actionAndParms.OrderBy(ap => ap.Item2).Select(ap => ap.Item1).ToDictionary(a => a, a => index++);
var suffix = orderedActions[action].ToString(Thread.CurrentThread.CurrentCulture);
while (actions.Select(a => a.Id).Contains(action.Id + suffix)) {
suffix = "0" + suffix;
}
return suffix;
}
return "";
}
public void TestActionNoParmsWithSelected()
{
TestDomainObject target = NakedObjectsFramework.Persistor.Instances <TestDomainObject>().Single(i => i.Id == 1);
INakedObjectAdapter targetNo = NakedObjectsFramework.NakedObjectManager.CreateAdapter(target, null, null);
IActionSpec actionSpec = targetNo.Spec.GetActions().Single(a => a.Id == "Action1");
var memento = new CollectionMemento(NakedObjectsFramework.LifecycleManager, NakedObjectsFramework.NakedObjectManager, NakedObjectsFramework.MetamodelManager, targetNo, actionSpec, new INakedObjectAdapter[] {});
var selectedMemento = new CollectionMemento(NakedObjectsFramework.LifecycleManager, NakedObjectsFramework.NakedObjectManager, NakedObjectsFramework.MetamodelManager, memento, new object[] { target });
RoundTrip(selectedMemento);
IEnumerable <TestDomainObject> recoveredCollection = selectedMemento.RecoverCollection().GetAsEnumerable(NakedObjectsFramework.NakedObjectManager).Select(AdapterUtils.GetDomainObject <TestDomainObject>);
Assert.IsFalse(target.Action1().SequenceEqual(recoveredCollection), "recovered selected collection same as original");
IEnumerable <TestDomainObject> selectedCollection = target.Action1().Where(tdo => tdo.Id == target.Id);
Assert.IsTrue(selectedCollection.SequenceEqual(recoveredCollection), "recovered selected collection not same as original selected collection");
}
public virtual JsonResult GetActionChoices(string id, string actionName)
{
INakedObject nakedObject = NakedObjectsContext.GetNakedObjectFromId(id);
IActionSpec action = NakedObjectsContext.GetActions(nakedObject).SingleOrDefault(a => a.Id == actionName);
IDictionary <string, string[][]> choices = new Dictionary <string, string[][]>();
IDictionary <string, INakedObject> otherValues = GetOtherValues(action);
foreach (IActionParameterSpec p in action.Parameters)
{
if (p.IsChoicesEnabled || p.IsMultipleChoicesEnabled)
{
INakedObject[] nakedObjectChoices = p.GetChoices(nakedObject, otherValues);
string[] content = nakedObjectChoices.Select(c => c.TitleString()).ToArray();
string[] value = NakedObjectsContext.IsParseableOrCollectionOfParseable(p) ? content : nakedObjectChoices.Select(NakedObjectsContext.GetObjectId).ToArray();
choices[IdHelper.GetParameterInputId(action, p)] = new[] { value, content };
}
}
return(Jsonp(choices));
}
public IActionSpec GetAction(INakedObjectsFramework framework)
{
if (nakedObjectAction == null)
{
GetNakedObject(framework);
IActionSpec[] actions;
if (nakedObject.Spec.IsCollection)
{
var metamodel = framework.MetamodelManager.Metamodel;
IObjectSpecImmutable elementSpecImmut = nakedObject.Spec.GetFacet <ITypeOfFacet>().GetValueSpec(nakedObject, metamodel);
var elementSpec = framework.MetamodelManager.GetSpecification(elementSpecImmut) as IObjectSpec;
Trace.Assert(elementSpec != null);
actions = elementSpec.GetCollectionContributedActions();
}
else
{
actions = nakedObject.Spec.GetObjectActions();
}
nakedObjectAction = actions.Where(a => a.IsUsable(nakedObject).IsAllowed).Where(a => a.IsVisible(nakedObject)).SingleOrDefault(a => a.Id == ActionId);
}
return(nakedObjectAction);
}
private static string GetUniqueSuffix(IActionSpec action, IActionSpec[] actions)
{
IActionSpec[] overloadedActions = actions.Where(a => a.Id == action.Id && actions.Count(ac => ac.Id == a.Id) > 1).ToArray();
if (overloadedActions.Any())
{
var actionAndParms = overloadedActions.Select(a => new Tuple <IActionSpec, string>(a, ((Func <IActionSpec, string>)(act => act.Parameters.Aggregate("", (acc, p) => a + p.Id + p.Spec.FullName)))(a)));
int index = 0;
var orderedActions = actionAndParms.OrderBy(ap => ap.Item2).Select(ap => ap.Item1).ToDictionary(a => a, a => index++);
var suffix = orderedActions[action].ToString(Thread.CurrentThread.CurrentCulture);
while (actions.Select(a => a.Id).Contains(action.Id + suffix))
{
suffix = "0" + suffix;
}
return(suffix);
}
return("");
}
private T InvokeAction <T>(INakedObject nakedObject, IActionSpec action, FormCollection parameters, out bool valid)
{
if (ActionExecutingAsContributed(action, nakedObject))
{
if (action.ParameterCount == 1)
{
// contributed action being invoked with a single parm that is the current target
// no dialog - go straight through
INakedObject result = action.Execute(nakedObject, new[] { nakedObject });
valid = true;
return(result.GetDomainObject <T>());
}
if (action.ParameterCount > 1)
{
// contributed action being invoked with multiple parms - populate first that match the target
IActionParameterSpec parmToPopulate = action.Parameters.FirstOrDefault(p => nakedObject.Spec.IsOfType(p.Spec));
if (parmToPopulate != null)
{
ViewData[IdHelper.GetParameterInputId(action, parmToPopulate)] = NakedObjectsContext.GetObjectId(nakedObject.Object);
}
}
}
if (ValidateParameters(nakedObject, action, new ObjectAndControlData {
Form = parameters
}))
{
IEnumerable <INakedObject> parms = GetParameterValues(action, new ObjectAndControlData {
Form = parameters
});
INakedObject result = action.Execute(nakedObject, parms.ToArray());
valid = true;
return(result.GetDomainObject <T>());
}
valid = false;
return(default(T));
}
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"];
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);
INakedObject subEditObject = NakedObjectsContext.GetNakedObjectFromId(subEditObjectId);
if (ValidateChanges(subEditObject, controlData))
{
ApplyChanges(subEditObject, controlData);
}
// 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> {
subEditObject.Object
};
return(View(Request.IsAjaxRequest() ? "PropertyEdit" : "FormWithSelections", new FindViewModel {
ActionResult = resultAsEnumerable,
TargetObject = targetNakedObject.Object,
ContextObject = contextNakedObject.Object,
TargetAction = targetAction,
ContextAction = contextAction,
PropertyName = propertyName
}));
}
public virtual JsonResult ValidateParameter(string id, string value, string actionName, string parameterName)
{
INakedObject nakedObject = NakedObjectsContext.GetNakedObjectFromId(id);
IActionSpec action = NakedObjectsContext.GetActions(nakedObject).SingleOrDefault(a => a.Id == actionName);
bool isValid = false;
string parmId = "";
if (action != null)
{
IActionParameterSpec parameter = action.Parameters.Where(p => p.Id.Equals(parameterName, StringComparison.InvariantCultureIgnoreCase)).Single();
parmId = IdHelper.GetParameterInputId(action, parameter);
if (value == null)
{
value = Request.Params[parmId];
}
try {
INakedObject valueNakedObject = GetParameterValue(parameter, value);
ValidateParameter(action, parameter, nakedObject, valueNakedObject);
}
catch (InvalidEntryException) {
ModelState.AddModelError(parmId, MvcUi.InvalidEntry);
}
isValid = ModelState.IsValid;
}
if (isValid)
{
return(Jsonp(true));
}
ModelError error = ModelState[parmId].Errors.FirstOrDefault();
return(Jsonp(error == null ? "" : error.ErrorMessage));
}
public static bool IsIdempotent(this IActionSpec action)
{
return(action.ContainsFacet <IIdempotentFacet>());
}
public static bool IsQueryOnly(this IActionSpec action)
{
return(action.ReturnSpec.IsQueryable || action.ContainsFacet <IQueryOnlyFacet>());
}
public ITestAction CreateTestAction(IActionSpec actionSpec, ITestHasActions owningObject) => new TestAction(metamodelManager, Session, lifecycleManager, transactionManager, actionSpec, owningObject, this, manager, messageBroker);
public ITestParameter CreateTestParameter(IActionSpec actionSpec, IActionParameterSpec parameterSpec, ITestHasActions owningObject) => new TestParameter(parameterSpec, owningObject, this);
public ActionParseableParameterSpec(IMetamodelManager metamodel, int index, IActionSpec actionSpec, IActionParameterSpecImmutable actionParameterSpecImmutable, INakedObjectManager manager, ISession session, IObjectPersistor persistor)
: base(metamodel, index, actionSpec, actionParameterSpecImmutable, manager, session, persistor)
{
}
public IActionParameterSpec CreateParameter(IActionParameterSpecImmutable parameterSpecImmutable, IActionSpec actionSpec, int index)
{
CheckInitialised();
var specification = parameterSpecImmutable.Specification;
return(specification switch {
_ when specification.IsParseable => new ActionParseableParameterSpec(framework.MetamodelManager, index, actionSpec, parameterSpecImmutable, framework.NakedObjectManager, framework.Session, framework.Persistor),
_ when specification.IsObject => new OneToOneActionParameter(framework.MetamodelManager, index, actionSpec, parameterSpecImmutable, framework.NakedObjectManager, framework.Session, framework.Persistor),
_ when specification.IsCollection => new OneToManyActionParameter(framework.MetamodelManager, index, actionSpec, parameterSpecImmutable, framework.NakedObjectManager, framework.Session, framework.Persistor),
_ => throw new UnknownTypeException(logger.LogAndReturn($"{specification}"))
});
public static MvcHtmlString CollectionTable(this HtmlHelper html, IEnumerable collection, IActionSpec action)
{
return(html.Collection(collection, action, IdHelper.TableDisplayFormat));
}
private string AppendActions(IActionSpec[] actionsSpec) {
var order = new StringBuilder();
for (int i = 0; i < actionsSpec.Length; i++) {
IActionSpec actionSpec = actionsSpec[i];
string name = actionSpec.Name;
order.Append(name);
order.Append(i < actionsSpec.Length - 1 ? ", " : "");
}
return order.ToString();
}
public static string GetOverloadedUId(IActionSpec action, ITypeSpec spec) {
IActionSpec[] actions = spec.GetActionLeafNodes();
Tuple<IActionSpec, string>[] overloadedActions = GetOverloadedActionsAndUIds(actions);
return overloadedActions.Where(oa => oa.Item1 == action).Select(oa => oa.Item2).SingleOrDefault();
}
public ActionParseableParameterSpec(IMetamodelManager metamodel, int index, IActionSpec actionSpec, IActionParameterSpecImmutable actionParameterSpecImmutable, INakedObjectManager manager, ISession session, IObjectPersistor persistor)
: base(metamodel, index, actionSpec, actionParameterSpecImmutable, manager, session, persistor) {}
public static string GetOverloadedUId(IActionSpec action, ITypeSpec spec)
{
IActionSpec[] actions = spec.GetActionLeafNodes();
Tuple <IActionSpec, string>[] overloadedActions = GetOverloadedActionsAndUIds(actions);
return(overloadedActions.Where(oa => oa.Item1 == action).Select(oa => oa.Item2).SingleOrDefault());
}
public ParameterContext(bool embeddedInObject, INakedObject target, IActionSpec action, IActionParameterSpec parameter, bool isEdit)
: base(embeddedInObject, target, action)
{
Parameter = parameter;
IsParameterEdit = isEdit;
}
public ITestParameter CreateTestParameter(IActionSpec actionSpec, IActionParameterSpec parameterSpec, ITestHasActions owningObject) {
return new TestParameter(parameterSpec, owningObject, this);
}
internal static MvcHtmlString CollectionTableInternal(this HtmlHelper html, IEnumerable collection, IActionSpec action = null)
{
INakedObject nakedObject = html.Framework().GetNakedObject(collection);
Func <IAssociationSpec, bool> filterFunc;
Func <IAssociationSpec, int> orderFunc;
bool withTitle;
if (action == null || action.ReturnSpec.IsVoid)
{
var memento = nakedObject.Oid as CollectionMemento;
if (memento != null)
{
action = memento.Action;
}
}
CommonHtmlHelper.GetTableColumnInfo(action, out filterFunc, out orderFunc, out withTitle);
return(html.GetStandaloneCollection(nakedObject, filterFunc, orderFunc, withTitle));
}
public static MvcHtmlString Collection(this HtmlHelper html, IEnumerable collection, IActionSpec action, string defaultTo = IdHelper.ListDisplayFormat)
{
bool renderEagerly = CommonHtmlHelper.RenderEagerly(action);
string displayType = DefaultFormat(html, renderEagerly ? IdHelper.TableDisplayFormat : defaultTo);
return(displayType == IdHelper.TableDisplayFormat ? CollectionTableInternal(html, collection, action) : CollectionListInternal(html, collection, action));
}
public ITestAction CreateTestAction(IActionSpec actionSpec, ITestHasActions owningObject) {
return new TestAction(metamodelManager, Session, lifecycleManager, transactionManager, actionSpec, owningObject, this, manager, messageBroker);
}
public static MvcHtmlString CollectionList(this HtmlHelper html, IEnumerable collection, IActionSpec action)
{
return(html.Collection(collection, action));
}
// for test purposes only
public static ICollectionMemento TestMemento(ILifecycleManager lifecycleManager, INakedObjectManager nakedObjectManager, IMetamodelManager metamodelManager, INakedObjectAdapter target, IActionSpec actionSpec, INakedObjectAdapter[] parameters) {
return new CollectionMemento(lifecycleManager, nakedObjectManager, metamodelManager, target, actionSpec, parameters);
}
internal static MvcHtmlString CollectionListInternal(this HtmlHelper html, IEnumerable collection, IActionSpec action = null)
{
INakedObject nakedObject = html.Framework().GetNakedObject(collection);
return(html.GetStandaloneList(nakedObject, null));
}
public TestAction(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, ITransactionManager transactionManager, IActionSpec actionSpec, ITestHasActions owningObject, ITestObjectFactory factory, INakedObjectManager manager, IMessageBroker messageBroker)
: this(metamodelManager, session, lifecycleManager, transactionManager, string.Empty, actionSpec, owningObject, factory, manager, messageBroker) {}
