void System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
{
int.TryParse(reader.GetAttribute("code"), out _propertyCode);
_name = reader.GetAttribute("name");
_columnName = string.IsNullOrEmpty(reader.GetAttribute("columnName")) ? _name : reader.GetAttribute("columnName");
_propertyType = reader.GetAttribute("type");
if (!Enum.TryParse <DirectionParameter>(reader.GetAttribute("direction"), out _direction))
{
_direction = DirectionParameter.InputOutput;
}
if (!Enum.TryParse <PersistenceParameterType>(reader.GetAttribute("parameterType"), out _parameterType))
{
_parameterType = PersistenceParameterType.Field;
}
bool.TryParse(reader.GetAttribute("isVolatile"), out _isVolatile);
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
if (reader.LocalName == "ForeignKey" && reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
var fkInfo = new ForeignKeyInfo();
((System.Xml.Serialization.IXmlSerializable)fkInfo).ReadXml(reader);
_foreignKey = fkInfo;
_isForeignKey = true;
reader.Skip();
}
else
{
reader.ReadEndElement();
}
}
}
/// <summary>
/// Constrói uma instancia do mapeamento da propriedade.
/// </summary>
/// <param name="name">Nome da propriedade</param>
/// <param name="column">Nome da coluna relacionada com a propriedade.</param>
/// <param name="parameterType">Tipo do parametro do mapeamento.</param>
/// <param name="size">Tamanho da coluna.</param>
/// <param name="isNotPersists">Identifica se a propriedade não para ser persistida.</param>
/// <param name="isNotNull">Identifica se a propriedade aceita valores nulos.</param>
/// <param name="direction">Direção do mapeamento da propriedade.</param>
/// <param name="generatorKeyName">Nome do gerador de chave usado pela propriedade.</param>
/// <param name="foreignKey">Dados da chave estrangeira relacionada.</param>
/// <param name="foreignMember">Dados do membro estrangeiro relacionado.</param>
/// <param name="validators">Validadores aplicados a propriedade.</param>
public PropertyMapping(string name, string column, PersistenceParameterType parameterType, int size, bool isNotPersists, bool isNotNull, DirectionParameter direction, string generatorKeyName, ForeignKeyMapping foreignKey, ForeignMemberMapping foreignMember, IEnumerable <ValidatorMapping> validators)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
this.Name = name;
this.Column = string.IsNullOrEmpty(column) ? name : column;
this.ParameterType = parameterType;
this.Size = size;
this.IsNotPersists = isNotPersists;
this.IsNotNull = isNotNull;
this.Direction = direction;
this.GeneratorKeyName = generatorKeyName;
this.ForeignKey = foreignKey;
this.ForeignMember = foreignMember;
Validators = new List <ValidatorMapping>();
if (validators != null)
{
foreach (var i in validators)
{
if (!Validators.Exists(f => f.Name == i.Name))
{
Validators.Add(i);
}
}
}
}
/// <summary>
/// Cria uma instancia para propriedade mapeada.
/// </summary>
/// <param name="modelType"></param>
/// <param name="ppa"></param>
/// <param name="propertyMapper"></param>
public Mapper(Type modelType, PersistencePropertyAttribute ppa, PropertyInfo propertyMapper)
{
this._modelType = modelType;
this._name = ppa.Name;
this._direction = ppa.Direction;
this._parameterType = ppa.ParameterType;
this._size = ppa.Size;
this._propertyMapper = propertyMapper;
this._propertyMapperName = propertyMapper.Name;
this._generatorKeyName = ppa.GeneratorKeyName;
this._isNotNull = ppa.IsNotNull;
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="propertyCode">Código da propriedade.</param>
/// <param name="name">Nome da propriedade.</param>
/// <param name="columnName">Nome da coluna associada.</param>
/// <param name="propertyType">Nome do tipo associado com a propriedade.</param>
/// <param name="foreignKeyTypeCode">Código de um tipo cuja propriedade é foreign key.</param>
/// <param name="isCacheIndexed">Identifica se está no cache.</param>
/// <param name="direction">Direção de persistencia da propriedade.</param>
/// <param name="isVolatile">Define se o campo deve ser sempre recuperado do banco de dados</param>
/// <param name="parameterType">Tipo de parametro que a propriedade representa.</param>
/// <param name="isForeignMember">Boleano que define se a propriedade é referência alguma tabela.</param>
public PropertyMetadata(int propertyCode, string name, string columnName, string propertyType, int?foreignKeyTypeCode = null, bool isCacheIndexed = true, DirectionParameter direction = DirectionParameter.InputOutput, bool isVolatile = false, PersistenceParameterType parameterType = PersistenceParameterType.Field, bool isForeignMember = false)
{
_propertyCode = propertyCode;
_name = name;
_columnName = columnName;
_propertyType = propertyType;
_foreignKeyTypeCode = foreignKeyTypeCode;
_isCacheIndexed = isCacheIndexed;
_direction = direction;
_parameterType = parameterType;
_isForeignKey = isForeignMember;
_isVolatile = isVolatile;
}
/// <summary>
///
/// </summary>
/// <param name="modelType"></param>
/// <param name="name"></param>
/// <param name="direction"></param>
/// <param name="parameterType"></param>
/// <param name="size"></param>
/// <param name="propertyMapper"></param>
/// <param name="generatorKeyName">Nome do gerador de codigo relacionado.</param>
public Mapper(Type modelType, string name, DirectionParameter direction, PersistenceParameterType parameterType, int size, PropertyInfo propertyMapper, string generatorKeyName)
{
this._modelType = modelType;
this._name = name;
this._direction = direction;
this._parameterType = parameterType;
this._size = size;
this._propertyMapper = propertyMapper;
if (propertyMapper != null)
{
this._propertyMapperName = propertyMapper.Name;
}
this._generatorKeyName = generatorKeyName;
}
/// <summary>
/// Recupera as propriedades de persistencia que são usadas pela ação de inserção.
/// </summary>
/// <param name="instanceType"></param>
/// <param name="propertyNames"></param>
/// <param name="direction"></param>
/// <param name="typeMetadata"></param>
/// <returns></returns>
private IEnumerable <System.Reflection.PropertyInfo> GetInsertPersistenceProperties(Type instanceType, string[] propertyNames, DirectionPropertiesName direction, ITypeMetadata typeMetadata)
{
var parameterTypes = new PersistenceParameterType[] {
PersistenceParameterType.Field
};
var directions = new DirectionParameter[] {
DirectionParameter.Output,
DirectionParameter.InputOptionalOutput,
DirectionParameter.InputOutput,
DirectionParameter.OutputOnlyInsert,
DirectionParameter.OnlyInsert,
DirectionParameter.InputOptionalOutputOnlyInsert
};
var mapping = typeMetadata.Where(f => directions.Contains(f.Direction) && parameterTypes.Contains(f.ParameterType)).ToList();
FilterMapping(propertyNames, direction, mapping, typeMetadata, PersistenceActionType.Insert);
var keyMapping = typeMetadata.GetKeyProperties();
return(mapping.Union(keyMapping, PropertyMetadataEqualityComparer.Instance).Select(f => instanceType.GetProperty(f.Name)).Where(f => f != null));
}
/// <summary>
/// Adiciona a propriedade para o mapeamento.
/// </summary>
/// <param name="propertiesSelector"></param>
/// <param name="column"></param>
/// <returns></returns>
public PropertyMappingBuilder <T> Add(Expression <Func <T, object> > propertySelector, string column, PersistenceParameterType parameterType)
{
if (propertySelector == null)
{
throw new ArgumentNullException("propertySelector");
}
_properties.Add(new PropertyMapping(GDA.Extensions.GetMember(propertySelector).Name, column, parameterType, 0, false, false, DirectionParameter.InputOutput, null, null, null, null));
return(this);
}
/// <summary>
/// Construtor.
/// </summary>
/// <param name="name">Nome que o campo representa no BD.</param>
/// <param name="parameterType">Tipo do campo no BD.</param>
/// <param name="size">Tamanho que o campo.</param>
/// <param name="direction">Dire��o em que os dados devem ser tratados.</param>
public PersistencePropertyAttribute(string name, PersistenceParameterType parameterType, int size, DirectionParameter direction) : this(name, parameterType, direction)
{
m_Size = size;
}
/// <summary>
/// Construtor.
/// </summary>
/// <param name="name">Nome que o campo representa no BD.</param>
/// <param name="parameterType">Tipo do campo no BD.</param>
/// <param name="size">Tamanho que o campo.</param>
public PersistencePropertyAttribute(string name, PersistenceParameterType parameterType, int size) : this(name, parameterType)
{
m_Size = size;
}
/// <summary>
/// Construtor.
/// </summary>
/// <param name="name">Nome que o campo representa no BD.</param>
/// <param name="parameterType">Tipo do campo no BD.</param>
/// <param name="direction">Dire��o em que os dados devem ser tratados.</param>
public PersistencePropertyAttribute(string name, PersistenceParameterType parameterType, DirectionParameter direction) : this(name, parameterType)
{
m_Direction = direction;
}
/// <summary>
/// Construtor.
/// </summary>
/// <param name="name">Nome que o campo representa no BD.</param>
/// <param name="parameterType">Tipo do campo no BD.</param>
public PersistencePropertyAttribute(string name, PersistenceParameterType parameterType)
{
m_Name = name;
m_ParameterType = parameterType;
}
/// <summary>
///
/// </summary>
/// <param name="parameterType"></param>
public PersistencePropertyAttribute(PersistenceParameterType parameterType)
{
this.m_ParameterType = parameterType;
}
