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