public override ImmutableDictionary <String, ITypeSpecBuilder> ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder, ImmutableDictionary <String, ITypeSpecBuilder> metamodel)
{
ParameterInfo parameter = method.GetParameters()[paramNum];
var facets = new List <IFacet>();
if (parameter.ParameterType.IsGenericType && (parameter.ParameterType.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
facets.Add(new NullableFacetAlways(holder));
}
var result = reflector.LoadSpecification(parameter.ParameterType, metamodel);
metamodel = result.Item2;
var returnSpec = result.Item1 as IObjectSpecBuilder;
if (returnSpec != null && IsCollection(parameter.ParameterType))
{
Type elementType = CollectionUtils.ElementType(parameter.ParameterType);
result = reflector.LoadSpecification(elementType, metamodel);
metamodel = result.Item2;
var elementSpec = result.Item1 as IObjectSpecImmutable;
facets.Add(new ElementTypeFacet(holder, elementType, elementSpec));
}
FacetUtils.AddFacets(facets);
return(metamodel);
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) =>
FacetUtils.AddFacets(
new IFacet[] {
new DescribedAsFacetNone(specification),
new ImmutableFacetNever(specification),
new TitleFacetNone(specification)
});
private static void Process(ISpecification holder)
{
var facets = new List <IFacet>();
if (holder is IMemberSpecImmutable specImmutable)
{
facets.Add(new NamedFacetInferred(specImmutable.Identifier.MemberName, holder));
facets.Add(new DescribedAsFacetNone(holder));
}
if (holder is IAssociationSpecImmutable)
{
facets.Add(new ImmutableFacetNever(holder));
facets.Add(new PropertyDefaultFacetNone(holder));
facets.Add(new PropertyValidateFacetNone(holder));
}
if (holder is IOneToOneAssociationSpecImmutable immutable)
{
facets.Add(new MaxLengthFacetZero(holder));
DefaultTypicalLength(facets, immutable.ReturnSpec, immutable);
facets.Add(new MultiLineFacetNone(holder));
}
if (holder is IActionSpecImmutable)
{
facets.Add(new ExecutedFacetDefault(holder));
facets.Add(new ActionDefaultsFacetNone(holder));
facets.Add(new ActionChoicesFacetNone(holder));
facets.Add(new PageSizeFacetDefault(holder));
}
FacetUtils.AddFacets(facets);
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification)
{
var facets = new List <IFacet>();
if (IsAbstract(type))
{
facets.Add(new TypeIsAbstractFacet(specification));
}
if (IsInterface(type))
{
facets.Add(new TypeIsInterfaceFacet(specification));
}
if (IsSealed(type))
{
facets.Add(new TypeIsSealedFacet(specification));
}
if (IsVoid(type))
{
facets.Add(new TypeIsVoidFacet(specification));
}
FacetUtils.AddFacets(facets);
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification)
{
var facets = new List <IFacet>();
var namedFacet = specification.GetFacet <INamedFacet>();
if (namedFacet == null)
{
string inferredName = NameUtils.NaturalName(ShortName(type));
namedFacet = new NamedFacetInferred(inferredName, specification);
facets.Add(namedFacet);
Log.InfoFormat("No name facet found inferring name {0}", inferredName);
}
var pluralFacet = specification.GetFacet <IPluralFacet>();
if (pluralFacet == null)
{
string pluralName = NameUtils.PluralName(namedFacet.Value);
pluralFacet = new PluralFacetInferred(pluralName, specification);
facets.Add(pluralFacet);
Log.InfoFormat("No plural facet found inferring name {0}", pluralName);
}
FacetUtils.AddFacets(facets);
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification)
{
var namedFacet = specification.GetFacet <INamedFacet>() ?? new NamedFacetInferred(type.Name, specification);
IFacet pluralFacet = specification.GetFacet <IPluralFacet>() ?? new PluralFacetInferred(NameUtils.PluralName(namedFacet.NaturalName), specification);
var facets = new[] { namedFacet, pluralFacet };
FacetUtils.AddFacets(facets);
}
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, Type type, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
FacetUtils.AddFacets(
new IFacet[] {
new DescribedAsFacetNone(specification),
new ImmutableFacetNever(specification),
new TitleFacetNone(specification)
});
return(metamodel);
}
public override ImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification, ImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
var facets = new List <IFacet> {
new TypeIsAbstractFacet(specification, IsAbstract(type)),
new TypeIsInterfaceFacet(specification, IsInterface(type)),
new TypeIsSealedFacet(specification, IsSealed(type)),
new TypeIsVoidFacet(specification, IsVoid(type))
};
FacetUtils.AddFacets(facets);
return(metamodel);
}
public override void Process(IReflector reflector, MethodInfo actionMethod, IMethodRemover methodRemover, ISpecificationBuilder action)
{
string capitalizedName = NameUtils.CapitalizeName(actionMethod.Name);
Type type = actionMethod.DeclaringType;
var facets = new List <IFacet>();
ITypeSpecBuilder onType = reflector.LoadSpecification(type);
var returnSpec = reflector.LoadSpecification <IObjectSpecBuilder>(actionMethod.ReturnType);
IObjectSpecImmutable elementSpec = null;
bool isQueryable = IsQueryOnly(actionMethod) || CollectionUtils.IsQueryable(actionMethod.ReturnType);
if (returnSpec != null && returnSpec.IsCollection)
{
Type elementType = CollectionUtils.ElementType(actionMethod.ReturnType);
elementSpec = reflector.LoadSpecification <IObjectSpecImmutable>(elementType);
}
RemoveMethod(methodRemover, actionMethod);
facets.Add(new ActionInvocationFacetViaMethod(actionMethod, onType, returnSpec, elementSpec, action, isQueryable));
MethodType methodType = actionMethod.IsStatic ? MethodType.Class : MethodType.Object;
Type[] paramTypes = actionMethod.GetParameters().Select(p => p.ParameterType).ToArray();
FindAndRemoveValidMethod(reflector, facets, methodRemover, type, methodType, capitalizedName, paramTypes, action);
DefaultNamedFacet(facets, actionMethod.Name, action); // must be called after the checkForXxxPrefix methods
AddHideForSessionFacetNone(facets, action);
AddDisableForSessionFacetNone(facets, action);
FindDefaultHideMethod(reflector, facets, methodRemover, type, methodType, "ActionDefault", action);
FindAndRemoveHideMethod(reflector, facets, methodRemover, type, methodType, capitalizedName, action);
FindDefaultDisableMethod(reflector, facets, methodRemover, type, methodType, "ActionDefault", action);
FindAndRemoveDisableMethod(reflector, facets, methodRemover, type, methodType, capitalizedName, action);
var actionSpecImmutable = action as IActionSpecImmutable;
if (actionSpecImmutable != null)
{
// Process the action's parameters names, descriptions and optional
// an alternative design would be to have another facet factory processing just ActionParameter, and have it remove these
// supporting methods. However, the FacetFactory API doesn't allow for methods of the class to be removed while processing
// action parameters, only while processing Methods (ie actions)
IActionParameterSpecImmutable[] actionParameters = actionSpecImmutable.Parameters;
string[] paramNames = actionMethod.GetParameters().Select(p => p.Name).ToArray();
FindAndRemoveParametersAutoCompleteMethod(reflector, methodRemover, type, capitalizedName, paramTypes, actionParameters);
FindAndRemoveParametersChoicesMethod(reflector, methodRemover, type, capitalizedName, paramTypes, paramNames, actionParameters);
FindAndRemoveParametersDefaultsMethod(reflector, methodRemover, type, capitalizedName, paramTypes, paramNames, actionParameters);
FindAndRemoveParametersValidateMethod(reflector, methodRemover, type, capitalizedName, paramTypes, paramNames, actionParameters);
}
FacetUtils.AddFacets(facets);
}
public override ImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder specification, ImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
string capitalizedName = property.Name;
var paramTypes = new[] { property.PropertyType };
var facets = new List <IFacet> {
new PropertyAccessorFacet(property, specification)
};
if (property.PropertyType.IsGenericType && (property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
facets.Add(new NullableFacetAlways(specification));
}
if (property.GetSetMethod() != null)
{
if (property.PropertyType == typeof(byte[]))
{
facets.Add(new DisabledFacetAlways(specification));
}
else
{
facets.Add(new PropertySetterFacetViaSetterMethod(property, specification));
}
facets.Add(new PropertyInitializationFacet(property, specification));
}
else
{
facets.Add(new NotPersistedFacet(specification));
facets.Add(new DisabledFacetAlways(specification));
}
FindAndRemoveModifyMethod(reflector, facets, methodRemover, property.DeclaringType, capitalizedName, paramTypes, specification);
FindAndRemoveAutoCompleteMethod(reflector, facets, methodRemover, property.DeclaringType, capitalizedName, property.PropertyType, specification);
metamodel = FindAndRemoveChoicesMethod(reflector, facets, methodRemover, property.DeclaringType, capitalizedName, property.PropertyType, specification, metamodel);
FindAndRemoveDefaultMethod(reflector, facets, methodRemover, property.DeclaringType, capitalizedName, property.PropertyType, specification);
FindAndRemoveValidateMethod(reflector, facets, methodRemover, property.DeclaringType, paramTypes, capitalizedName, specification);
AddHideForSessionFacetNone(facets, specification);
AddDisableForSessionFacetNone(facets, specification);
FindDefaultHideMethod(reflector, facets, methodRemover, property.DeclaringType, MethodType.Object, "PropertyDefault", specification);
FindAndRemoveHideMethod(reflector, facets, methodRemover, property.DeclaringType, MethodType.Object, capitalizedName, specification);
FindDefaultDisableMethod(reflector, facets, methodRemover, property.DeclaringType, MethodType.Object, "PropertyDefault", specification);
FindAndRemoveDisableMethod(reflector, facets, methodRemover, property.DeclaringType, MethodType.Object, capitalizedName, specification);
FacetUtils.AddFacets(facets);
return(metamodel);
}
public override void Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder collection)
{
string capitalizedName = property.Name;
Type type = property.DeclaringType;
var facets = new List <IFacet> {
new PropertyAccessorFacet(property, collection)
};
AddSetFacet(facets, property, collection);
AddHideForSessionFacetNone(facets, collection);
AddDisableFacetAlways(facets, collection);
FindDefaultHideMethod(reflector, facets, methodRemover, property.DeclaringType, MethodType.Object, "PropertyDefault", collection);
FindAndRemoveHideMethod(reflector, facets, methodRemover, type, MethodType.Object, capitalizedName, collection);
FacetUtils.AddFacets(facets);
}
public override void ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder)
{
var facets = new List <IFacet>();
if (holder is IActionParameterSpecImmutable param)
{
var name = method.GetParameters()[paramNum].Name ?? method.GetParameters()[paramNum].ParameterType.FullName;
INamedFacet namedFacet = new NamedFacetInferred(name, holder);
facets.Add(namedFacet);
facets.Add(new DescribedAsFacetNone(holder));
facets.Add(new MultiLineFacetNone(holder));
facets.Add(new MaxLengthFacetZero(holder));
facets.Add(new TypicalLengthFacetZero(holder));
DefaultTypicalLength(facets, param.Specification, param);
}
FacetUtils.AddFacets(facets);
}
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, PropertyInfo property, ISpecificationBuilder collection, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
var capitalizedName = property.Name;
var type = property.DeclaringType;
var facets = new List <IFacet> {
new PropertyAccessorFacet(property, collection)
};
AddSetFacet(facets, property, collection);
MethodHelpers.AddHideForSessionFacetNone(facets, collection);
MethodHelpers.AddDisableFacetAlways(facets, collection);
MethodHelpers.FindDefaultHideMethod(reflector, facets, property.DeclaringType, MethodType.Object, "PropertyDefault", collection, LoggerFactory);
MethodHelpers.FindAndRemoveHideMethod(reflector, facets, type, MethodType.Object, capitalizedName, collection, LoggerFactory);
FacetUtils.AddFacets(facets);
return(metamodel);
}
public override void ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder)
{
var facets = new List <IFacet>();
var param = holder as ActionParameterSpecImmutable;
if (param != null)
{
string name = method.GetParameters()[paramNum].Name;
INamedFacet namedFacet = name == null ? (INamedFacet) new NamedFacetNone(holder) : new NamedFacetInferred(NameUtils.NaturalName(name), holder);
facets.Add(namedFacet);
facets.Add(new DescribedAsFacetNone(holder));
facets.Add(new MultiLineFacetNone(holder));
facets.Add(new MaxLengthFacetZero(holder));
facets.Add(new TypicalLengthFacetZero(holder));
DefaultTypicalLength(facets, param.Specification, param);
}
FacetUtils.AddFacets(facets);
}
public override IImmutableDictionary <string, ITypeSpecBuilder> ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
var facets = new List <IFacet>();
var param = holder as IActionParameterSpecImmutable;
if (param != null)
{
string name = method.GetParameters()[paramNum].Name ?? method.GetParameters()[paramNum].ParameterType.FullName;
INamedFacet namedFacet = new NamedFacetInferred(name, holder);
facets.Add(namedFacet);
facets.Add(new DescribedAsFacetNone(holder));
facets.Add(new MultiLineFacetNone(holder));
facets.Add(new MaxLengthFacetZero(holder));
facets.Add(new TypicalLengthFacetZero(holder));
DefaultTypicalLength(facets, param.Specification, param);
}
FacetUtils.AddFacets(facets);
return(metamodel);
}
public override void ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder)
{
ParameterInfo parameter = method.GetParameters()[paramNum];
var facets = new List <IFacet>();
if (parameter.ParameterType.IsGenericType && (parameter.ParameterType.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
facets.Add(new NullableFacetAlways(holder));
}
var returnSpec = reflector.LoadSpecification <IObjectSpecBuilder>(parameter.ParameterType);
if (returnSpec != null && returnSpec.IsCollection)
{
Type elementType = CollectionUtils.ElementType(parameter.ParameterType);
var elementSpec = reflector.LoadSpecification <IObjectSpecImmutable>(elementType);
facets.Add(new ElementTypeFacet(holder, elementType, elementSpec));
}
FacetUtils.AddFacets(facets);
}
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification)
{
var facets = new List <IFacet>();
var namedFacet = specification.GetFacet <INamedFacet>();
if (namedFacet == null)
{
namedFacet = new NamedFacetInferred(type.Name, specification);
facets.Add(namedFacet);
}
var pluralFacet = specification.GetFacet <IPluralFacet>();
if (pluralFacet == null)
{
string pluralName = NameUtils.PluralName(namedFacet.NaturalName);
pluralFacet = new PluralFacetInferred(pluralName, specification);
facets.Add(pluralFacet);
}
FacetUtils.AddFacets(facets);
}
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
var facets = new List <IFacet>();
var namedFacet = specification.GetFacet <INamedFacet>();
if (namedFacet == null)
{
namedFacet = new NamedFacetInferred(type.Name, specification);
facets.Add(namedFacet);
}
var pluralFacet = specification.GetFacet <IPluralFacet>();
if (pluralFacet == null)
{
string pluralName = NameUtils.PluralName(namedFacet.NaturalName);
pluralFacet = new PluralFacetInferred(pluralName, specification);
facets.Add(pluralFacet);
}
FacetUtils.AddFacets(facets);
return(metamodel);
}
private static void Process(ISpecification holder)
{
var facets = new List <IFacet>();
if (holder is MemberSpecImmutable)
{
facets.Add(new NamedFacetNone(holder));
facets.Add(new DescribedAsFacetNone(holder));
}
if (holder is AssociationSpecImmutable)
{
facets.Add(new ImmutableFacetNever(holder));
facets.Add(new PropertyDefaultFacetNone(holder));
facets.Add(new PropertyValidateFacetNone(holder));
}
var immutable = holder as OneToOneAssociationSpecImmutable;
if (immutable != null)
{
OneToOneAssociationSpecImmutable association = immutable;
facets.Add(new MaxLengthFacetZero(holder));
DefaultTypicalLength(facets, association.ReturnSpec, immutable);
facets.Add(new MultiLineFacetNone(holder));
}
if (holder is ActionSpecImmutable)
{
facets.Add(new ExecutedFacetDefault(holder));
facets.Add(new ActionDefaultsFacetNone(holder));
facets.Add(new ActionChoicesFacetNone(holder));
facets.Add(new PageSizeFacetDefault(holder));
}
FacetUtils.AddFacets(facets);
}
public override void Process(IReflector reflector, Type type, IMethodRemover remover, ISpecificationBuilder specification)
{
var facets = new List <IFacet>();
var methods = new List <MethodInfo>();
var method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.CreatedMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new CreatedCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new CreatedCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.PersistingMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new PersistingCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new PersistingCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.PersistedMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new PersistedCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new PersistedCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.UpdatingMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new UpdatingCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new UpdatingCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.UpdatedMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new UpdatedCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new UpdatedCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.LoadingMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new LoadingCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new LoadingCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.LoadedMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new LoadedCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new LoadedCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.DeletingMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new DeletingCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new DeletingCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.DeletedMethod, typeof(void), Type.EmptyTypes);
if (method != null)
{
methods.Add(method);
facets.Add(new DeletedCallbackFacetViaMethod(method, specification));
}
else
{
facets.Add(new DeletedCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.OnUpdatingErrorMethod, typeof(string), new[] { typeof(Exception) });
if (method != null)
{
methods.Add(method);
facets.Add(new OnUpdatingErrorCallbackFacetViaMethod(method, specification, Logger <OnUpdatingErrorCallbackFacetViaMethod>()));
}
else
{
facets.Add(new OnUpdatingErrorCallbackFacetNull(specification));
}
method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.OnPersistingErrorMethod, typeof(string), new[] { typeof(Exception) });
if (method != null)
{
methods.Add(method);
facets.Add(new OnPersistingErrorCallbackFacetViaMethod(method, specification, Logger <OnPersistingErrorCallbackFacetViaMethod>()));
}
else
{
facets.Add(new OnPersistingErrorCallbackFacetNull(specification));
}
remover.RemoveMethods(methods);
FacetUtils.AddFacets(facets);
}
