/// <summary>
/// Initializes a new instance of the <see cref="CompositeKeyModel"/> class.
/// </summary>
/// <param name="propInfo">The prop info.</param>
/// <param name="pkAtt">The pk att.</param>
public CompositeKeyModel(PropertyInfo propInfo, CompositeKeyAttribute pkAtt)
{
if (propInfo == null) throw new ArgumentNullException("propInfo");
if (pkAtt == null) throw new ArgumentNullException("pkAtt");
this.propInfo = propInfo;
this.pkAtt = pkAtt;
}
/// <summary>
/// Initializes a new instance of the <see cref="CompositeKeyModel"/> class.
/// </summary>
/// <param name="propInfo">The prop info.</param>
/// <param name="pkAtt">The pk att.</param>
public CompositeKeyModel(PropertyInfo propInfo, CompositeKeyAttribute pkAtt)
{
if (propInfo == null)
{
throw new ArgumentNullException("propInfo");
}
if (pkAtt == null)
{
throw new ArgumentNullException("pkAtt");
}
this.propInfo = propInfo;
this.pkAtt = pkAtt;
}
private void DoNaturalKey(PrimaryKeyModel model)
{
CompositeKeyAttribute att = model.Property.PropertyType.GetCustomAttributes(typeof(CompositeKeyAttribute), false)[0] as CompositeKeyAttribute;
string unsavedVal = att.UnsavedValue;
if (unsavedVal == null)
{
unsavedVal = "none";
}
AppendF("<composite-id {0} {1} {2} {3}>",
MakeAtt("name", model.Property.Name),
MakeClassAtt(model.Property.PropertyType),
WriteIfNonNull("unsaved-value", unsavedVal),
MakeAtt("access", att.AccessString));
Ident();
PropertyInfo[] keyProps = model.Property.PropertyType.GetProperties();
foreach (PropertyInfo keyProp in keyProps)
{
KeyPropertyAttribute keyPropAttr = keyProp.GetCustomAttributes(typeof(KeyPropertyAttribute), false)[0] as KeyPropertyAttribute;
if (keyPropAttr.Column == null)
{
keyPropAttr.Column = keyProp.Name;
}
AppendF("<key-property {0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} />",
MakeAtt("name", keyProp.Name),
MakeAtt("access", keyPropAttr.AccessString),
MakeAtt("column", keyPropAttr.Column),
MakeTypeAtt(keyProp.PropertyType, keyPropAttr.ColumnType),
WriteIfNotZero("length", keyPropAttr.Length),
WriteIfNonNull("unsaved-value", keyPropAttr.UnsavedValue),
WriteIfTrue("not-null", keyPropAttr.NotNull),
WriteIfTrue("unique", keyPropAttr.Unique),
WriteIfFalse("insert", keyPropAttr.Insert),
WriteIfFalse("update", keyPropAttr.Update),
WriteIfNonNull("formula", keyPropAttr.Formula));
}
Dedent();
AppendF("</composite-id>");
}
public void CanGenerateCompositeKey()
{
string expectedClassName = "ClassWithCompositeKey";
Type type = Assembly.GetExecutingAssembly().GetType("Debugging.Tests." + expectedClassName);
PropertyInfo property = type.GetProperty(expectedClassName + "CompositeKey");
object[] propertyAttributes = property.GetCustomAttributes(typeof(CompositeKeyAttribute), false);
Assert.IsTrue(propertyAttributes.Length == 1, "Did not generate CompositeKeyAttribute.");
CompositeKeyAttribute attribute = propertyAttributes[0] as CompositeKeyAttribute;
Assert.IsNotNull(attribute, "Did not generate CompositeKeyAttribute.");
Assert.IsTrue(property.GetGetMethod().ReturnType.Name == expectedClassName + "CompositeKey");
Type ckType =
Assembly.GetExecutingAssembly().GetType("Debugging.Tests." + expectedClassName + "CompositeKey");
Assert.IsNotNull(ckType, "Did not generate Helper class for composite key.");
PropertyInfo keyProperty1 = ckType.GetProperty("Key1");
object[] keyAttributes = keyProperty1.GetCustomAttributes(typeof(KeyPropertyAttribute), false);
Assert.IsTrue(keyAttributes.Length == 1, "Did not generate KeyPropertyAttribute.");
KeyPropertyAttribute keyAttribute = keyAttributes[0] as KeyPropertyAttribute;
Assert.IsNotNull(keyAttribute, "Did not generate KeyPropertyAttribute.");
ClassWithCompositeKeyCompositeKey ck = new ClassWithCompositeKeyCompositeKey();
ck.Key1 = 1;
ck.Key2 = 2;
Assert.AreEqual(ck.ToString(), "1:2");
Assert.IsFalse(ck.Equals(null));
Assert.IsFalse(ck.Equals(new object()));
Assert.IsFalse(ck.Equals(new ClassWithCompositeKeyCompositeKey()));
ClassWithCompositeKeyCompositeKey ck2 = new ClassWithCompositeKeyCompositeKey();
ck2.Key1 = 1;
ck2.Key2 = 2;
Assert.IsTrue(ck.Equals(ck2));
}
private void ProcessProperties(Type type, ActiveRecordModel model)
{
// Check persistent properties of the base class as well
if (ShouldCheckBase(type))
{
ProcessProperties(type.BaseType, model);
}
PropertyInfo[] props = type.GetProperties(DefaultBindingFlags);
foreach (PropertyInfo prop in props)
{
bool isArProperty = false;
AnyModel anyModel;
HasManyToAnyModel hasManyToAnyModel;
if (extension != null)
{
extension.ProcessProperty(prop, model);
}
object[] valAtts = prop.GetCustomAttributes(typeof(AbstractValidationAttribute), true);
foreach (AbstractValidationAttribute valAtt in valAtts)
{
IValidator validator = valAtt.Build();
validator.Initialize(validatorRegistry, prop);
model.Validators.Add(validator);
}
foreach (object attribute in prop.GetCustomAttributes(false))
{
if (attribute is PrimaryKeyAttribute)
{
PrimaryKeyAttribute propAtt = attribute as PrimaryKeyAttribute;
isArProperty = true;
// Joined Subclasses must not have PrimaryKey
if (HasJoinedBase(type))
{
throw new ActiveRecordException("You can't specify a PrimaryKeyAttribute in a joined subclass. " +
"Check type " + model.Type.FullName);
}
if (prop.PropertyType.IsDefined(typeof(CompositeKeyAttribute), true))
{
object[] att = prop.PropertyType.GetCustomAttributes(typeof(CompositeKeyAttribute), true);
CompositeKeyAttribute cAtt = att[0] as CompositeKeyAttribute;
model.CompositeKey = new CompositeKeyModel(prop, cAtt);
}
else
{
if (!propAtt.IsOverride && model.PrimaryKey != null)
{
throw new ActiveRecordException("You can't specify more than one PrimaryKeyAttribute in a " +
"class. Check type " + model.Type.FullName);
}
model.PrimaryKey = new PrimaryKeyModel(prop, propAtt);
}
}
else if (attribute is CompositeKeyAttribute)
{
CompositeKeyAttribute propAtt = attribute as CompositeKeyAttribute;
isArProperty = true;
model.CompositeKey = new CompositeKeyModel(prop, propAtt);
}
else if (attribute is AnyAttribute)
{
AnyAttribute anyAtt = attribute as AnyAttribute;
isArProperty = true;
anyModel = new AnyModel(prop, anyAtt);
model.Anys.Add(anyModel);
CollectMetaValues(anyModel.MetaValues, prop);
}
else if (attribute is PropertyAttribute)
{
PropertyAttribute propAtt = attribute as PropertyAttribute;
isArProperty = true;
// If this property overrides a base class property remove the old one
if (propAtt.IsOverride)
{
for (int index = 0; index < model.Properties.Count; ++index)
{
PropertyModel oldModel = (PropertyModel)model.Properties[index];
if (oldModel.Property.Name == prop.Name)
{
model.Properties.RemoveAt(index);
break;
}
}
}
PropertyModel propModel = new PropertyModel(prop, propAtt);
model.Properties.Add(propModel);
model.PropertyDictionary[prop.Name] = propModel;
}
else if (attribute is NestedAttribute)
{
NestedAttribute propAtt = attribute as NestedAttribute;
isArProperty = true;
ActiveRecordModel nestedModel = new ActiveRecordModel(prop.PropertyType);
nestedModel.IsNestedType = true;
Type nestedType = propAtt.MapType ?? prop.PropertyType;
nestedModel.IsNestedCompositeType = model.IsNestedCompositeType;
ProcessProperties(nestedType, nestedModel);
ProcessFields(nestedType, nestedModel);
NestedModel nested = new NestedModel(prop, propAtt, nestedModel);
nestedModel.ParentNested = nested;
model.Components.Add(nested);
}
else if (attribute is NestedParentReferenceAttribute)
{
NestedParentReferenceAttribute nestedParentAtt = attribute as NestedParentReferenceAttribute;
isArProperty = true;
model.ComponentParent.Add(new NestedParentReferenceModel(prop, nestedParentAtt));
}
else if (attribute is JoinedKeyAttribute)
{
JoinedKeyAttribute propAtt = attribute as JoinedKeyAttribute;
isArProperty = true;
if (model.Key != null)
{
throw new ActiveRecordException("You can't specify more than one JoinedKeyAttribute. " +
"Check type " + model.Type.FullName);
}
model.Key = new KeyModel(prop, propAtt);
}
else if (attribute is VersionAttribute)
{
VersionAttribute propAtt = attribute as VersionAttribute;
isArProperty = true;
if (model.Version != null)
{
throw new ActiveRecordException("You can't specify more than one VersionAttribute. " +
"Check type " + model.Type.FullName);
}
model.Version = new VersionModel(prop, propAtt);
}
else if (attribute is TimestampAttribute)
{
TimestampAttribute propAtt = attribute as TimestampAttribute;
isArProperty = true;
if (model.Timestamp != null)
{
throw new ActiveRecordException("You can't specify more than one TimestampAttribute. " +
"Check type " + model.Type.FullName);
}
model.Timestamp = new TimestampModel(prop, propAtt);
}
// Relations
else if (attribute is OneToOneAttribute)
{
OneToOneAttribute propAtt = attribute as OneToOneAttribute;
isArProperty = true;
model.OneToOnes.Add(new OneToOneModel(prop, propAtt));
}
else if (attribute is BelongsToAttribute)
{
BelongsToAttribute propAtt = attribute as BelongsToAttribute;
isArProperty = true;
BelongsToModel btModel = new BelongsToModel(prop, propAtt);
model.BelongsTo.Add(btModel);
model.BelongsToDictionary[prop.Name] = btModel;
if (extension != null)
{
extension.ProcessBelongsTo(prop, btModel, model);
}
}
// The ordering is important here, HasManyToAny must comes before HasMany!
else if (attribute is HasManyToAnyAttribute)
{
HasManyToAnyAttribute propAtt = attribute as HasManyToAnyAttribute;
isArProperty = true;
hasManyToAnyModel = new HasManyToAnyModel(prop, propAtt);
model.HasManyToAny.Add(hasManyToAnyModel);
model.HasManyToAnyDictionary[prop.Name] = hasManyToAnyModel;
CollectMetaValues(hasManyToAnyModel.MetaValues, prop);
if (extension != null)
{
extension.ProcessHasManyToAny(prop, hasManyToAnyModel, model);
}
}
else if (attribute is HasManyAttribute)
{
HasManyAttribute propAtt = attribute as HasManyAttribute;
isArProperty = true;
HasManyModel hasManyModel = new HasManyModel(prop, propAtt, model);
if (propAtt.DependentObjects)
{
ActiveRecordModel dependentObjectModel = new ActiveRecordModel(propAtt.MapType);
dependentObjectModel.IsNestedType = true;
dependentObjectModel.IsNestedCompositeType = true;
ProcessProperties(propAtt.MapType, dependentObjectModel);
hasManyModel.DependentObjectModel = new DependentObjectModel(prop, propAtt, dependentObjectModel);
}
model.HasMany.Add(hasManyModel);
model.HasManyDictionary[prop.Name] = hasManyModel;
if (extension != null)
{
extension.ProcessHasMany(prop, hasManyModel, model);
}
}
else if (attribute is HasAndBelongsToManyAttribute)
{
HasAndBelongsToManyAttribute propAtt = attribute as HasAndBelongsToManyAttribute;
isArProperty = true;
HasAndBelongsToManyModel habtManyModel = new HasAndBelongsToManyModel(prop, propAtt);
model.HasAndBelongsToMany.Add(habtManyModel);
model.HasAndBelongsToManyDictionary[prop.Name] = habtManyModel;
if (extension != null)
{
extension.ProcessHasAndBelongsToMany(prop, habtManyModel, model);
}
}
else if (attribute is Any.MetaValueAttribute)
{
if (prop.GetCustomAttributes(typeof(HasManyToAnyAttribute), false).Length == 0 &&
prop.GetCustomAttributes(typeof(AnyAttribute), false).Length == 0
)
{
throw new ActiveRecordException(
"You can't specify an Any.MetaValue without specifying the Any or HasManyToAny attribute. " +
"Check type " + prop.DeclaringType.FullName);
}
}
else if (attribute is CompositeUserTypeAttribute)
{
CompositeUserTypeAttribute propAtt = attribute as CompositeUserTypeAttribute;
isArProperty = true;
model.CompositeUserType.Add(new CompositeUserTypeModel(prop, prop.PropertyType, propAtt));
}
if (attribute is CollectionIDAttribute)
{
CollectionIDAttribute propAtt = attribute as CollectionIDAttribute;
model.CollectionIDs.Add(new CollectionIDModel(prop, propAtt));
}
if (attribute is HiloAttribute)
{
HiloAttribute propAtt = attribute as HiloAttribute;
model.Hilos.Add(new HiloModel(prop, propAtt));
}
}
if (!isArProperty)
{
model.NotMappedProperties.Add(prop);
}
}
}
