private static List <Field> GetFieldsOrdered(EntityJoin entityAliasTree)
{
return(entityAliasTree.Entity.GetFields()
.Where(f => !f.IsEntity)
.OrderBy(f => !f.IsKey)
.ThenBy(f => f.Name).ToList());
}
private string GetColumn(EntityJoin join, Field field)
{
return(String.Format("{0}{1} {2}",
SEPARATOR,
GetColumnName(join, field),
GetColumnAlias(join, field)));
}
private EntityJoin Generate(Field field)
{
EntityJoin join = Generate(GetEntity(field.Type), field);
join.Field = field;
return(join);
}
private void ProcessAlias(EntityJoin join, string entityPath)
{
join.Entity.GetFields()
.OrderBy(f => f.ColumnName.Length)
.Reverse()
.Where(f => !f.IsEntity).ToList()
.ForEach(field => ReplaceConditionField(join, field, entityPath));
}
private string GetSelectFields(EntityJoin entityAliasTree)
{
string selectFields = "";
GetFieldsOrdered(entityAliasTree)
.ForEach(f => selectFields += GetColumn(entityAliasTree, f));
return(selectFields);
}
public void AssertAliasProduto()
{
target = new EntityJoinsGenerator();
EntityJoin tree = target.Generate(entityProduto);
Assert.That(tree.Alias.Symbol, Is.EqualTo("p"));
Assert.That(tree.Field, Is.Null);
Assert.That(tree.Joins.Any(), Is.False);
}
private void AddJoin(EntityJoin entityA, EntityJoin entityB)
{
from += String.Format(FORMAT_JOIN,
GetTableName(entityB),
GetAlias(entityB),
GetPrimaryKey(),
GetAlias(entityA),
GetForeignKey(entityB));
}
private EntityJoin Generate(Entity entity, Field field)
{
Alias alias = CreateAlias(entity, field);
EntityJoin join = new EntityJoin(alias);
entity.GetFields().Where(f => f.IsEntity).ToList()
.ForEach(f => join.Joins.Add(Generate(f)));
return(join);
}
private object GetJoinValue(EntityJoin join)
{
return(new EntityLoaderBuilder()
.Entity(join.Entity)
.Row(Row)
.Columns(Columns)
.IndexColumn(IndexColumn)
.Dictionary(DictionaryObjectsProcessed)
.Build());
}
private void ReplaceConditionField(EntityJoin join, Field field, string entityPath)
{
FieldAliasReplacer replacer = new FieldAliasReplacerBuilder()
.Join(join)
.Field(field)
.SqlQuery(sqlCommand)
.EntityPath(entityPath)
.Builder();
sqlCommand = replacer.Replace();
}
public void AssertAliasPrecoProduto()
{
target = new EntityJoinsGenerator();
EntityJoin treePrecoProduto = target.Generate(entityPrecoProduto);
Assert.That(treePrecoProduto.Alias.Symbol, Is.EqualTo("p"));
Assert.That(treePrecoProduto.Field, Is.Null);
Assert.That(treePrecoProduto.Joins.Count, Is.EqualTo(1));
EntityJoin treeProduto = treePrecoProduto.Joins[0];
Assert.That(treeProduto.Alias.Symbol, Is.EqualTo("pr"));
Assert.That(treeProduto.Field.ToString(), Is.EqualTo("[id_produto]Produto: EntityJokeTests.Core.Produto"));
Assert.That(treeProduto.Joins.Any(), Is.False);
}
private void ProcessJoin(EntityJoin join)
{
SetFieldValue(join.Field, GetJoinValue(join));
}
private bool IsEntityMain(EntityJoin join)
{
return(join.Field == null);
}
private string GetNameFieldWithEntityPath(EntityJoin join, string entityPath)
{
return(String.Format("{0}.{1}", entityPath, join.Field.Name));
}
private static string GetEntityName(EntityJoin join)
{
return(join.Entity.Type.Name);
}
private string GetCompletedNameField(EntityJoin join, string entityPath)
{
return(IsEntityMain(join) ? GetEntityName(join) : GetNameFieldWithEntityPath(join, entityPath));
}
public FieldAliasReplacerBuilder Join(EntityJoin join)
{
this.join = join;
return(this);
}
private void ReplaceFieldsEntity(EntityJoin join, string entityPath = "")
{
ProcessAlias(join, entityPath);
join.Joins.ForEach(j => ReplaceFieldsEntity(j, GetCompletedNameField(join, entityPath)));
}
private void AddEntityAlias(EntityJoin entityAliasTree)
{
select += GetSelectFields(entityAliasTree);
entityAliasTree.Joins.ForEach(j => AddEntityAlias(j));
}
private static string GetAlias(EntityJoin entity)
{
return(entity.Alias.Symbol);
}
private static string GetForeignKey(EntityJoin entity)
{
return(entity.Field.ColumnName);
}
private static string GetTableName(EntityJoin entity)
{
return(entity.TableName);
}
private string GetColumnAlias(EntityJoin join, Field field)
{
return(String.Format("{0}_{1}", join.Alias.Symbol, field.ColumnName));
}
private void ProcessJoin(EntityJoin entityA, EntityJoin entityB)
{
AddJoin(entityA, entityB);
ProcessJoins(entityB);
}
private void ProcessJoins(EntityJoin entityA)
{
entityA.Joins.ForEach(entityB => ProcessJoin(entityA, entityB));
}
private void AddEntityMain(EntityJoin entity)
{
from += String.Format("{0} {1}", entity.Entity.Name, entity.Alias.Symbol);
}
