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