private MappingValidationResult Validate(IRelationEndPointDefinition relationEndPointDefinition)
{
ArgumentUtility.CheckNotNull("relationEndPointDefinition", relationEndPointDefinition);
var endPointDefinitionAsVirtualRelationEndPointDefinition = relationEndPointDefinition as VirtualRelationEndPointDefinition;
if (endPointDefinitionAsVirtualRelationEndPointDefinition != null)
{
if (endPointDefinitionAsVirtualRelationEndPointDefinition.Cardinality == CardinalityType.One &&
!ReflectionUtility.IsDomainObject(endPointDefinitionAsVirtualRelationEndPointDefinition.PropertyInfo.PropertyType))
{
return(MappingValidationResult.CreateInvalidResultForProperty(
endPointDefinitionAsVirtualRelationEndPointDefinition.PropertyInfo,
"The property type of a virtual end point of a one-to-one relation must be assignable to '{0}'.",
typeof(DomainObject).Name));
}
if (endPointDefinitionAsVirtualRelationEndPointDefinition.Cardinality == CardinalityType.Many &&
!ReflectionUtility.IsObjectList(endPointDefinitionAsVirtualRelationEndPointDefinition.PropertyInfo.PropertyType))
{
return(MappingValidationResult.CreateInvalidResultForProperty(
endPointDefinitionAsVirtualRelationEndPointDefinition.PropertyInfo,
"The property type of a virtual end point of a one-to-many relation must be assignable to '{0}'.",
typeof(ObjectList <>).Name));
}
}
return(MappingValidationResult.CreateValidResult());
}
private MappingValidationResult Validate(IRelationEndPointDefinition relationEndPointDefinition)
{
ArgumentUtility.CheckNotNull("relationEndPointDefinition", relationEndPointDefinition);
if (relationEndPointDefinition.IsAnonymous)
{
return(MappingValidationResult.CreateValidResult());
}
var propertyInfo = relationEndPointDefinition.PropertyInfo;
if (propertyInfo == null)
{
return(MappingValidationResult.CreateValidResult());
}
var relationAttribute = propertyInfo.GetCustomAttribute <DBBidirectionalRelationAttribute> (true);
if (relationAttribute != null && relationAttribute.ContainsForeignKey && ReflectionUtility.IsObjectList(propertyInfo.PropertyType))
{
return(MappingValidationResult.CreateInvalidResultForProperty(
propertyInfo,
"Only relation end points with a property type of '{0}' can contain the foreign key.",
typeof(DomainObject).Name));
}
return(MappingValidationResult.CreateValidResult());
}
public IEnumerable <MappingValidationResult> Validate(ClassDefinition classDefinition)
{
ArgumentUtility.CheckNotNull("classDefinition", classDefinition);
if (classDefinition.BaseClass == null) //if class definition is inheritance root class
{
var allDistinctTableNames = new HashSet <string> ();
foreach (var tableName in FindAllTableDefinitions(classDefinition).Select(td => td.TableName.EntityName))
{
if (allDistinctTableNames.Contains(tableName))
{
yield return(MappingValidationResult.CreateInvalidResultForType(
classDefinition.ClassType,
"At least two classes in different inheritance branches derived from abstract class '{0}'"
+ " specify the same entity name '{1}', which is not allowed.",
classDefinition.ClassType.Name,
tableName));
}
else
{
yield return(MappingValidationResult.CreateValidResult());
}
allDistinctTableNames.Add(tableName);
}
}
}
public MappingValidationResult Validate(RelationDefinition relationDefinition)
{
ArgumentUtility.CheckNotNull("relationDefinition", relationDefinition);
foreach (var endPointDefinition in relationDefinition.EndPointDefinitions)
{
if (endPointDefinition is PropertyNotFoundRelationEndPointDefinition)
{
return(MappingValidationResult.CreateInvalidResultForType(
endPointDefinition.ClassDefinition.ClassType,
"Property '{0}' on class '{1}' could not be found.",
endPointDefinition.PropertyName,
endPointDefinition.ClassDefinition.ClassType.Name));
}
else if (endPointDefinition is TypeNotObjectIDRelationEndPointDefinition)
{
return(MappingValidationResult.CreateInvalidResultForType(
endPointDefinition.ClassDefinition.ClassType,
"Relation property '{0}' on class '{1}' is of type '{2}', but non-virtual relation properties must be of type '{3}'.",
endPointDefinition.PropertyName,
endPointDefinition.ClassDefinition.ClassType.Name,
endPointDefinition.PropertyInfo.PropertyType.Name,
typeof(ObjectID).Name));
}
}
return(MappingValidationResult.CreateValidResult());
}
public override MappingValidationResult Validate(RelationDefinition relationDefinition)
{
ArgumentUtility.CheckNotNull("relationDefinition", relationDefinition);
var endPointDefinition1 = relationDefinition.EndPointDefinitions[0];
var endPointDefinition2 = relationDefinition.EndPointDefinitions[1];
if (IsInvalidEndPointDefinition(endPointDefinition1) || IsInvalidEndPointDefinition(endPointDefinition2))
{
return(MappingValidationResult.CreateValidResult());
}
if (endPointDefinition1.IsAnonymous && endPointDefinition2.IsAnonymous)
{
return(MappingValidationResult.CreateInvalidResult("Relation '{0}' cannot have two anonymous end points.", relationDefinition.ID));
}
if (endPointDefinition1.IsVirtual && endPointDefinition2.IsVirtual)
{
var endPointDefinition1AsVirtualRelationEndPointDefinition = endPointDefinition1 as VirtualRelationEndPointDefinition;
var endPointDefinition2AsVirtualRelationEndPointDefinition = endPointDefinition2 as VirtualRelationEndPointDefinition;
if (endPointDefinition1AsVirtualRelationEndPointDefinition != null && endPointDefinition2AsVirtualRelationEndPointDefinition != null)
{
return(MappingValidationResult.CreateInvalidResultForRelation(
relationDefinition.ID,
endPointDefinition1.PropertyInfo,
"The relation between property '{0}', declared on type '{1}', and property '{2}' declared on type '{3}', contains two virtual end points. "
+ "One of the two properties must set 'ContainsForeignKey' to 'true' on the '{4}'.",
endPointDefinition1.PropertyInfo.Name,
endPointDefinition1.ClassDefinition.ClassType.Name,
endPointDefinition2.PropertyInfo.Name,
endPointDefinition2.ClassDefinition.ClassType.Name,
typeof(DBBidirectionalRelationAttribute).Name));
}
else
{
return(MappingValidationResult.CreateInvalidResultForRelation(
relationDefinition.ID,
endPointDefinition1.PropertyInfo,
"Relation '{0}' cannot have two virtual end points.",
relationDefinition.ID));
}
}
if (!endPointDefinition1.IsVirtual && !endPointDefinition2.IsVirtual)
{
return(MappingValidationResult.CreateInvalidResultForRelation(
relationDefinition.ID,
endPointDefinition1.PropertyInfo,
"The relation between property '{0}', declared on type '{1}', and property '{2}' declared on type '{3}', contains two non-virtual end points. "
+ "One of the two properties must set 'ContainsForeignKey' to 'false' on the '{4}'.",
endPointDefinition1.PropertyInfo.Name,
endPointDefinition1.ClassDefinition.ClassType.Name,
endPointDefinition2.PropertyInfo.Name,
endPointDefinition2.ClassDefinition.ClassType.Name,
typeof(DBBidirectionalRelationAttribute).Name));
}
return(MappingValidationResult.CreateValidResult());
}
private IEnumerable <MappingValidationResult> ValidatePropertyGroup(string columnName, IList <PropertyDefinition> propertyDefinitions)
{
if (propertyDefinitions.Count > 1)
{
var referenceProperty = propertyDefinitions[0];
var differentProperties = propertyDefinitions.Where(pd => !pd.PropertyInfo.Equals(referenceProperty.PropertyInfo));
if (differentProperties.Any())
{
foreach (var differentProperty in differentProperties)
{
yield return(MappingValidationResult.CreateInvalidResultForProperty(
referenceProperty.PropertyInfo,
"Property '{0}' of class '{1}' must not define storage specific name '{2}',"
+ " because class '{3}' in same inheritance hierarchy already defines property '{4}' with the same storage specific name.",
differentProperty.PropertyInfo.Name,
differentProperty.ClassDefinition.ClassType.Name,
columnName,
referenceProperty.ClassDefinition.ClassType.Name,
referenceProperty.PropertyInfo.Name));
}
}
else
{
yield return(MappingValidationResult.CreateValidResult());
}
}
}
private MappingValidationResult Validate(IRelationEndPointDefinition relationEndPointDefinition)
{
ArgumentUtility.CheckNotNull("relationEndPointDefinition", relationEndPointDefinition);
if (!relationEndPointDefinition.IsAnonymous && !(relationEndPointDefinition is InvalidRelationEndPointDefinitionBase))
{
var relationAttribute = relationEndPointDefinition.PropertyInfo.GetCustomAttribute <BidirectionalRelationAttribute> (true);
var oppositeEndPointDefinition = relationEndPointDefinition.GetOppositeEndPointDefinition();
if (oppositeEndPointDefinition != null &&
!oppositeEndPointDefinition.IsAnonymous &&
!(oppositeEndPointDefinition is InvalidRelationEndPointDefinitionBase) &&
relationAttribute != null)
{
var oppositePropertyInfo = oppositeEndPointDefinition.PropertyInfo;
var classDefinition = relationEndPointDefinition.ClassDefinition;
var oppositeDomainObjectType = ReflectionUtility.GetRelatedObjectTypeFromRelationProperty(oppositePropertyInfo);
var declaringDomainObjectTypeForProperty =
ReflectionUtility.GetDeclaringDomainObjectTypeForProperty(relationEndPointDefinition.PropertyInfo, classDefinition);
bool isPropertyDeclaredByThisClassDefinition = declaringDomainObjectTypeForProperty == classDefinition.ClassType;
if (isPropertyDeclaredByThisClassDefinition)
{
// Case where property is declared on this ClassDefinition => it is declared below/on the inheritance root
// In this case, the opposite property's return type must exactly match this ClassDefinition's type.
if (classDefinition.ClassType != oppositeDomainObjectType)
{
return(MappingValidationResult.CreateInvalidResultForProperty(
relationEndPointDefinition.PropertyInfo,
"The type '{0}' does not match the type of the opposite relation propery '{1}' declared on type '{2}'.",
declaringDomainObjectTypeForProperty.Name,
relationAttribute.OppositeProperty,
oppositePropertyInfo.DeclaringType.Name));
}
}
else
{
// Case where property is not declared on this ClassDefinition => it must be declared above the inheritance root
// In this case, the opposite property's return type must be assignable to the type declaring the property. This enables the following
// scenario:
// - ClassAboveInheritanceRoot has a relation property P1 to RelationTarget
// - RelationTarget has a relation property P2 back to the InheritanceRoot derived from ClassAboveInheritanceRoot
// In that case, when reflecting P1, DeclaringDomainObjectTypeForProperty will be ClassAboveInheritanceRoot, oppositeDomainObjectType will be
// InheritanceRoot. ClassAboveInheritanceRoot is assignable from InheritanceRoo, so the check passes.
// This is the only case where the two sides of a bidirectional relation can point to subclasses of each other.
// (The scenario this was actually needed for is to allow for generic base classes above the inheritance root defining relation properties.)
if (!declaringDomainObjectTypeForProperty.IsAssignableFrom(oppositeDomainObjectType))
{
return(MappingValidationResult.CreateInvalidResultForProperty(
relationEndPointDefinition.PropertyInfo,
"The type '{0}' cannot be assigned to the type of the opposite relation propery '{1}' declared on type '{2}'.",
declaringDomainObjectTypeForProperty.Name,
relationAttribute.OppositeProperty,
oppositePropertyInfo.DeclaringType.Name));
}
}
}
}
return(MappingValidationResult.CreateValidResult());
}
public void SetUp()
{
_relationDefinition1 = CreateRelationDefinition("RelationDefinition1");
_relationDefinition2 = CreateRelationDefinition("RelationDefinition2");
_relationDefinition3 = CreateRelationDefinition("RelationDefinition3");
_validationRuleMock = MockRepository.GenerateStrictMock <IRelationDefinitionValidatorRule> ();
_fakeValidMappingValidationResult = MappingValidationResult.CreateValidResult();
_fakeInvalidMappingValidationResult = MappingValidationResult.CreateInvalidResult("Test");
}
private MappingValidationResult Validate(Type type)
{
ArgumentUtility.CheckNotNull("type", type);
if (type.IsGenericType)// && !ReflectionUtility.IsDomainObjectBase(type))
{
return(MappingValidationResult.CreateInvalidResultForType(type, "Generic domain objects are not supported."));
}
return(MappingValidationResult.CreateValidResult());
}
public void SetUp()
{
_classDefinition1 = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(DerivedValidationDomainObjectClass));
_classDefinition2 = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(DerivedValidationDomainObjectClass));
_classDefinition3 = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(DerivedValidationDomainObjectClass));
_validationRuleMock1 = MockRepository.GenerateStrictMock <IClassDefinitionValidationRule> ();
_validationRuleMock2 = MockRepository.GenerateStrictMock <IClassDefinitionValidationRule> ();
_validationRuleMock3 = MockRepository.GenerateStrictMock <IClassDefinitionValidationRule> ();
_fakeValidMappingValidationResult = MappingValidationResult.CreateValidResult();
_fakeInvalidMappingValidationResult = MappingValidationResult.CreateInvalidResult("Test");
}
// //TODO 3467:
// // StringPropertyAttribute
// public class StringxxxValidationRule : xxxValidationRule<StringPropertyAttribute>
// {
// override string GetMEssage()
// }
// protected MappingValidationResultValidate (PropertyInfo pi)
//{
// var attr = AttributeUtility.GetCustomAttributes<TAttribute> (pi, true))
// if (attr != null && !IsPropertyTypeSupported (pi))
// {
// return new MappingValidationResult (false, GetMessage (pi));
// }
// return new MappingValidationResult (true);
// }
private MappingValidationResult Validate(IPropertyInformation propertyInfo)
{
ArgumentUtility.CheckNotNull("propertyInfo", propertyInfo);
foreach (var attribute in propertyInfo.GetCustomAttributes <Attribute> (true))
{
var constraint = GetAttributeConstraint(attribute.GetType());
if (constraint != null && !Array.Exists(constraint.PropertyTypes, t => IsPropertyTypeSupported(propertyInfo, t)))
{
return(MappingValidationResult.CreateInvalidResultForProperty(propertyInfo, constraint.Message));
}
}
return(MappingValidationResult.CreateValidResult());
}
public MappingValidationResult Validate(ClassDefinition classDefinition)
{
if (classDefinition.BaseClass != null && !classDefinition.ClassType.IsSubclassOf(classDefinition.BaseClass.ClassType))
{
return(MappingValidationResult.CreateInvalidResultForType(
classDefinition.BaseClass.ClassType,
"Type '{0}' of class '{1}' is not derived from type '{2}' of base class '{3}'.",
classDefinition.ClassType.AssemblyQualifiedName,
classDefinition.ID,
classDefinition.BaseClass.ClassType.AssemblyQualifiedName,
classDefinition.BaseClass.ID));
}
return(MappingValidationResult.CreateValidResult());
}
public MappingValidationResult Validate(RelationDefinition relationDefinition)
{
ArgumentUtility.CheckNotNull("relationDefinition", relationDefinition);
foreach (var endPointDefinition in relationDefinition.EndPointDefinitions)
{
var validationResult = Validate(endPointDefinition);
if (!validationResult.IsValid)
{
return(validationResult);
}
}
return(MappingValidationResult.CreateValidResult());
}
public MappingValidationResult Validate(ClassDefinition classDefinition)
{
ArgumentUtility.CheckNotNull("classDefinition", classDefinition);
if (!ReflectionUtility.IsDomainObject(classDefinition.ClassType))
{
return(MappingValidationResult.CreateInvalidResultForType(
classDefinition.ClassType,
"Type '{0}' of class '{1}' is not assignable to '{2}'.",
classDefinition.ClassType.Name,
classDefinition.ID,
typeof(DomainObject).Name));
}
return(MappingValidationResult.CreateValidResult());
}
public MappingValidationResult Validate(ClassDefinition classDefinition)
{
if (classDefinition.BaseClass != null)
{
if (classDefinition.StorageGroupType != classDefinition.BaseClass.StorageGroupType)
{
var message = "Class '{0}' must have the same storage group type as its base class '{1}'.";
return(MappingValidationResult.CreateInvalidResultForType(
classDefinition.ClassType,
message,
classDefinition.ClassType.Name,
classDefinition.BaseClass.ClassType.Name));
}
}
return(MappingValidationResult.CreateValidResult());
}
public IEnumerable <MappingValidationResult> Validate(ClassDefinition classDefinition)
{
ArgumentUtility.CheckNotNull("classDefinition", classDefinition);
if (classDefinition.IsClassTypeResolved && !IsAssociatedWithTable(classDefinition) && !classDefinition.IsAbstract)
{
yield return(MappingValidationResult.CreateInvalidResultForType(
classDefinition.ClassType,
"Neither class '{0}' nor its base classes are mapped to a table. "
+ "Make class '{0}' abstract or define a table for it or one of its base classes.",
classDefinition.ClassType.Name));
}
else
{
yield return(MappingValidationResult.CreateValidResult());
}
}
private MappingValidationResult Validate(IPropertyInformation propertyInfo)
{
ArgumentUtility.CheckNotNull("propertyInfo", propertyInfo);
var storageClassAttribute = propertyInfo.GetCustomAttribute <StorageClassAttribute> (true);
if (storageClassAttribute != null && storageClassAttribute.StorageClass != StorageClass.Persistent &&
storageClassAttribute.StorageClass != StorageClass.Transaction)
{
return(MappingValidationResult.CreateInvalidResultForProperty(
propertyInfo,
"Only StorageClass.Persistent and StorageClass.Transaction are supported for property '{0}' of class '{1}'.",
propertyInfo.Name,
propertyInfo.DeclaringType.Name));
}
return(MappingValidationResult.CreateValidResult());
}
private MappingValidationResult Validate(IRelationEndPointDefinition relationEndPointDefinition)
{
var relationEndPointDefinitionAsVirtualRelationEndPointDefinition = relationEndPointDefinition as VirtualRelationEndPointDefinition;
if (relationEndPointDefinitionAsVirtualRelationEndPointDefinition != null)
{
try
{
relationEndPointDefinitionAsVirtualRelationEndPointDefinition.GetSortExpression();
}
catch (MappingException ex)
{
return(MappingValidationResult.CreateInvalidResult(ex.Message));
}
}
return(MappingValidationResult.CreateValidResult());
}
private MappingValidationResult Validate(PropertyDefinition propertyDefinition)
{
var nativePropertyType = propertyDefinition.PropertyType;
if (!PropertyValue.IsTypeSupported(nativePropertyType))
{
return(MappingValidationResult.CreateInvalidResultForProperty(
propertyDefinition.PropertyInfo,
"The property type '{0}' is not supported. If you meant to declare a relation, '{0}' must be derived from '{1}'. "
+ "For non-mapped properties, use the '{2}'.",
nativePropertyType.Name,
typeof(DomainObject).Name,
typeof(StorageClassNoneAttribute).Name));
}
return(MappingValidationResult.CreateValidResult());
}
private MappingValidationResult Validate(IPropertyInformation propertyInfo)
{
ArgumentUtility.CheckNotNull("propertyInfo", propertyInfo);
if (!propertyInfo.IsOriginalDeclaration())
{
var mappingAttributes = propertyInfo.GetCustomAttributes <IMappingAttribute> (false);
if (mappingAttributes.Any())
{
return(MappingValidationResult.CreateInvalidResultForProperty(
propertyInfo,
"The '{0}' is a mapping attribute and may only be applied at the property's base definition.",
mappingAttributes[0].GetType().Name));
}
}
return(MappingValidationResult.CreateValidResult());
}
private MappingValidationResult Validate(IRelationEndPointDefinition relationEndPointDefinition)
{
ArgumentUtility.CheckNotNull("relationEndPointDefinition", relationEndPointDefinition);
var relationEndPointDefinitionAsVirtualRelationEndPointDefintion = relationEndPointDefinition as VirtualRelationEndPointDefinition;
if (relationEndPointDefinitionAsVirtualRelationEndPointDefintion != null &&
relationEndPointDefinitionAsVirtualRelationEndPointDefintion.Cardinality == CardinalityType.One &&
relationEndPointDefinitionAsVirtualRelationEndPointDefintion.SortExpressionText != null)
{
return(MappingValidationResult.CreateInvalidResultForProperty(
relationEndPointDefinitionAsVirtualRelationEndPointDefintion.PropertyInfo,
"Property '{0}' of class '{1}' must not specify a SortExpression, because cardinality is equal to 'one'.",
relationEndPointDefinitionAsVirtualRelationEndPointDefintion.PropertyInfo.Name,
relationEndPointDefinitionAsVirtualRelationEndPointDefintion.ClassDefinition.ClassType.Name));
}
return(MappingValidationResult.CreateValidResult());
}
private MappingValidationResult Validate(PropertyDefinition propertyDefinition)
{
ArgumentUtility.CheckNotNull("propertyDefinition", propertyDefinition);
if (propertyDefinition.StorageClass == StorageClass.Persistent)
{
var unsupportedStoragePropertyDefinition = propertyDefinition.StoragePropertyDefinition as UnsupportedStoragePropertyDefinition;
if (unsupportedStoragePropertyDefinition != null)
{
return(MappingValidationResult.CreateInvalidResultForProperty(
propertyDefinition.PropertyInfo,
"The property type '{0}' is not supported by this storage provider. {1}",
propertyDefinition.PropertyType.Name,
unsupportedStoragePropertyDefinition.Message));
}
}
return(MappingValidationResult.CreateValidResult());
}
private SortExpressionDefinition ParseSortExpression(string sortExpressionText)
{
if (sortExpressionText == null)
{
return(null);
}
try
{
var parser = new SortExpressionParser(this.GetOppositeEndPointDefinition().ClassDefinition);
return(parser.Parse(sortExpressionText));
}
catch (MappingException ex)
{
var result = MappingValidationResult.CreateInvalidResultForProperty(PropertyInfo, ex.Message);
throw new MappingException(result.Message, ex);
}
}
private MappingValidationResult Validate(Type type)
{
ArgumentUtility.CheckNotNull("type", type);
if (!type.IsAbstract || (type.IsAbstract && Attribute.IsDefined(type, typeof(InstantiableAttribute), false)))
{
BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.ExactBinding;
ConstructorInfo legacyLoadConstructor = type.GetConstructor(flags, null, new[] { typeof(DataContainer) }, null);
if (legacyLoadConstructor != null)
{
return(MappingValidationResult.CreateInvalidResultForType(
type,
"The domain object type has a legacy infrastructure constructor for loading (a nonpublic constructor taking a single DataContainer "
+ "argument). The reflection-based mapping does not use this constructor any longer and requires it to be removed."));
}
}
return(MappingValidationResult.CreateValidResult());
}
public MappingValidationResult Validate(RelationDefinition relationDefinition)
{
ArgumentUtility.CheckNotNull("relationDefinition", relationDefinition);
foreach (var endPointDefinition in relationDefinition.EndPointDefinitions)
{
var classDefinitionAsTypeNotFoundClassDefinition = endPointDefinition.ClassDefinition as ClassDefinitionForUnresolvedRelationPropertyType;
if (classDefinitionAsTypeNotFoundClassDefinition != null)
{
return(MappingValidationResult.CreateInvalidResultForProperty(
classDefinitionAsTypeNotFoundClassDefinition.RelationProperty,
"The relation property '{0}' has return type '{1}', which is not a part of the mapping. Relation properties must not point to "
+ "classes above the inheritance root.",
classDefinitionAsTypeNotFoundClassDefinition.RelationProperty.Name,
classDefinitionAsTypeNotFoundClassDefinition.RelationProperty.PropertyType.Name));
}
}
return(MappingValidationResult.CreateValidResult());
}
private MappingValidationResult Validate(IRelationEndPointDefinition relationEndPointDefinition)
{
ArgumentUtility.CheckNotNull("relationEndPointDefinition", relationEndPointDefinition);
var relationEndPointAsReflectionBasedVirtualRelationEndPoint = relationEndPointDefinition as VirtualRelationEndPointDefinition;
if (relationEndPointAsReflectionBasedVirtualRelationEndPoint != null)
{
var propertyInfo = relationEndPointAsReflectionBasedVirtualRelationEndPoint.PropertyInfo;
var hasRelationAttribute = propertyInfo.IsDefined <BidirectionalRelationAttribute> (true);
if (!hasRelationAttribute && !ReflectionUtility.IsDomainObject(propertyInfo.PropertyType))
{
return(MappingValidationResult.CreateInvalidResultForProperty(
relationEndPointAsReflectionBasedVirtualRelationEndPoint.PropertyInfo,
"The property type of an uni-directional relation property must be assignable to '{0}'.",
typeof(DomainObject).Name));
}
}
return(MappingValidationResult.CreateValidResult());
}
private MappingValidationResult Validate(IRelationEndPointDefinition relationEndPointDefinition)
{
ArgumentUtility.CheckNotNull("relationEndPointDefinition", relationEndPointDefinition);
var endPointDefinitionAsVirtualRelationEndPointDefinition = relationEndPointDefinition as VirtualRelationEndPointDefinition;
if (endPointDefinitionAsVirtualRelationEndPointDefinition != null &&
endPointDefinitionAsVirtualRelationEndPointDefinition.PropertyInfo.PropertyType != null &&
!ReflectionUtility.IsRelationType(endPointDefinitionAsVirtualRelationEndPointDefinition.PropertyInfo.PropertyType))
{
return(MappingValidationResult.CreateInvalidResultForProperty(
endPointDefinitionAsVirtualRelationEndPointDefinition.PropertyInfo,
"Virtual property '{0}' of class '{1}' is of type '{2}', but must be assignable to '{3}' or '{4}'.",
endPointDefinitionAsVirtualRelationEndPointDefinition.PropertyInfo.Name,
endPointDefinitionAsVirtualRelationEndPointDefinition.ClassDefinition.ClassType.Name,
endPointDefinitionAsVirtualRelationEndPointDefinition.PropertyInfo.PropertyType.Name,
typeof(DomainObject).Name,
typeof(ObjectList <>).Name));
}
return(MappingValidationResult.CreateValidResult());
}
private MappingValidationResult Validate(Type type)
{
ArgumentUtility.CheckNotNull("type", type);
if (AttributeUtility.IsDefined(type, typeof(StorageGroupAttribute), false) &&
AttributeUtility.IsDefined(type.BaseType, typeof(StorageGroupAttribute), true))
{
Type baseType = type.BaseType;
while (!AttributeUtility.IsDefined <StorageGroupAttribute> (baseType, false)) //get base type which has the attribute applied
{
baseType = baseType.BaseType;
}
return(MappingValidationResult.CreateInvalidResultForType(
type,
"The domain object type cannot redefine the '{0}' already defined on base type '{1}'.",
typeof(StorageGroupAttribute).Name,
baseType.Name));
}
return(MappingValidationResult.CreateValidResult());
}
private MappingValidationResult Validate(IRelationEndPointDefinition relationEndPointDefinition)
{
ArgumentUtility.CheckNotNull("relationEndPointDefinition", relationEndPointDefinition);
if (!relationEndPointDefinition.IsAnonymous)
{
var relationAttribute = relationEndPointDefinition.PropertyInfo.GetCustomAttribute <BidirectionalRelationAttribute> (true);
if (relationAttribute != null)
{
var oppositeEndPointDefinition = relationEndPointDefinition.GetOppositeEndPointDefinition();
if (!oppositeEndPointDefinition.IsAnonymous)
{
var oppositeProperty = oppositeEndPointDefinition.PropertyInfo;
var oppositeRelationAttribute = oppositeProperty.GetCustomAttribute <BidirectionalRelationAttribute> (true);
if (oppositeRelationAttribute == null)
{
return(MappingValidationResult.CreateInvalidResultForProperty(
relationEndPointDefinition.PropertyInfo,
"Opposite relation property '{0}' declared on type '{1}' does not define a matching '{2}'.",
relationAttribute.OppositeProperty,
oppositeProperty.DeclaringType.Name,
relationAttribute.GetType().Name));
}
if (!relationEndPointDefinition.PropertyInfo.Name.Equals(oppositeRelationAttribute.OppositeProperty, StringComparison.Ordinal))
{
return(MappingValidationResult.CreateInvalidResultForProperty(
relationEndPointDefinition.PropertyInfo,
"Opposite relation property '{0}' declared on type '{1}' defines a '{2}' whose opposite property does not match.",
relationAttribute.OppositeProperty,
oppositeProperty.DeclaringType.Name,
relationAttribute.GetType().Name));
}
}
}
}
return(MappingValidationResult.CreateValidResult());
}
public IEnumerable <MappingValidationResult> Validate(ClassDefinition classDefinition)
{
ArgumentUtility.CheckNotNull("classDefinition", classDefinition);
if (classDefinition.BaseClass != null && classDefinition.StorageEntityDefinition is TableDefinition)
{
var baseClasses = classDefinition.BaseClass.CreateSequence(cd => cd.BaseClass);
foreach (ClassDefinition baseClass in baseClasses)
{
if (baseClass.StorageEntityDefinition is TableDefinition)
{
yield return(MappingValidationResult.CreateInvalidResultForType(
classDefinition.ClassType,
"Class '{0}' must not define a table when its base class '{1}' also defines one.",
classDefinition.ClassType.Name,
baseClass.ClassType.Name));
}
}
}
else
{
yield return(MappingValidationResult.CreateValidResult());
}
}
