private ParameterContext[] FilterParmsForContributedActions(IActionSpec action, ITypeSpec targetSpec, string uid) {
IActionParameterSpec[] parms;
if (action.IsContributedMethod && !action.OnSpec.Equals(targetSpec)) {
var tempParms = new List<IActionParameterSpec>();
bool skipped = false;
foreach (IActionParameterSpec parameter in action.Parameters) {
// skip the first parm that matches the target.
if (targetSpec.IsOfType(parameter.Spec) && !skipped) {
skipped = true;
}
else {
tempParms.Add(parameter);
}
}
parms = tempParms.ToArray();
}
else {
parms = action.Parameters;
}
return parms.Select(p => new ParameterContext {
Action = action,
Parameter = p,
OverloadedUniqueId = uid
}).ToArray();
}
private INakedObject[] GetConditionalList(INakedObject nakedObject, ArgumentsContext arguments) {
Tuple<string, IObjectSpec>[] expectedParms = GetChoicesParameters();
IDictionary<string, object> actualParms = arguments.Values;
string[] expectedParmNames = expectedParms.Select(t => t.Item1).ToArray();
string[] actualParmNames = actualParms.Keys.ToArray();
if (expectedParmNames.Count() < actualParmNames.Count()) {
throw new BadRequestNOSException("Wrong number of conditional arguments");
}
if (!actualParmNames.All(expectedParmNames.Contains)) {
throw new BadRequestNOSException("Unrecognised conditional argument(s)");
}
Func<Tuple<string, IObjectSpec>, object> getValue = ep => {
if (actualParms.ContainsKey(ep.Item1)) {
return actualParms[ep.Item1];
}
return ep.Item2.IsParseable ? "" : null;
};
var matchedParms = expectedParms.ToDictionary(ep => ep.Item1, ep => new {
expectedType = ep.Item2,
value = getValue(ep),
actualType = getValue(ep) == null ? null : framework.MetamodelManager.GetSpecification(getValue(ep).GetType())
});
var errors = new List<ContextSurface>();
var mappedArguments = new Dictionary<string, INakedObject>();
foreach (var ep in expectedParms) {
string key = ep.Item1;
var mp = matchedParms[key];
object value = mp.value;
IObjectSpec expectedType = mp.expectedType;
ITypeSpec actualType = mp.actualType;
if (expectedType.IsParseable && actualType.IsParseable) {
string rawValue = value.ToString();
try {
mappedArguments[key] = expectedType.GetFacet<IParseableFacet>().ParseTextEntry(rawValue, framework.NakedObjectManager);
errors.Add(new ChoiceContextSurface(key, GetSpecificationWrapper(expectedType)) {
ProposedValue = rawValue
});
}
catch (Exception e) {
errors.Add(new ChoiceContextSurface(key, GetSpecificationWrapper(expectedType)) {
Reason = e.Message,
ProposedValue = rawValue
});
}
}
else if (actualType != null && !actualType.IsOfType(expectedType)) {
errors.Add(new ChoiceContextSurface(key, GetSpecificationWrapper(expectedType)) {
Reason = string.Format("Argument is of wrong type is {0} expect {1}", actualType.FullName, expectedType.FullName),
ProposedValue = actualParms[ep.Item1]
});
}
else {
mappedArguments[key] = framework.NakedObjectManager.CreateAdapter(value, null, null);
errors.Add(new ChoiceContextSurface(key, GetSpecificationWrapper(expectedType)) {
ProposedValue = getValue(ep)
});
}
}
if (errors.Any(e => !string.IsNullOrEmpty(e.Reason))) {
throw new BadRequestNOSException("Wrong type of conditional argument(s)", errors);
}
return GetChoices(nakedObject, mappedArguments);
}
private static bool IsFileAttachment(this ITypeSpec spec, INakedObjectsFramework framework)
{
ITypeSpec fileSpec = framework.MetamodelManager.GetSpecification(typeof(FileAttachment));
return(spec != null && spec.IsOfType(fileSpec));
}
public static bool IsImage(this ITypeSpec spec, INakedObjectsFramework framework)
{
ITypeSpec imageSpec = framework.MetamodelManager.GetSpecification(typeof(Image));
return(spec != null && spec.IsOfType(imageSpec));
}
public bool IsOfType(ITypeFacade otherSpec)
{
return(spec.IsOfType(((TypeFacade)otherSpec).spec));
}
public bool IsOfType(INakedObjectSpecificationSurface otherSpec)
{
return(spec.IsOfType(((NakedObjectSpecificationWrapper)otherSpec).spec));
}