private static IRangeFacet Create(RangeAttribute attribute, bool isDate, IFacetHolder holder) {
if (attribute != null && attribute.OperandType != typeof (int) && attribute.OperandType != typeof (double)) {
Log.WarnFormat("Unsupported use of range attribute with explicit type on {0}", holder);
return null;
}
return attribute == null ? null : new RangeFacetAnnotation(attribute.Minimum, attribute.Maximum, isDate, holder);
}
private static bool Process(IFacetHolder holder) {
var facets = new List<IFacet>();
if (holder is DotNetNakedObjectMemberPeer) {
facets.Add(new NamedFacetNone(holder));
facets.Add(new DescribedAsFacetNone(holder));
}
if (holder is DotNetNakedObjectAssociationPeer) {
facets.Add(new ImmutableFacetNever(holder));
facets.Add(new PropertyDefaultFacetNone(holder));
facets.Add(new PropertyValidateFacetNone(holder));
}
// TODO this should really only be applied to objects marked as ParseableEntryFacet or ones that are externally processed as such
if (holder is IParseableFacet || holder is DotNetOneToOneAssociationPeer) {
var association = (DotNetOneToOneAssociationPeer) holder;
facets.Add(new MaxLengthFacetZero(holder));
DefaultTypicalLength(facets, association.Specification, holder);
facets.Add(new MultiLineFacetNone(holder));
}
if (holder is DotNetNakedObjectActionPeer) {
facets.Add(new ExecutedFacetAtDefault(holder));
facets.Add(new ActionDefaultsFacetNone(holder));
facets.Add(new ActionChoicesFacetNone(holder));
facets.Add(new PageSizeFacetDefault(holder));
}
return FacetUtils.AddFacets(facets);
}
public virtual void DecorateAllHoldersFacets(IFacetHolder holder) {
if (!IsEmpty) {
foreach (Type facetType in holder.FacetTypes) {
DecoratedFacet(facetType, holder);
}
}
}
public override bool Process(MethodInfo method, IMethodRemover methodRemover, IFacetHolder holder) {
if ((method.ReturnType.IsPrimitive || TypeUtils.IsEnum(method.ReturnType)) && method.GetCustomAttribute<OptionallyAttribute>() != null) {
Log.Warn("Ignoring Optionally annotation on primitive parameter on " + method.ReflectedType + "." + method.Name);
return false;
}
return Process(method, holder);
}
public static InteractionBuffer IsValid(IFacetHolder facetHolder, InteractionContext ic, InteractionBuffer buf) {
IFacet[] facets = facetHolder.GetFacets(FacetFilters.IsA(typeof (IValidatingInteractionAdvisor)));
foreach (IValidatingInteractionAdvisor advisor in facets) {
buf.Append(advisor.Invalidates(ic));
}
return buf;
}
private static bool Process(MemberInfo member, IFacetHolder holder) {
Attribute attribute = member.GetCustomAttribute<RegularExpressionAttribute>();
if (attribute == null) {
attribute = member.GetCustomAttribute<RegExAttribute>();
}
return FacetUtils.AddFacet(Create(attribute, holder));
}
public override bool Process(Type type, IMethodRemover methodRemover, IFacetHolder holder) {
IFacet facet = null;
if (!type.IsInterface && typeof (IViewModel).IsAssignableFrom(type)) {
MethodInfo deriveMethod = type.GetMethod("DeriveKeys", new Type[] {});
MethodInfo populateMethod = type.GetMethod("PopulateUsingKeys", new[] {typeof (string[])});
var toRemove = new List<MethodInfo> {deriveMethod, populateMethod};
if (typeof (IViewModelEdit).IsAssignableFrom(type)) {
facet = new ViewModelEditFacetConvention(holder);
}
else if (typeof (IViewModelSwitchable).IsAssignableFrom(type)) {
MethodInfo isEditViewMethod = type.GetMethod("IsEditView");
toRemove.Add(isEditViewMethod);
facet = new ViewModelSwitchableFacetConvention(holder);
}
else {
facet = new ViewModelFacetConvention(holder);
}
methodRemover.RemoveMethods(toRemove.ToArray());
}
return FacetUtils.AddFacet(facet);
}
private static bool Process(MemberInfo member, IFacetHolder holder) {
Attribute attribute = member.GetCustomAttribute<DescriptionAttribute>();
if (attribute == null) {
attribute = member.GetCustomAttribute<DescribedAsAttribute>();
}
return FacetUtils.AddFacet(Create(attribute, holder));
}
protected RegExFacetAbstract(string validation, string format, bool caseSensitive, string failureMessage, IFacetHolder holder)
: base(Type, holder) {
validationPattern = validation;
formatPattern = format;
isCaseSensitive = caseSensitive;
this.failureMessage = failureMessage;
}
private bool AddFacetDerivedFromTypeIfPresent(IFacetHolder holder, Type type) {
ITypicalLengthFacet facet = GetTypicalLengthFacet(type);
if (facet != null) {
return FacetUtils.AddFacet(new TypicalLengthFacetDerivedFromType(facet, holder));
}
return false;
}
private static InteractionBuffer IsUsable(IFacetHolder facetHolder, InteractionContext ic, InteractionBuffer buf) {
IFacet[] facets = facetHolder.GetFacets(FacetFilters.IsA(typeof (IDisablingInteractionAdvisor)));
foreach (IDisablingInteractionAdvisor advisor in facets) {
buf.Append(advisor.Disables(ic));
}
return buf;
}
public ActionInvocationFacetViaMethod(MethodInfo method, INakedObjectSpecification onType, INakedObjectSpecification returnType, IFacetHolder holder)
: base(holder) {
actionMethod = method;
paramCount = method.GetParameters().Length;
this.onType = onType;
this.returnType = returnType;
}
public override bool Process(PropertyInfo property, IMethodRemover methodRemover, IFacetHolder holder) {
if (CollectionUtils.IsCollectionButNotArray(property.PropertyType)) {
holder.AddFacet(new CollectionResetFacet(property, holder));
return true;
}
return base.Process(property, methodRemover, holder);
}
protected NakedObjectAssociationAbstract(string fieldId, INakedObjectSpecification specification, IFacetHolder facetHolder)
: base(fieldId, facetHolder) {
if (specification == null) {
throw new ArgumentException(string.Format(Resources.NakedObjects.MissingFieldType, fieldId));
}
this.specification = specification;
}
public PropertyChoicesFacetViaMethod(MethodInfo optionsMethod, IFacetHolder holder)
: base(holder) {
method = optionsMethod;
parameterNamesAndTypes = optionsMethod.GetParameters().Select(p => new Tuple<string, INakedObjectSpecification>(p.Name.ToLower(), NakedObjectsContext.Reflector.LoadSpecification(p.ParameterType))).ToArray();
parameterNames = parameterNamesAndTypes.Select(pnt => pnt.Item1).ToArray();
}
public DescribedAsFacetDynamicWrapI18n(II18nManager manager, IFacetHolder holder, IIdentifier identifier, IDescribedAsFacet describedAsFacet, int index = -1)
: base(Type, holder) {
this.manager = manager;
this.identifier = identifier;
this.describedAsFacet = describedAsFacet;
this.index = index;
}
/// <summary>
/// Returns a <see cref="IFacetsFacet" /> impl provided that at least one valid
/// factory <see cref="IFacetsFacet.FacetFactories" /> was specified.
/// </summary>
private static IFacetsFacet Create(FacetsAttribute attribute, IFacetHolder holder) {
if (attribute == null) {
return null;
}
var facetsFacetAnnotation = new FacetsFacetAnnotation(attribute, holder);
return facetsFacetAnnotation.FacetFactories.Length > 0 ? facetsFacetAnnotation : null;
}
public override bool Process(Type type, IMethodRemover methodRemover, IFacetHolder holder) {
Attribute attribute = type.GetCustomAttributeByReflection<RegularExpressionAttribute>();
if (attribute == null) {
attribute = type.GetCustomAttributeByReflection<RegExAttribute>();
}
return FacetUtils.AddFacet(Create(attribute, holder));
}
public SecurityHideForSessionFacet(IIdentifier identifier,
SecurityFacetDecorator decorator,
IFacetHolder holder)
: base(holder) {
this.identifier = identifier;
this.decorator = decorator;
}
/// <summary>
/// Returns a <see cref="IValueFacet" /> implementation.
/// </summary>
private static IValueFacet Create(Type type, IFacetHolder holder) {
// create from annotation, if present
var annotation = type.GetCustomAttributeByReflection<ValueAttribute>();
if (annotation != null) {
if (annotation.SemanticsProviderClass != null || annotation.SemanticsProviderName.Length != 0) {
Type annotationType = annotation.SemanticsProviderClass;
if (annotationType == null && !string.IsNullOrEmpty(annotation.SemanticsProviderName)) {
annotationType = TypeUtils.GetType(annotation.SemanticsProviderName);
}
PropertyInfo method = annotationType.GetProperty("Parser");
Type propertyType = method.PropertyType.GetGenericArguments()[0];
if (!propertyType.IsAssignableFrom(type)) {
throw new ModelException(string.Format(Resources.NakedObjects.SemanticProviderMismatch, type, propertyType, holder.Identifier.ClassName));
}
}
var facet = TypeUtils.CreateGenericInstance<IValueFacet>(typeof (ValueFacetAnnotation<>),
new[] {type},
new object[] {type, holder});
if (facet.IsValid) {
return facet;
}
}
return null;
}
public ActionChoicesFacetViaMethod(MethodInfo choicesMethod, Type choicesType, IFacetHolder holder, bool isMultiple = false)
: base(holder) {
this.choicesMethod = choicesMethod;
this.choicesType = choicesType;
this.isMultiple = isMultiple;
parameterNamesAndTypes = choicesMethod.GetParameters().Select(p => new Tuple<string, INakedObjectSpecification>(p.Name.ToLower(), NakedObjectsContext.Reflector.LoadSpecification(p.ParameterType))).ToArray();
parameterNames = parameterNamesAndTypes.Select(pnt => pnt.Item1).ToArray();
}
public override bool ProcessParams(MethodInfo method, int paramNum, IFacetHolder holder) {
ParameterInfo parameter = method.GetParameters()[paramNum];
if (TypeUtils.IsString(parameter.ParameterType)) {
var attribute = parameter.GetCustomAttributeByReflection<MultiLineAttribute>();
return FacetUtils.AddFacet(Create(attribute, holder));
}
return false;
}
public NamedFacetDynamicWrapI18n(II18nManager manager, IFacetHolder holder, IIdentifier identifier, INamedFacet namedFacet, int index = -1)
: base(Type, holder) {
this.manager = manager;
this.identifier = identifier;
this.namedFacet = namedFacet;
this.index = index;
}
public override bool ProcessParams(MethodInfo method, int paramNum, IFacetHolder holder) {
ParameterInfo parameter = method.GetParameters()[paramNum];
Attribute attribute = parameter.GetCustomAttributeByReflection<DescriptionAttribute>();
if (attribute == null) {
attribute = parameter.GetCustomAttributeByReflection<DescribedAsAttribute>();
}
return FacetUtils.AddFacet(Create(attribute, holder));
}
public override bool Process(Type type, IMethodRemover methodRemover, IFacetHolder holder) {
return FacetUtils.AddFacets(
new IFacet[] {
new DescribedAsFacetNone(holder),
new ImmutableFacetNever(holder),
new TitleFacetNone(holder),
});
}
private static bool Process(MemberInfo member, IFacetHolder holder) {
var attribute = member.GetCustomAttribute<DisabledAttribute>();
IDisabledFacet disabledFacet = Create(attribute, holder);
if (disabledFacet != null) {
return FacetUtils.AddFacet(disabledFacet);
}
return false;
}
private static bool Process(Func<Attribute> getHidden, Func<Attribute> getScaffold, IFacetHolder holder) {
Attribute attribute = getHidden();
if (attribute != null) {
return FacetUtils.AddFacet(Create((HiddenAttribute) attribute, holder));
}
attribute = getScaffold();
return FacetUtils.AddFacet(Create((ScaffoldColumnAttribute) attribute, holder));
}
public static bool IsVisible(IFacetHolder facetHolder, InteractionContext ic) {
var buf = new InteractionBuffer();
IFacet[] facets = facetHolder.GetFacets(FacetFilters.IsA(typeof (IHidingInteractionAdvisor)));
foreach (IHidingInteractionAdvisor advisor in facets) {
buf.Append(advisor.Hides(ic));
}
return IsVisible(buf);
}
public void ProcessSystemType(Type type, IMethodRemover methodRemover, IFacetHolder holder) {
InitForType(type);
foreach (MethodInfo method in typeToMethods[type]) {
if (methodRemover != null && method != null) {
methodRemover.RemoveMethod(method);
}
}
}
private bool Process(MemberInfo member, Type methodReturnType, IFacetHolder holder) {
if (CollectionUtils.IsGenericEnumerable(methodReturnType) || CollectionUtils.IsCollection(methodReturnType)) {
var attribute = member.GetCustomAttribute<TableViewAttribute>();
return FacetUtils.AddFacet(Create(attribute, holder));
}
return false;
}
