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[] {});
}
