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) {}