public static object CreateObject(this EntityObjectStore.LocalContext context, Type type)
{
object objectSet = context.GetObjectSet(type);
var methods = objectSet.GetType().GetMethods();
var mi = methods.Single(m => m.Name == "CreateObject" && m.IsGenericMethod).MakeGenericMethod(type);
return(InvokeUtils.Invoke(mi, objectSet, null));
}
public override string InvalidReason(INakedObject target, INakedObject proposedValue)
{
if (proposedValue != null)
{
return((string)InvokeUtils.Invoke(method, target, new[] { proposedValue }));
}
return(null);
}
public static IQueryable <TDerived> GetObjectSetOfType <TDerived, TBase>(this EntityObjectStore.LocalContext context) where TDerived : TBase
{
MethodInfo mi = context.WrappedObjectContext.GetType().GetMethod("CreateObjectSet", Type.EmptyTypes).MakeGenericMethod(typeof(TBase));
var os = (IQueryable <TBase>)InvokeUtils.Invoke(mi, context.WrappedObjectContext, null);
((ObjectQuery)os).MergeOption = context.DefaultMergeOption;
return(os.OfType <TDerived>());
}
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 string HiddenReason(INakedObject nakedObject)
{
if (nakedObject == null)
{
return(null);
}
var isHidden = (bool)InvokeUtils.Invoke(method, nakedObject);
return(isHidden ? Resources.NakedObjects.Hidden : null);
}
public override INakedObject Invoke(INakedObject inObject, INakedObject[] parameters, ILifecycleManager lifecycleManager, IMetamodelManager manager, ISession session, INakedObjectManager nakedObjectManager)
{
if (parameters.Length != paramCount)
{
Log.Error(actionMethod + " requires " + paramCount + " parameters, not " + parameters.Length);
}
object result = InvokeUtils.Invoke(actionMethod, inObject, parameters);
INakedObject adaptedResult = nakedObjectManager.CreateAdapter(result, null, null);
Log.DebugFormat("Action result {0}", adaptedResult);
return(adaptedResult);
}
public object[] GetCompletions(INakedObject inObject, string autoCompleteParm)
{
try {
object autoComplete = InvokeUtils.Invoke(method, inObject.GetDomainObject(), new object[] { autoCompleteParm });
var complete = autoComplete as IQueryable;
if (complete != null)
{
return(complete.Take(PageSize).ToArray());
}
throw new NakedObjectDomainException("Must return IQueryable 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 override object[] GetChoices(INakedObject nakedObject, IDictionary <string, INakedObject> parameterNameValues)
{
INakedObject[] parms = FacetUtils.MatchParameters(parameterNames, parameterNameValues);
try {
var options = InvokeUtils.Invoke(choicesMethod, nakedObject, parms) as IEnumerable;
if (options != null)
{
return(options.Cast <object>().ToArray());
}
throw new NakedObjectDomainException("Must return IEnumerable from choices method: " + choicesMethod.Name);
}
catch (ArgumentException ae) {
string msg = string.Format("Choices exception: {0} has mismatched (ie type of choices parameter does not match type of action parameter) parameter types", choicesMethod.Name);
throw new InvokeException(msg, ae);
}
}
public object[] GetChoices(INakedObject inObject, IDictionary <string, INakedObject> parameterNameValues)
{
INakedObject[] parms = FacetUtils.MatchParameters(parameterNames, parameterNameValues);
try {
object options = InvokeUtils.Invoke(method, inObject, parms);
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)
{
logger.LogError($"{ActionMethod} requires {paramCount} parameters, not {parameters.Length}");
}
object result;
if (ActionDelegate != null)
{
result = ActionDelegate(inObjectAdapter.GetDomainObject(), parameters.Select(no => no.GetDomainObject()).ToArray());
}
else
{
logger.LogWarning($"Invoking action via reflection as no delegate {OnType}.{ActionMethod}");
result = InvokeUtils.Invoke(ActionMethod, inObjectAdapter, parameters);
}
return(nakedObjectManager.CreateAdapter(result, null, null));
}
public override INakedObjectAdapter Invoke(INakedObjectAdapter inObjectAdapter, INakedObjectAdapter[] parameters, INakedObjectsFramework framework)
{
if (parameters.Length != paramCount)
{
logger.LogError($"{ActionMethod} requires {paramCount} parameters, not {parameters.Length}");
}
object result;
if (ActionDelegate != null)
{
result = ActionDelegate(inObjectAdapter.GetDomainObject(), parameters.Select(no => no.GetDomainObject()).ToArray());
}
else
{
logger.LogWarning($"Invoking action via reflection as no delegate {OnType}.{ActionMethod}");
result = InvokeUtils.Invoke(ActionMethod, inObjectAdapter, parameters);
}
return(framework.NakedObjectManager.CreateAdapter(result, null, null));
}
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 string InvalidReason(INakedObject target, INakedObject proposedArgument)
{
return((string)InvokeUtils.Invoke(method, target, new[] { proposedArgument }));
}
public override void SetProperty(INakedObject inObject, INakedObject value, ITransactionManager transactionManager)
{
InvokeUtils.Invoke(method, inObject, new[] { value });
}
public override void Invoke(INakedObject nakedObject, ISession session, ILifecycleManager lifecycleManager, IMetamodelManager metamodelManager)
{
InvokeUtils.Invoke(method, nakedObject);
}
public override void ClearProperty(INakedObject nakedObject, ITransactionManager transactionManager)
{
InvokeUtils.Invoke(method, nakedObject);
}
public string InvalidReason(INakedObject target, INakedObject[] proposedArguments)
{
return((string)InvokeUtils.Invoke(method, target, proposedArguments));
}
public override string GetTitle(INakedObject nakedObject, INakedObjectManager nakedObjectManager)
{
object obj = InvokeUtils.Invoke(method, nakedObject);
return(obj == null ? null : nakedObjectManager.CreateAdapter(obj, null, null).TitleString());
}
public override string Invoke(INakedObject nakedObject, Exception exception)
{
return((string)InvokeUtils.Invoke(method, nakedObject.Object, new object[] { exception }));
}
public override string GetIconName(INakedObject nakedObject)
{
return((string)InvokeUtils.Invoke(method, nakedObject));
}
public override object GetDefault(INakedObject inObject)
{
return(InvokeUtils.Invoke(method, inObject));
}
public override Tuple <object, TypeOfDefaultValue> GetDefault(INakedObject nakedObject)
{
// type safety is given by the reflector only identifying methods that match the
// parameter type
return(new Tuple <object, TypeOfDefaultValue>(InvokeUtils.Invoke(method, nakedObject), TypeOfDefaultValue.Explicit));
}
public string DisabledReason(INakedObject nakedObject)
{
return((string)InvokeUtils.Invoke(method, nakedObject));
}
public override string GetTitle(INakedObject nakedObject, INakedObjectManager nakedObjectManager)
{
return(InvokeUtils.Invoke(method, nakedObject) as string);
}
public string Execute(INakedObject obj, INakedObject[] parameters)
{
return(InvokeUtils.Invoke(method, obj, parameters) as string);
}
