public void Reset(INakedObjectAdapter inObjectAdapter) { try { var collection = (IList) property.GetValue(inObjectAdapter.GetDomainObject(), null); collection.Clear(); property.SetValue(inObjectAdapter.GetDomainObject(), collection, null); } catch (Exception e) { throw new ReflectionException(Log.LogAndReturn($"Failed to get/set property {property.Name} in {inObjectAdapter.Spec.FullName}"), e); } }
public void Reset(INakedObjectAdapter inObjectAdapter) { try { var collection = (IList) property.GetValue(inObjectAdapter.GetDomainObject(), null); collection.Clear(); property.SetValue(inObjectAdapter.GetDomainObject(), collection, null); } catch (Exception e) { throw new ReflectionException(string.Format("Failed to get/set property {0} in {1}", property.Name, inObjectAdapter.Spec.FullName), e); } }
public override string GetTitleWithMask(string mask, INakedObjectAdapter nakedObjectAdapter, INakedObjectManager nakedObjectManager) { if (maskDelegate != null) { return (string) maskDelegate(nakedObjectAdapter.GetDomainObject(), new object[] {mask}); } if (maskMethod != null) { return (string) maskMethod.Invoke(nakedObjectAdapter.GetDomainObject(), new object[] {mask}); } return GetTitle(nakedObjectAdapter, nakedObjectManager); }
public void Reset(INakedObjectAdapter inObjectAdapter) { try { var collection = (IList)property.GetValue(inObjectAdapter.GetDomainObject(), null); collection.Clear(); property.SetValue(inObjectAdapter.GetDomainObject(), collection, null); } catch (Exception e) { throw new ReflectionException(Log.LogAndReturn($"Failed to get/set property {property.Name} in {inObjectAdapter.Spec.FullName}"), e); } }
public void Reset(INakedObjectAdapter inObjectAdapter) { try { var collection = (IList)property.GetValue(inObjectAdapter.GetDomainObject(), null); collection.Clear(); property.SetValue(inObjectAdapter.GetDomainObject(), collection, null); } catch (Exception e) { throw new ReflectionException(string.Format("Failed to get/set property {0} in {1}", property.Name, inObjectAdapter.Spec.FullName), e); } }
public override string GetTitleWithMask(string mask, INakedObjectAdapter nakedObjectAdapter, INakedObjectManager nakedObjectManager, ISession session, IObjectPersistor persistor) { if (maskDelegate != null) { return((string)maskDelegate(nakedObjectAdapter.GetDomainObject(), new object[] { mask })); } if (maskMethod != null) { return((string)maskMethod.Invoke(nakedObjectAdapter.GetDomainObject(), new object[] { mask })); } return(GetTitle(nakedObjectAdapter, nakedObjectManager, session, persistor)); }
public void TestGetPropertyChoicesOtherValue() { INakedObjectAdapter choicesRepo = NakedObjectsFramework.GetAdaptedService("ChoicesRepository"); object choicesObject = choicesRepo.GetDomainObject <ChoicesRepository>().GetChoicesObject(); string id = NakedObjectsFramework.GetObjectId(choicesObject); const string parm1Id = "ChoicesObject-Name-Input0"; const string parm2Id = "ChoicesObject-AProperty-Input0"; mocks.Request.Setup(x => x.Params).Returns(new NameValueCollection { { parm1Id, "AName" }, { parm2Id, "" } }); JsonResult result = controller.GetPropertyChoices(id); Assert.IsInstanceOf <IDictionary <string, string[][]> >(result.Data); var dict = result.Data as IDictionary <string, string[][]>; Assert.AreEqual(1, dict.Count); Assert.IsTrue(dict.ContainsKey("ChoicesObject-AProperty-Input")); Assert.IsTrue(dict["ChoicesObject-AProperty-Input"][0].SequenceEqual(new[] { "AName-A", "AName-B" })); Assert.IsTrue(dict["ChoicesObject-AProperty-Input"][1].SequenceEqual(new[] { "AName-A", "AName-B" })); }
public void TestGetPropertyAutoComplete() { INakedObjectAdapter autoCompleteRepo = NakedObjectsFramework.GetAdaptedService("AutoCompleteRepository"); object autoCompleteObject = autoCompleteRepo.GetDomainObject <AutoCompleteRepository>().GetAutoCompleteObject(); string id = NakedObjectsFramework.GetObjectId(autoCompleteObject); const string parm1Id = "AutoCompleteObject-Name-Input"; mocks.Request.Setup(x => x.Params).Returns(new NameValueCollection { { parm1Id, "" } }); JsonResult result = controller.GetPropertyCompletions(id, "AProperty", ""); var list = result.Data as IList <object>; Assert.AreEqual(2, list.Count); var nv1 = new RouteValueDictionary(list[0]); var nv2 = new RouteValueDictionary(list[1]); Assert.AreEqual("value5", nv1["label"]); Assert.AreEqual("value5", nv1["value"]); Assert.AreEqual("value5", nv1["link"]); Assert.AreEqual("/Images/Default.png", nv1["src"]); Assert.AreEqual("String", nv1["alt"]); Assert.AreEqual("value6", nv2["label"]); Assert.AreEqual("value6", nv2["value"]); Assert.AreEqual("value6", nv2["link"]); Assert.AreEqual("/Images/Default.png", nv2["src"]); Assert.AreEqual("String", nv1["alt"]); }
public object[] GetCompletions(INakedObjectAdapter inObjectAdapter, string autoCompleteParm) { try { object autoComplete = methodDelegate(inObjectAdapter.GetDomainObject(), new object[] { autoCompleteParm }); //returning an IQueryable var queryable = autoComplete as IQueryable; if (queryable != null) { return(queryable.Take(PageSize).ToArray()); } //returning an IEnumerable (of string only) var strings = autoComplete as IEnumerable <string>; if (strings != null) { return(strings.ToArray()); } //return type is a single object if (!CollectionUtils.IsCollection(autoComplete.GetType())) { return(new object[] { autoComplete }); } throw new NakedObjectDomainException("Must return IQueryable or a single object from autoComplete method: " + method.Name); } catch (ArgumentException ae) { string msg = string.Format("autoComplete exception: {0} has mismatched parameter type - must be string", method.Name); throw new InvokeException(msg, ae); } }
public object[] GetCompletions(INakedObjectAdapter inObjectAdapter, string autoCompleteParm) { try { object autoComplete = methodDelegate(inObjectAdapter.GetDomainObject(), new object[] { autoCompleteParm }); //returning an IQueryable var queryable = autoComplete as IQueryable; if (queryable != null) { return queryable.Take(PageSize).ToArray(); } //returning an IEnumerable (of string only) var strings = autoComplete as IEnumerable<string>; if (strings != null) { return strings.ToArray(); } //return type is a single object if (!CollectionUtils.IsCollection(autoComplete.GetType())) { return new object[] { autoComplete }; } throw new NakedObjectDomainException("Must return IQueryable or a single object from autoComplete method: " + method.Name); } catch (ArgumentException ae) { string msg = string.Format("autoComplete exception: {0} has mismatched parameter type - must be string", method.Name); throw new InvokeException(msg, ae); } }
public string HiddenReason(INakedObjectAdapter nakedObjectAdapter) { if (nakedObjectAdapter == null) { return null; } var isHidden = (bool) methodDelegate(nakedObjectAdapter.GetDomainObject(), new object[] {}); return isHidden ? Resources.NakedObjects.Hidden : null; }
public void GetCollectionNakedObjectFromId() { IList <Claim> claims = NakedObjectsFramework.GetService <ClaimRepository>().FindMyClaims(null, ""); INakedObjectAdapter no = NakedObjectsFramework.NakedObjectManager.CreateAdapter(claims, null, null); 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); no.SetATransientOid(cm); string id = NakedObjectsFramework.GetObjectId(no); INakedObjectAdapter no2 = NakedObjectsFramework.GetNakedObjectFromId(id); List <Claim> claims2 = no2.GetDomainObject <IEnumerable <Claim> >().ToList(); Assert.AreEqual(claims.Count(), claims2.Count()); int index = 0; Dictionary <Claim, Claim> dict = claims.ToDictionary(x => x, y => claims2.Skip(index++).First()); dict.ForEach(kvp => Assert.AreSame(kvp.Key, kvp.Value)); }
public override Tuple <object, TypeOfDefaultValue> GetDefault(INakedObjectAdapter nakedObjectAdapter) { // type safety is given by the reflector only identifying methods that match the // parameter type var defaultValue = methodDelegate(nakedObjectAdapter.GetDomainObject(), new object[] {}); return(new Tuple <object, TypeOfDefaultValue>(defaultValue, TypeOfDefaultValue.Explicit)); }
/// <summary> /// Whether the provided argument exceeds the <see cref="SingleIntValueFacetAbstract.Value" /> maximum length}. /// </summary> public virtual bool Exceeds(INakedObjectAdapter nakedObjectAdapter) { var str = nakedObjectAdapter.GetDomainObject() as string; if (str == null) { return false; } int maxLength = Value; return maxLength != 0 && str.Length > maxLength; }
public override string InvalidReason(INakedObjectAdapter target, INakedObjectAdapter proposedValue) { if (proposedValue != null) { return((string)methodDelegate(target.GetDomainObject(), new[] { proposedValue.GetDomainObject() })); } return(null); }
public void InitProperty(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter value) { try { property.SetValue(nakedObjectAdapter.GetDomainObject(), value.GetDomainObject(), null); } catch (TargetInvocationException e) { InvokeUtils.InvocationException("Exception executing " + property, e); } }
public override (object, TypeOfDefaultValue) GetDefault(INakedObjectAdapter nakedObjectAdapter, ISession session, IObjectPersistor persistor) { // type safety is given by the reflector only identifying methods that match the // parameter type var defaultValue = MethodDelegate(nakedObjectAdapter.GetDomainObject(), new object[] { }); return(defaultValue, TypeOfDefaultValue.Explicit); }
public string InvalidReason(INakedObjectAdapter target, INakedObjectAdapter[] proposedArguments) { if (methodDelegate != null) { return (string)methodDelegate(target.GetDomainObject(), proposedArguments.Select(no => no.GetDomainObject()).ToArray()); } //Fall back (e.g. if method has > 6 params) on reflection... Log.WarnFormat("Invoking validate method via reflection as no delegate {0}.{1}", target, method); return (string)InvokeUtils.Invoke(method, target, proposedArguments); }
public override void SetProperty(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter value, ITransactionManager transactionManager, ISession session, ILifecycleManager lifecycleManager) { try { property.SetValue(nakedObjectAdapter.GetDomainObject(), value.GetDomainObject(), null); } catch (TargetInvocationException e) { InvokeUtils.InvocationException("Exception executing " + property, e); } }
public bool IsSet(INakedObjectAdapter nakedObjectAdapter) { if (!nakedObjectAdapter.Exists()) { return(false); } return(nakedObjectAdapter.GetDomainObject <bool>()); }
public override void Init(INakedObjectAdapter collection, INakedObjectAdapter[] initData) { Array newCollection = Array.CreateInstance(collection.GetDomainObject().GetType().GetElementType(), initData.Length); collection.ReplacePoco(newCollection); int i = 0; foreach (INakedObjectAdapter nakedObject in initData) { AsCollection(collection)[i++] = nakedObject.Object; } }
public override bool IsEditView(INakedObjectAdapter nakedObjectAdapter) { var target = nakedObjectAdapter.GetDomainObject<IViewModelSwitchable>(); if (target != null) { return target.IsEditView(); } throw new NakedObjectSystemException(nakedObjectAdapter.Object == null ? "Null domain object" : "Wrong type of domain object: " + nakedObjectAdapter.Object.GetType().FullName); }
public override void SetProperty(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter value, ITransactionManager transactionManager, ISession session, ILifecycleManager lifecycleManager) { try { property.SetValue(nakedObjectAdapter.GetDomainObject(), value.GetDomainObject(), null); } catch (TargetInvocationException e) { InvokeUtils.InvocationException("Exception executing " + property, e); } }
public object GetProperty(INakedObjectAdapter nakedObjectAdapter) { try { return propertyMethod.GetValue(nakedObjectAdapter.GetDomainObject(), null); } catch (TargetInvocationException e) { InvokeUtils.InvocationException("Exception executing " + propertyMethod, e); return null; } }
public void InitProperty(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter value) { try { property.SetValue(nakedObjectAdapter.GetDomainObject(), value.GetDomainObject(), null); } catch (TargetInvocationException e) { InvokeUtils.InvocationException("Exception executing " + property, e); } }
/// <summary> /// Whether the provided argument exceeds the <see cref="SingleIntValueFacetAbstract.Value" /> maximum length}. /// </summary> public virtual bool Exceeds(INakedObjectAdapter nakedObjectAdapter) { if (nakedObjectAdapter.GetDomainObject() is string str) { var maxLength = Value; return(maxLength != 0 && str.Length > maxLength); } return(false); }
public string HiddenReason(INakedObjectAdapter nakedObjectAdapter) { if (nakedObjectAdapter == null) { return(null); } var isHidden = (bool)methodDelegate(nakedObjectAdapter.GetDomainObject(), new object[] {}); return(isHidden ? Resources.NakedObjects.Hidden : null); }
public object GetProperty(INakedObjectAdapter nakedObjectAdapter) { try { return(propertyMethod.GetValue(nakedObjectAdapter.GetDomainObject(), null)); } catch (TargetInvocationException e) { InvokeUtils.InvocationException("Exception executing " + propertyMethod, e); return(null); } }
public bool IsEditable(ISession session, ILifecycleManager lifecycleManager, INakedObjectAdapter target, IIdentifier identifier) { object authorizer = GetAuthorizer(target, lifecycleManager); Type authType = authorizer.GetType(); if ((typeof(INamespaceAuthorizer)).IsAssignableFrom(authType)) { var nameAuth = (INamespaceAuthorizer) authorizer; return nameAuth.IsEditable(session.Principal, target.Object, identifier.MemberName); } return isEditableDelegates[authType](authorizer, session.Principal, target.GetDomainObject(), identifier.MemberName); }
public string InvalidReason(INakedObjectAdapter target, INakedObjectAdapter[] proposedArguments) { if (methodDelegate != null) { return((string)methodDelegate(target.GetDomainObject(), proposedArguments.Select(no => no.GetDomainObject()).ToArray())); } //Fall back (e.g. if method has > 6 params) on reflection... Log.WarnFormat("Invoking validate method via reflection as no delegate {0}.{1}", target, method); return((string)InvokeUtils.Invoke(method, target, proposedArguments)); }
public object[] GetCompletions(INakedObjectAdapter inObjectAdapter, string autoCompleteParm, ISession session, IObjectPersistor persistor) { try { var autoComplete = methodDelegate(inObjectAdapter.GetDomainObject(), new object[] { autoCompleteParm }); return(autoComplete switch { IQueryable queryable => queryable.Take(PageSize).ToArray(), IEnumerable <string> strings => strings.Cast <object>().ToArray(), _ when !CollectionUtils.IsCollection(autoComplete.GetType()) => new[] { autoComplete }, _ => throw new NakedObjectDomainException($"Must return IQueryable or a single object from autoComplete method: {method.Name}") }); }
public void TestActionNoParmsTransient() { INakedObjectAdapter targetNo = NakedObjectsFramework.LifecycleManager.CreateInstance((IObjectSpec)NakedObjectsFramework.MetamodelManager.GetSpecification(typeof(TestDomainObject))); IActionSpec actionSpec = targetNo.Spec.GetActions().Single(a => a.Id == "Action1"); var memento = new CollectionMemento(NakedObjectsFramework.LifecycleManager, NakedObjectsFramework.NakedObjectManager, NakedObjectsFramework.MetamodelManager, targetNo, actionSpec, new INakedObjectAdapter[] {}); RoundTrip(memento); RecoverCollection(targetNo.GetDomainObject <TestDomainObject>().Action1(), memento, NakedObjectsFramework.NakedObjectManager); }
public override bool IsEditView(INakedObjectAdapter nakedObjectAdapter) { var target = nakedObjectAdapter.GetDomainObject <IViewModelSwitchable>(); if (target != null) { return(target.IsEditView()); } throw new NakedObjectSystemException(Log.LogAndReturn(nakedObjectAdapter.Object == null ? "Null domain object" : $"Wrong type of domain object: {nakedObjectAdapter.Object.GetType().FullName}")); }
public void Persist <T>(ref T transientObject) { INakedObjectAdapter adapter = framework.NakedObjectManager.GetAdapterFor(transientObject); if (IsPersistent(transientObject)) { throw new PersistFailedException(Log.LogAndReturn(string.Format(Resources.NakedObjects.AlreadyPersistentMessage, adapter))); } Validate(adapter); framework.LifecycleManager.MakePersistent(adapter); transientObject = adapter.GetDomainObject <T>(); }
/// <summary> /// Whether the provided argument exceeds the <see cref="SingleIntValueFacetAbstract.Value" /> maximum length}. /// </summary> public virtual bool Exceeds(INakedObjectAdapter nakedObjectAdapter) { var str = nakedObjectAdapter.GetDomainObject() as string; if (str == null) { return(false); } int maxLength = Value; return(maxLength != 0 && str.Length > maxLength); }
public bool IsEditable(ISession session, ILifecycleManager lifecycleManager, INakedObjectAdapter target, IIdentifier identifier) { object authorizer = GetAuthorizer(target, lifecycleManager); Type authType = authorizer.GetType(); if (typeof(INamespaceAuthorizer).IsAssignableFrom(authType)) { var nameAuth = (INamespaceAuthorizer)authorizer; return(nameAuth.IsEditable(session.Principal, target.Object, identifier.MemberName)); } return(isEditableDelegates[authType](authorizer, session.Principal, target.GetDomainObject(), identifier.MemberName)); }
public override void Init(INakedObjectAdapter collection, INakedObjectAdapter[] initData) { Array newCollection = Array.CreateInstance(collection.GetDomainObject().GetType().GetElementType(), initData.Length); collection.ReplacePoco(newCollection); int i = 0; foreach (INakedObjectAdapter nakedObject in initData) { AsCollection(collection)[i++] = nakedObject.Object; } }
public void Invoke(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter[] parameters, bool queryOnly, IIdentifier identifier, ISession session, ILifecycleManager lifecycleManager) { IAuditor auditor = GetAuditor(nakedObjectAdapter, lifecycleManager); IPrincipal byPrincipal = session.Principal; string memberName = identifier.MemberName; if (nakedObjectAdapter.Spec is IServiceSpec) { string serviceName = nakedObjectAdapter.Spec.GetTitle(nakedObjectAdapter); auditor.ActionInvoked(byPrincipal, memberName, serviceName, queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray()); } else { auditor.ActionInvoked(byPrincipal, memberName, nakedObjectAdapter.GetDomainObject(), queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray()); } }
public override bool IsEditView(INakedObjectAdapter nakedObjectAdapter, ISession session, IObjectPersistor persistor) { var target = nakedObjectAdapter.GetDomainObject <IViewModelSwitchable>(); if (target == null) { throw new NakedObjectSystemException(nakedObjectAdapter.Object == null ? "Null domain object" : $"Wrong type of domain object: {nakedObjectAdapter.Object.GetType().FullName}"); } return(target.IsEditView()); }
public bool IsVisible(ISession session, ILifecycleManager lifecycleManager, INakedObjectAdapter target, IIdentifier identifier) { var authorizer = GetAuthorizer(target, lifecycleManager); var authType = authorizer.GetType(); if (typeof(INamespaceAuthorizer).IsAssignableFrom(authType)) { var nameAuth = (INamespaceAuthorizer)authorizer; return(nameAuth.IsVisible(session.Principal, target.Object, identifier.MemberName)); } //Must be an ITypeAuthorizer, including default authorizer (ITypeAuthorizer<object>) return(isVisibleDelegates[authType](authorizer, session.Principal, target.GetDomainObject(), identifier.MemberName)); }
public INakedObjectAdapter RecoverCollection() { INakedObjectAdapter nakedObjectAdapter = Action.Execute(Target, Parameters); if (selectedObjects != null) { IEnumerable <object> selected = nakedObjectAdapter.GetDomainObject <IEnumerable>().Cast <object>().Where(x => selectedObjects.Contains(x)); IList newResult = CollectionUtils.CloneCollectionAndPopulate(nakedObjectAdapter.Object, selected); nakedObjectAdapter = nakedObjectManager.CreateAdapter(newResult, null, null); } nakedObjectAdapter.SetATransientOid(this); return(nakedObjectAdapter); }
public override object[] GetChoices(INakedObjectAdapter nakedObjectAdapter, IDictionary<string, INakedObjectAdapter> parameterNameValues) { INakedObjectAdapter[] parms = FacetUtils.MatchParameters(parameterNames, parameterNameValues); try { var options = choicesDelegate(nakedObjectAdapter.GetDomainObject(), parms.Select(p => p.GetDomainObject()).ToArray()) as IEnumerable; if (options != null) { return options.Cast<object>().ToArray(); } throw new NakedObjectDomainException(Log.LogAndReturn($"Must return IEnumerable from choices method: {choicesMethod.Name}")); } catch (ArgumentException ae) { throw new InvokeException(Log.LogAndReturn($"Choices exception: {choicesMethod.Name} has mismatched (ie type of choices parameter does not match type of action parameter) parameter types"), ae); } }
public object[] GetChoices(INakedObjectAdapter inObjectAdapter, IDictionary<string, INakedObjectAdapter> parameterNameValues) { INakedObjectAdapter[] parms = FacetUtils.MatchParameters(parameterNames, parameterNameValues); try { object options = methodDelegate(inObjectAdapter.GetDomainObject(), parms.Select(p => p.GetDomainObject()).ToArray()); var enumerable = options as IEnumerable; if (enumerable != null) { return enumerable.Cast<object>().ToArray(); } throw new NakedObjectDomainException(Log.LogAndReturn($"Must return IEnumerable from choices method: {method.Name}")); } catch (ArgumentException ae) { throw new InvokeException(Log.LogAndReturn($"Choices exception: {method.Name} has mismatched (ie type of parameter does not match type of property) parameter types"), ae); } }
public override object[] GetChoices(INakedObjectAdapter nakedObjectAdapter, IDictionary <string, INakedObjectAdapter> parameterNameValues) { INakedObjectAdapter[] parms = FacetUtils.MatchParameters(parameterNames, parameterNameValues); try { var options = choicesDelegate(nakedObjectAdapter.GetDomainObject(), parms.Select(p => p.GetDomainObject()).ToArray()) as IEnumerable; if (options != null) { return(options.Cast <object>().ToArray()); } throw new NakedObjectDomainException(Log.LogAndReturn($"Must return IEnumerable from choices method: {choicesMethod.Name}")); } catch (ArgumentException ae) { throw new InvokeException(Log.LogAndReturn($"Choices exception: {choicesMethod.Name} has mismatched (ie type of choices parameter does not match type of action parameter) parameter types"), ae); } }
public void Invoke(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter[] parameters, bool queryOnly, IIdentifier identifier, ISession session, ILifecycleManager lifecycleManager) { IAuditor auditor = GetAuditor(nakedObjectAdapter, lifecycleManager); IPrincipal byPrincipal = session.Principal; string memberName = identifier.MemberName; if (nakedObjectAdapter.Spec is IServiceSpec) { string serviceName = nakedObjectAdapter.Spec.GetTitle(nakedObjectAdapter); auditor.ActionInvoked(byPrincipal, memberName, serviceName, queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray()); } else { auditor.ActionInvoked(byPrincipal, memberName, nakedObjectAdapter.GetDomainObject(), queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray()); } }
public object[] GetChoices(INakedObjectAdapter inObjectAdapter, IDictionary <string, INakedObjectAdapter> parameterNameValues) { INakedObjectAdapter[] parms = FacetUtils.MatchParameters(parameterNames, parameterNameValues); try { object options = methodDelegate(inObjectAdapter.GetDomainObject(), parms.Select(p => p.GetDomainObject()).ToArray()); var enumerable = options as IEnumerable; if (enumerable != null) { return(enumerable.Cast <object>().ToArray()); } throw new NakedObjectDomainException("Must return IEnumerable from choices method: " + method.Name); } catch (ArgumentException ae) { string msg = string.Format("Choices exception: {0} has mismatched (ie type of parameter does not match type of property) parameter types", method.Name); throw new InvokeException(msg, ae); } }
public override INakedObjectAdapter Invoke(INakedObjectAdapter inObjectAdapter, INakedObjectAdapter[] parameters, ILifecycleManager lifecycleManager, IMetamodelManager manager, ISession session, INakedObjectManager nakedObjectManager, IMessageBroker messageBroker, ITransactionManager transactionManager) { if (parameters.Length != paramCount) { Log.Error(actionMethod + " requires " + paramCount + " parameters, not " + parameters.Length); } object result; if (actionDelegate != null) { result = actionDelegate(inObjectAdapter.GetDomainObject(), parameters.Select(no => no.GetDomainObject()).ToArray()); } else { Log.WarnFormat("Invoking action via reflection as no delegate {0}.{1}", onType, actionMethod); result = InvokeUtils.Invoke(actionMethod, inObjectAdapter, parameters); } INakedObjectAdapter adaptedResult = nakedObjectManager.CreateAdapter(result, null, null); return adaptedResult; }
public override Tuple<object, TypeOfDefaultValue> GetDefault(INakedObjectAdapter nakedObjectAdapter) { // type safety is given by the reflector only identifying methods that match the // parameter type var defaultValue = methodDelegate(nakedObjectAdapter.GetDomainObject(), new object[]{}); return new Tuple<object, TypeOfDefaultValue>(defaultValue, TypeOfDefaultValue.Explicit); }
public override string GetIconName(INakedObjectAdapter nakedObjectAdapter) { return (string) methodDelegate(nakedObjectAdapter.GetDomainObject(), new object[] {}); }
public void End(ISession session, ProfileEvent profileEvent, string member, INakedObjectAdapter nakedObjectAdapter, ILifecycleManager lifecycleManager) { GetProfiler(lifecycleManager).End(session.Principal, profileEvent, nakedObjectAdapter.GetDomainObject().GetType(), member); }
public override string Invoke(INakedObjectAdapter nakedObjectAdapter, Exception exception) { return (string) methodDelegate(nakedObjectAdapter.GetDomainObject(), new object[] {exception}); }
public override string[] Derive(INakedObjectAdapter nakedObjectAdapter, INakedObjectManager nakedObjectManager, IDomainObjectInjector injector) { return nakedObjectAdapter.GetDomainObject<IViewModel>().DeriveKeys(); }
public string Execute(INakedObjectAdapter obj, INakedObjectAdapter[] parameters) { return methodDelegate(obj.GetDomainObject(), parameters.Select(no => no.GetDomainObject()).ToArray()) as string; }
public override void Populate(string[] keys, INakedObjectAdapter nakedObjectAdapter, INakedObjectManager nakedObjectManager, IDomainObjectInjector injector) { nakedObjectAdapter.GetDomainObject<IViewModel>().PopulateUsingKeys(keys); }
public override string GetTitle(INakedObjectAdapter nakedObjectAdapter, INakedObjectManager nakedObjectManager) { return methodDelegate(nakedObjectAdapter.GetDomainObject(), new object[] {}) as string; }
private void InitializeNewObject(INakedObjectAdapter nakedObjectAdapter) { InitializeNewObject(nakedObjectAdapter, nakedObjectAdapter.GetDomainObject()); }
public void Persisted(INakedObjectAdapter nakedObjectAdapter, ISession session, ILifecycleManager lifecycleManager) { IAuditor auditor = GetAuditor(nakedObjectAdapter, lifecycleManager); auditor.ObjectPersisted(session.Principal, nakedObjectAdapter.GetDomainObject()); }
public override string InvalidReason(INakedObjectAdapter target, INakedObjectAdapter proposedValue) { if (proposedValue != null) { return (string) methodDelegate(target.GetDomainObject(), new[] {proposedValue.GetDomainObject()}); } return null; }
public override void Invoke(INakedObjectAdapter nakedObjectAdapter, ISession session, ILifecycleManager lifecycleManager, IMetamodelManager metamodelManager) { createdDelegate(nakedObjectAdapter.GetDomainObject()); }
public override object GetDefault(INakedObjectAdapter inObjectAdapter) { return methodDelegate(inObjectAdapter.GetDomainObject(), new object[] {}); }