public List <Tuple <string, Object> > GetColumnsAndValues(Object instance, bool isInherited = false) { List <Tuple <string, Object> > list = new List <Tuple <string, Object> > { }; Type instanceType = instance.GetType(); PropertyInfo[] properties; if (isInherited) { properties = GetTypeAllProperties(instanceType); } else { properties = GetTypeProperties(instanceType); } foreach (PropertyInfo property in properties) { MethodInfo strGetter = property.GetGetMethod(nonPublic: true); var value = strGetter.Invoke(instance, null); string columnName; ColumnAttribute columnAttribute = (ColumnAttribute)property.GetCustomAttribute(typeof(ColumnAttribute), false); if (columnAttribute == null) { continue; } if (columnAttribute._columnName == null) { columnName = property.Name; } else { columnName = columnAttribute._columnName; } OneToOneAttribute oneToOneAttribute = (OneToOneAttribute)property.GetCustomAttribute(typeof(OneToOneAttribute), false); OneToManyAttribute oneToManyAttribute = (OneToManyAttribute)property.GetCustomAttribute(typeof(OneToManyAttribute), false); ManyToManyAttribute manyToManyAttribute = (ManyToManyAttribute)property.GetCustomAttribute(typeof(ManyToManyAttribute), false); if (oneToOneAttribute == null && oneToManyAttribute == null && manyToManyAttribute == null) { list.Add(new Tuple <string, Object>(columnName, value)); } } return(list); }
public List <Tuple <string, Object> > GetInheritedColumnsAndValues(List <PropertyInfo> inheritedProperties) { List <Tuple <string, Object> > list = new List <Tuple <string, object> >(); foreach (var property in inheritedProperties) { Type propertyType = property.PropertyType; string columnName; ColumnAttribute columnAttribute = (ColumnAttribute)property.GetCustomAttribute(typeof(ColumnAttribute), false); if (columnAttribute == null) { continue; } if (columnAttribute._columnName == null) { columnName = property.Name; } else { columnName = columnAttribute._columnName; } OneToOneAttribute oneToOneAttribute = (OneToOneAttribute)property.GetCustomAttribute(typeof(OneToOneAttribute), false); OneToManyAttribute oneToManyAttribute = (OneToManyAttribute)property.GetCustomAttribute(typeof(OneToManyAttribute), false); ManyToManyAttribute manyToManyAttribute = (ManyToManyAttribute)property.GetCustomAttribute(typeof(ManyToManyAttribute), false); if (oneToOneAttribute == null && oneToManyAttribute == null && manyToManyAttribute == null) { list.Add(new Tuple <string, Object>(columnName, propertyType)); } } return(list); }
/// <summary> Write a OneToOne XML Element from attributes in a member. </summary> public virtual void WriteOneToOne(System.Xml.XmlWriter writer, System.Reflection.MemberInfo member, OneToOneAttribute attribute, BaseAttribute parentAttribute, System.Type mappedClass) { writer.WriteStartElement( "one-to-one" ); // Attribute: <name> writer.WriteAttributeString("name", attribute.Name==null ? DefaultHelper.Get_OneToOne_Name_DefaultValue(member) : GetAttributeValue(attribute.Name, mappedClass)); // Attribute: <formula> if(attribute.Formula != null) writer.WriteAttributeString("formula", GetAttributeValue(attribute.Formula, mappedClass)); // Attribute: <access> if(attribute.Access != null) writer.WriteAttributeString("access", GetAttributeValue(attribute.Access, mappedClass)); // Attribute: <class> if(attribute.Class != null) writer.WriteAttributeString("class", GetAttributeValue(attribute.Class, mappedClass)); // Attribute: <entity-name> if(attribute.EntityName != null) writer.WriteAttributeString("entity-name", GetAttributeValue(attribute.EntityName, mappedClass)); // Attribute: <cascade> if(attribute.Cascade != null) writer.WriteAttributeString("cascade", GetAttributeValue(attribute.Cascade, mappedClass)); // Attribute: <outer-join> if(attribute.OuterJoin != OuterJoinStrategy.Unspecified) writer.WriteAttributeString("outer-join", GetXmlEnumValue(typeof(OuterJoinStrategy), attribute.OuterJoin)); // Attribute: <fetch> if(attribute.Fetch != FetchMode.Unspecified) writer.WriteAttributeString("fetch", GetXmlEnumValue(typeof(FetchMode), attribute.Fetch)); // Attribute: <constrained> if( attribute.ConstrainedSpecified ) writer.WriteAttributeString("constrained", attribute.Constrained ? "true" : "false"); // Attribute: <foreign-key> if(attribute.ForeignKey != null) writer.WriteAttributeString("foreign-key", GetAttributeValue(attribute.ForeignKey, mappedClass)); // Attribute: <property-ref> if(attribute.PropertyRef != null) writer.WriteAttributeString("property-ref", GetAttributeValue(attribute.PropertyRef, mappedClass)); // Attribute: <lazy> if(attribute.Lazy != Laziness.Unspecified) writer.WriteAttributeString("lazy", GetXmlEnumValue(typeof(Laziness), attribute.Lazy)); // Attribute: <node> if(attribute.Node != null) writer.WriteAttributeString("node", GetAttributeValue(attribute.Node, mappedClass)); // Attribute: <embed-xml> if( attribute.EmbedXmlSpecified ) writer.WriteAttributeString("embed-xml", attribute.EmbedXml ? "true" : "false"); WriteUserDefinedContent(writer, member, null, attribute); System.Collections.ArrayList memberAttribs = GetSortedAttributes(member); int attribPos; // Find the position of the OneToOneAttribute (its <sub-element>s must be after it) for(attribPos=0; attribPos<memberAttribs.Count; attribPos++) if( memberAttribs[attribPos] is OneToOneAttribute && ((BaseAttribute)memberAttribs[attribPos]).Position == attribute.Position ) break; // found int i = attribPos + 1; // Element: <meta> for(; i<memberAttribs.Count; i++) { BaseAttribute memberAttrib = memberAttribs[i] as BaseAttribute; if( IsNextElement(memberAttrib, parentAttribute, attribute.GetType()) || IsNextElement(memberAttrib, attribute, typeof(MetaAttribute)) ) break; // next attributes are 'elements' of the same level OR for 'sub-elements' else { if( memberAttrib is OneToOneAttribute ) break; // Following attributes are for this OneToOne if( memberAttrib is MetaAttribute ) WriteMeta(writer, member, memberAttrib as MetaAttribute, attribute, mappedClass); } } WriteUserDefinedContent(writer, member, typeof(MetaAttribute), attribute); // Element: <formula> for(; i<memberAttribs.Count; i++) { BaseAttribute memberAttrib = memberAttribs[i] as BaseAttribute; if( IsNextElement(memberAttrib, parentAttribute, attribute.GetType()) || IsNextElement(memberAttrib, attribute, typeof(FormulaAttribute)) ) break; // next attributes are 'elements' of the same level OR for 'sub-elements' else { if( memberAttrib is OneToOneAttribute ) break; // Following attributes are for this OneToOne if( memberAttrib is FormulaAttribute ) WriteFormula(writer, member, memberAttrib as FormulaAttribute, attribute, mappedClass); } } WriteUserDefinedContent(writer, member, typeof(FormulaAttribute), attribute); writer.WriteEndElement(); }
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); } } }
/// <summary> /// Initializes a new instance of the <see cref="OneToOneModel"/> class. /// </summary> /// <param name="propInfo">The prop info.</param> /// <param name="att">The att.</param> public OneToOneModel(PropertyInfo propInfo, OneToOneAttribute att) { this.propInfo = propInfo; this.att = att; }
/// <summary> /// Initializes a new instance of the <see cref="OneToOneModel"/> class. /// </summary> /// <param name="propInfo">The prop info.</param> /// <param name="att">The att.</param> public OneToOneModel(PropertyInfo propInfo, OneToOneAttribute att) { this.propInfo = propInfo; this.att = att; }
public OneToOneRelation(Table parentTable, Table childTable, MemberInfo member, string memberPath, Type memberValueType, OneToOneAttribute relationAttribute) : base(parentTable, childTable, member, memberPath, memberValueType, relationAttribute) { }
/// <summary> /// Sets a value from a specific property. /// </summary> /// <exception cref="ActiveRecordAttributeException"></exception> /// <param name="propertyName">string</param> /// <param name="value">object</param> public static void SetValue(this IActiveRecord wrapper, string propertyName, object value) { if (wrapper.IsProxy) { wrapper.FetchUnderlyingObject(); } if (wrapper.Deleted) { throw new ActiveRecordException("Não é possível setar o valor deste atributo, pois o objeto foi deletado."); } var att = wrapper.GetFieldDefinition(typeof(FieldAttribute), propertyName); if (att == null) { throw new ActiveRecordAttributeException(wrapper.GetType(), String.Format("Não foi possível localizar o atributo de campo para a propriedade {0}", propertyName)); } if (att is DomainFieldAttribute) { SetDisplayValue(wrapper, att, value.ToString()); } if (att is BelongsToAttribute) { BelongsToAttribute attribute = att as BelongsToAttribute; if (value == null) { wrapper.UnderlyingObject.set_Value(attribute.ParentValueFieldIndex, DBNull.Value); } else { wrapper.UnderlyingObject.set_Value(attribute.ParentValueFieldIndex, value); } return; } if (att is OneToOneAttribute) { OneToOneAttribute attribute = att as OneToOneAttribute; if (value == null) { wrapper.UnderlyingObject.set_Value(attribute.RelatedAttributeIndex, DBNull.Value); } else { wrapper.UnderlyingObject.set_Value(attribute.RelatedAttributeIndex, value); } return; } // if the field does not have an index, just exit if (att.Index == -1) { return; } // if the field cannot be null, but it is, throw a new exception if (att.NotNullable && value == null) { throw new ActiveRecordException(String.Format("O atributo {0} não pode ser nulo.", att.FieldName)); } if (att.FieldType == esriFieldType.esriFieldTypeBlob) { SetBlobValue(wrapper, att, value); return; } if (value == null) { wrapper.UnderlyingObject.set_Value(att.Index, DBNull.Value); } else { wrapper.UnderlyingObject.set_Value(att.Index, value); } }