/// <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); } } }