private static TablixRowHierarchy CreateTablixRowHierarchy()
{
var group =
new Group(
new GroupExpressions(new GroupExpression("=" + Expression.FieldsValue(ElementProperty.Period))));
var sortExpression =
new SortExpression(new Value("=" + Expression.FieldsValue(ElementProperty.Period)));
var sortExpressions = new SortExpressions(sortExpression);
var textRun = new TextRun
{
Value = "=" + Expression.FieldsValue(ElementProperty.Period),
FontWeight = FontWeight.Bold
};
var paragraph = new Paragraph(new TextRuns(textRun))
{
TextAlign = TextAlign.Center
};
var textbox = new Textbox(paragraph)
{
TextboxStyle = new TextboxStyle {
VerticalAlign = VerticalAlign.Middle
}
};
var header = new TablixHeader(new Inch(0.7), new CellContents(textbox));
return(new TablixRowHierarchy(new TablixMembers(new TablixMember(group, sortExpressions, header))));
}
private static TablixColumnHierarchy CreateTablixColumnHierarchy(List <SuperPoco> pocos)
{
var group =
new Group(
new GroupExpressions(new GroupExpression("=ColumnName")
));
var sortExpressions = new SortExpressions(new SortExpression(new Value("=ColumnName")));
var textRun = new TextRun
{
Value = "=ColumnName",
FontWeight = FontWeight.Bold
};
var paragraph = new Paragraph(new TextRuns(textRun))
{
TextAlign = TextAlign.Center
};
var textbox = new Textbox(paragraph)
{
TextboxStyle = new TextboxStyle()
};
var header = new TablixHeader(new Inch(0.4), new CellContents(textbox));
return(new TablixColumnHierarchy(new TablixMembers(new TablixMember(group, sortExpressions, header))));
}
private static IQueryable <TEntity> ApplySort <TEntity>(this IQueryable <TEntity> query, Sort sort)
{
if (!query.Any() || sort == null || sort.IsUnsorted())
{
return(query);
}
var sortExpressions = new SortExpressions <TEntity, object>();
var propertyInfos = typeof(TEntity).GetProperties(BindingFlags.Public | BindingFlags.Instance);
var orders = sort.Orders;
foreach (var order in orders)
{
if (order == null || order.Property == null)
{
continue;
}
var isDescending = order.Direction.IsDescending();
var propertyInfo = propertyInfos.FirstOrDefault(pi => pi.Name.Equals(order.Property, StringComparison.InvariantCultureIgnoreCase));
if (propertyInfo == null)
{
continue;
}
var expressionFunc = GetExpression <TEntity, object>(propertyInfo);
sortExpressions.Add(expressionFunc, isDescending);
}
return(SortExpressions <TEntity, object> .ApplySorts(query, sortExpressions));
}
protected override void SetSearchCriteria(ref SearchBuilder sb)
{
SortExpressions.Clear();
sb.SortExpressions.Clear();
sb.TableAlias = "U";
sb.Fields.Add("UserId");
if (!StringUtils.IsBlank(CompanyName) && CompanyName.ToLower() != "all")
{
sb.Criteria.Add(string.Format("CompanyName='{0}'", SqlUtils.SafeValue(CompanyName)));
}
if (BrandId.HasValue)
{
switch (BrandId.Value)
{
case 0:
sb.Criteria.Add(string.Format("{0} IS NULL", User.Columns.PrimaryBrandId));
break;
default:
sb.Criteria.Add(string.Format("{0}={1}", User.Columns.PrimaryBrandId, BrandId.Value));
break;
}
}
}
private void AddOrderByClause()
{
switch (OrderBy)
{
case OrderBy.Relevance:
// Relevance ordering is done within the full text search
// However, for empty search we also need to order by date
if (StringUtils.IsBlank(GeneralKeyword))
{
SortExpressions.RemoveAll(delegate(ISortExpression sortExpression)
{
string fieldName = sortExpression.FieldName.ToLower();
return(
fieldName == Asset.Columns.PublishDate.ToString().ToLower() ||
fieldName == Asset.Columns.AssetId.ToString().ToLower()
);
});
SortExpressions.Add(new DescendingSort(Asset.Columns.PublishDate));
SortExpressions.Add(new DescendingSort(Asset.Columns.AssetId));
}
break;
case OrderBy.Popularity:
// Order assets by download count. If the download count is the same
// favour newer assets, on the basis that they have achieved the same
// download count in a shorter space of time. This system breaks if
// assets are published and unpublished, as the download count does not
// reset when an asset is unpublished, so it will not be accurate.
SortExpressions.Clear();
SortExpressions.Add(new DescendingSort(Asset.Columns.DownloadCount));
SortExpressions.Add(new DescendingSort(Asset.Columns.UploadDate));
break;
case OrderBy.Date:
// Order by assets by date, with newer assets first
SortExpressions.Clear();
SortExpressions.Add(new DescendingSort(Asset.Columns.PublishDate));
SortExpressions.Add(new DescendingSort(Asset.Columns.AssetId));
break;
}
}
private static TablixColumnHierarchy CreateTablixColumnHierarchy()
{
var group = new Group(new GroupExpressions(new GroupExpression(CreateColumnGroupExpression())));
var sortExpression =
new SortExpression(new Value("=" + Expression.FieldsValue(ElementProperty.AtomicNumber)));
var sortExpressions = new SortExpressions(sortExpression);
var header = new TablixHeader(
new Inch(0.3),
new CellContents(new Textbox(new Paragraph(new TextRuns(new TextRun())))));
return(new TablixColumnHierarchy(new TablixMembers(new TablixMember(group, sortExpressions, header))));
}
/// <summary>
/// Performs a subsequent ordering of the elements in a sequence in descending order, according to a key.
/// </summary>
/// <typeparam name="TKey">The type of the key returned by the function represented by keySelector.</typeparam>
/// <param name="keySelector">A function to extract a key from each element.</param>
/// <returns>A new query instance containing all specified query parameters</returns>
IOrderedQuery <T> IOrderedQuery <T> .ThenByDescending <TKey>(Expression <Func <T, TKey> > keySelector)
{
if (!SortExpressions.Any())
{
throw new InvalidOperationException("No sorting defined yet, use OrderBy or OrderByDescending first.");
}
var expression = _expressionTranslator(keySelector);
var sortExpression = new Expressions.SortExpression(expression, Expressions.SortDirection.Descending);
var sortExpressions = SortExpressions.ToList();
sortExpressions.Add(sortExpression);
var query = new Query <T>(_dataProvider, _expressionTranslator, FilterExpressions, sortExpressions, SkipValue, TakeValue);
return(query);
}
/// <summary>
/// Performs a subsequent ordering of the elements in a sequence in descending order, according to a key.
/// </summary>
/// <param name="sortExpression">A sort expression to extract a key from each element and define a sort direction.</param>
/// <returns>A new query instance containing all specified query parameters.</returns>
IOrderedQuery IOrderedQuery.ThenByDescending(SortExpression sortExpression)
{
if (!SortExpressions.Any())
{
throw new InvalidOperationException("No sorting defined yet, use OrderBy or OrderByDescending first.");
}
if (sortExpression.SortDirection != SortDirection.Descending)
{
throw new ArgumentException("Expected sort expresson to be descending.");
}
var sortExpressions = SortExpressions.ToList();
sortExpressions.Add(sortExpression);
var query = new Query(Type, FilterExpressions, sortExpressions, SkipValue, TakeValue);
return(query);
}
/// <summary>
/// Pulizia delle espressioni di ordinamento
/// </summary>
public virtual void SortExpressionsClear()
{
SortExpressions.Clear();
}
