/// <summary>
/// Finds the entity by its prefix
/// </summary>
/// <typeparam name="T">The type of the entity</typeparam>
/// <param name="baseFilterDto">The filtering DTO to make the where part</param>
/// <param name="selector">The selector for select the attributes</param>
/// <returns>The list of the referencedDto for the appropriate search DTO</returns>
internal List <ReferenceDto> FindByPrefix <T>(BaseFilterDto baseFilterDto, Expression <Func <T, ReferenceDto> > selector) where T : BaseEntity
{
return(_modelContext.Set <T>()
.Where(ExpressionQueryBuilder.BuildWhere <T>(baseFilterDto))
.Select(selector)
.ToList());
}
internal IPagedList <T> FindPaged <T, U>(EventFilterDto eventFilterDto) where T : BaseEventDto, new() where U : BaseEvent
{
return(_modelContext.Set <U>()
.Where(ExpressionQueryBuilder.BuildWhere <U>(eventFilterDto))
.OrderBy(x => x.Start)
.Select(x => new T()
{
Id = x.Id, Theme = x.Theme, Start = x.Start, End = x.End, City = x.City, CountryId = x.CountryId
})
.ToPagedList(eventFilterDto.Page, eventFilterDto.PageSize));
}
/// <summary>
/// Finds paged users.
/// </summary>
/// <param name="userFilterDto">The filtering DTO</param>
/// <returns>The User DTO page</returns>
internal IPagedList <UserDto> FindPaged(UserFilterDto userFilterDto)
{
return(_modelContext.Set <User>()
.Where(ExpressionQueryBuilder.BuildWhere <User>(userFilterDto))
.OrderBy(x => x.Surname)
.Select(x => new UserDto()
{
Id = x.Id, BujinkanTitle = x.BujinkanTitle, FirstName = x.FirstName, Surname = x.Surname
})
.ToPagedList(userFilterDto.Page, userFilterDto.PageSize));
}
internal ListReferenceDto FindAllReferences <T>(CategoryFilterDto categoryFilterDto) where T : Category
{
Dictionary <Guid, string> references = _modelContext.Set <T>()
.Where(ExpressionQueryBuilder.BuildWhere <T>(categoryFilterDto))
.OrderBy(x => x.Name)
.Select(x => new { Id = x.Id, Name = x.Name })
.ToDictionary(x => x.Id, x => x.Name);
return(new ListReferenceDto()
{
References = references
});
}
internal ListReferenceDto FindAllReferences(BaseFilterDto baseFilterDto)
{
Dictionary <Guid, string> references = _modelContext.Set <Role>()
.Where(ExpressionQueryBuilder.BuildWhere <Role>(baseFilterDto))
.OrderBy(x => x.Name)
.Select(x => new { Id = x.Id, Name = x.Name })
.ToDictionary(x => x.Id, x => x.Name);
return(new ListReferenceDto()
{
References = references
});
}
internal IPagedList <TrainingDto> FindPaged(TrainingFilterDto trainingFilterDto)
{
return(_modelContext.Set <Training>()
.Where(ExpressionQueryBuilder.BuildWhere <Training>(trainingFilterDto))
.OrderBy(x => x.Day)
.Select(x => new TrainingDto()
{
Id = x.Id, Day = x.Day, Start = x.Start, End = x.End, City = x.City, UserReference = new ReferenceString()
{
Value = x.UserId + ":" + x.User.FirstName + " " + x.User.Surname
}, UserId = x.UserId
})
.ToPagedList(trainingFilterDto.Page, trainingFilterDto.PageSize));
}
public override string ToString()
{
var sb = new StringBuilder();
sb.Append("SELECT ");
var firstColumn = true;
foreach (var column in SelectedColumns)
{
if (!firstColumn)
{
sb.Append(", ");
}
firstColumn = false;
sb.Append(column);
}
sb.AppendLine();
sb.Append("FROM ").Append($"[{RootTableName}] AS ").Append($"[{RootTableAlias}]").AppendLine();
foreach (var join in Joins)
{
sb.AppendLine(join.ToString());
}
var expComp = new ExpressionQueryBuilder <T>(m_owner);
var where = expComp.Map(Where);
where.Render(sb);
sb.AppendLine();
ResultOrderingModel.Render <T>(OrderBy, sb);
if (Skip != null)
{
sb.AppendLine($"OFFSET {Skip} ROWS");
}
if (Take != null)
{
sb.AppendLine($"FETCH NEXT {Take} ROWS ONLY");
}
return(sb.ToString());
}
public ITransformedQuery <TResult> Transform <TResult>(Expression <Func <T, TResult> > generator)
{
var expComp = new ExpressionQueryBuilder <T>(this);
var seg = expComp.Map(generator) as WhereSegment;
var selexp = seg.GetSelectExpression();
if (!m_selectList.Contains(selexp))
{
m_selectList.Add(selexp);
}
return(new TransformedQueryBuilder <T, TResult>(m_owner, this));
}
public static string Render <T>(IQueryModel <T> query, IQueryBuilder <T> queryBuilder) where T : class
{
var sb = new StringBuilder();
var takeRendered = false;
sb.Append("SELECT ");
if ((query.Skip == null) && (query.Take != null))
{
sb.Append($"TOP {query.Take} ");
takeRendered = true;
}
var firstColumn = true;
foreach (var column in query.SelectedColumns)
{
if (!firstColumn)
{
sb.Append(", ");
}
firstColumn = false;
sb.Append(column);
}
sb.AppendLine();
sb.Append("FROM ").Append($"[{query.RootTableName}] AS ").Append($"[{query.RootTableAlias}]").AppendLine();
foreach (var join in query.Joins)
{
sb.AppendLine(join.ToString());
}
var expComp = new ExpressionQueryBuilder <T>(queryBuilder);
var where = expComp.Map(query.Where);
where.Render(sb);
sb.AppendLine();
ResultOrderingModel.Render <T>(query.OrderBy, sb);
if (!takeRendered)
{
if (query.Skip != null)
{
sb.AppendLine($"OFFSET {query.Skip} ROWS");
}
if (query.Take != null)
{
sb.AppendLine($"FETCH NEXT {query.Take} ROWS ONLY");
}
}
return(sb.ToString());
}
