public FirewallRule(NameParameter name, DirectionParameter direction, ActionParameter action)
{
if (name == null) throw new ArgumentNullException(nameof(name));
if (direction == null) throw new ArgumentNullException(nameof(direction));
if (action == null) throw new ArgumentNullException(nameof(action));
Name = name;
Direction = direction;
Action = action;
}
/// <summary>
/// Recupera os dados do objeto submetido tendo como base os valores
/// da chave contidos no objeto submetido.
/// </summary>
/// <param name="session">Sess�o utilizada para a execu��o do comando.</param>
/// <param name="objData">Objeto contendo os dados das chaves.</param>
/// <returns>Model com os dados recuperados.</returns>
public Model RecoverData(GDASession session, Model objData)
{
string sqlParam = "";
StringBuilder buf = new StringBuilder("SELECT ");
List <Mapper> properties = Keys;
if (properties.Count == 0)
{
throw new GDAException("In model {0} not found keys for to recover data.", objData.GetType().FullName);
}
DirectionParameter[] dp = new DirectionParameter[] {
DirectionParameter.Input,
DirectionParameter.InputOutput,
DirectionParameter.OutputOnlyInsert
};
List <Mapper> columns = MappingManager.GetMappers <Model>(null, dp);
foreach (Mapper column in columns)
{
buf.Append(UserProvider.QuoteExpression(column.Name)).Append(",");
}
buf.Remove(buf.Length - 1, 1);
buf.Append(" FROM ").Append(SystemTableName).Append(" ");
GDAParameter[] parameters = new GDAParameter[properties.Count];
int i = 0;
foreach (Mapper mapper in properties)
{
if (sqlParam != "")
{
sqlParam += " AND ";
}
parameters[i] = new GDAParameter(UserProvider.ParameterPrefix + mapper.Name + UserProvider.ParameterSuffix, typeof(Model).GetProperty(mapper.PropertyMapper.Name).GetValue(objData, null));
sqlParam += UserProvider.QuoteExpression(mapper.Name) + "=" + parameters[i].ParameterName;
i++;
}
buf.Append("WHERE ").Append(sqlParam);
return(RecoverData(session, objData, buf.ToString(), parameters));
}
/// <summary>
/// Recupera as propriedades de persistencia que são usadas pela ação de atualização.
/// </summary>
/// <param name="instanceType"></param>
/// <param name="propertyNames"></param>
/// <param name="direction"></param>
/// <param name="typeMetadata"></param>
/// <param name="isConditional"></param>
/// <returns></returns>
private IEnumerable <System.Reflection.PropertyInfo> GetUpdatePersistenceProperties(Type instanceType, string[] propertyNames, DirectionPropertiesName direction, ITypeMetadata typeMetadata, bool isConditional)
{
var parameterTypes = new PersistenceParameterType[] {
PersistenceParameterType.Field
};
var directions = new DirectionParameter[] {
DirectionParameter.Output,
DirectionParameter.InputOptionalOutput,
DirectionParameter.InputOutput
};
var mapping = typeMetadata.Where(f => directions.Contains(f.Direction) && parameterTypes.Contains(f.ParameterType)).ToList();
FilterMapping(propertyNames, direction, mapping, typeMetadata, PersistenceActionType.Update);
if (isConditional)
{
return(mapping.Select(f => instanceType.GetProperty(f.Name)).Where(f => f != null));
}
else
{
return(mapping.Union(typeMetadata.GetKeyProperties(), PropertyMetadataEqualityComparer.Instance).Select(f => instanceType.GetProperty(f.Name)).Where(f => f != null));
}
}
public void TestDirectionParameter()
{
var generator = new TestFactoryBuilder()
.Build();
var accessor = generator.Create <IDirectionParameterAccessor>();
var con = new MockDbConnection();
con.SetupCommand(cmd =>
{
cmd.Executing = c =>
{
Assert.Equal("PROC", c.CommandText);
Assert.Equal("1", c.Parameters[nameof(DirectionParameter.InParam)].Value);
Assert.Equal(2, c.Parameters[nameof(DirectionParameter.InOutParam)].Value);
c.Parameters[nameof(DirectionParameter.InOutParam)].Value = 3;
c.Parameters[nameof(DirectionParameter.OutParam)].Value = 4;
c.Parameters.OfType <MockDbParameter>().First(x => x.Direction == ParameterDirection.ReturnValue).Value = 5;
};
cmd.SetupResult(100);
});
var parameter = new DirectionParameter
{
InParam = "1",
InOutParam = 2
};
accessor.Call(con, parameter);
Assert.Equal(3, parameter.InOutParam);
Assert.Equal(4, parameter.OutParam);
Assert.Equal(5, parameter.Result);
}
/// <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>
/// Captura os attributes PersistenceProperty das propriedades da classe refenciada.
/// </summary>
/// <param name="typeModel">Tipo do modelo de onde será recuperado o mapeamento.</param>
/// <param name="typesParam">Tipos de parametros a serem filtrados. null para não se aplicar nenhum filtro.</param>
/// <param name="directions">Sentido dos atributos a serem filtrados. Default Input, InputOutput</param>
/// <param name="returnFirstFound">True para retorna o primeiro valor encontrado.</param>
/// <returns>Lista com todas os atributos, obedecendo o filtro.</returns>
public static List <Mapper> GetMappers(Type typeModel, PersistenceParameterType[] typesParam, DirectionParameter[] directions, bool returnFirstFound)
{
var persistencePropertyAttributes = MappingManager.LoadPersistencePropertyAttributes(typeModel);
List <Mapper> result = new List <Mapper>();
var propertiesMapped = persistencePropertyAttributes.Mappers;
if (directions == null)
{
directions = new DirectionParameter[] {
DirectionParameter.Input,
DirectionParameter.InputOptionalOutput,
DirectionParameter.InputOutput,
DirectionParameter.OutputOnlyInsert,
DirectionParameter.InputOptional,
DirectionParameter.InputOptionalOutput
}
}
;
bool itemFound;
if (propertiesMapped != null)
{
foreach (Mapper mapper in propertiesMapped)
{
if (mapper == null)
{
continue;
}
if (typesParam != null)
{
itemFound = false;
foreach (PersistenceParameterType ppt in typesParam)
{
if (ppt == mapper.ParameterType)
{
itemFound = true;
break;
}
}
if (!itemFound)
{
continue;
}
}
if (directions != null)
{
itemFound = false;
foreach (DirectionParameter dp in directions)
{
if (dp == mapper.Direction)
{
itemFound = true;
break;
}
}
if (!itemFound)
{
continue;
}
}
result.Add(mapper);
if (returnFirstFound)
{
break;
}
}
}
return(result);
}
/// <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, DirectionParameter direction)
{
if (propertySelector == null)
{
throw new ArgumentNullException("propertySelector");
}
_properties.Add(new PropertyMapping(GDA.Extensions.GetMember(propertySelector).Name, column, PersistenceParameterType.Field, 0, false, false, direction, null, null, null, null));
return(this);
}
public ParameterSP(string nome, object valore, int dim, DirectionParameter direzione, System.Data.DbType t) :
this(nome, valore, dim, direzione)
{
this.Tipo = t;
}
public ParameterSP(string nome, object valore, DirectionParameter direzione) :
this(nome, valore, 0, direzione)
{
}
/// <summary>
/// Construtor.
/// </summary>
/// <param name="name">Nome que o campo representa 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, int size, DirectionParameter direction)
{
m_Name = name;
m_Size = size;
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>
/// <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="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>
/// Funzione per la creazione di un parametro da passare ad una store
/// </summary>
/// <param name="parameterName">Nome del parametro</param>
/// <param name="initializationValue">Valore da utilizzare per inizializzare il parametro</param>
/// <param name="parameterDirection">Direzione del parametro</param>
/// <param name="parameterLength">Lunghezza del campo</param>
/// <param name="parameterType">Tipo di parametro</param>
/// <returns>Parametro da inviare alla store</returns>
private ParameterSP CreateParameter(String parameterName, Object initializationValue, DirectionParameter parameterDirection, int parameterLength, DbType parameterType)
{
// Creazione e restituzione del parametro
ParameterSP parameter;
parameter = new ParameterSP(parameterName, initializationValue, parameterDirection);
parameter.Size = parameterLength;
parameter.Tipo = parameterType;
return(parameter);
}
/// <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);
}
}
}
}
