public EntityCollection<CatalogsEntity> GetAllParent(SortExpression sort)
{
EntityCollection<CatalogsEntity> cats = new EntityCollection<CatalogsEntity>();
SortExpression _sort = new SortExpression();
if (sort != null)
{
_sort = sort;
}
else
{
_sort.Add(CatalogsFields.CatalogName | SortOperator.Ascending);
}
IPredicateExpression predicate = new PredicateExpression();
predicate.Add(CatalogsFields.ParentId == 0);
predicate.AddWithAnd(CatalogsFields.IsVisible == true);
RelationPredicateBucket filter = new RelationPredicateBucket();
filter.PredicateExpression.Add(predicate);
using (DataAccessAdapterBase adapter = new DataAccessAdapterFactory().CreateAdapter())
{
adapter.FetchEntityCollection(cats, filter, 0, _sort);
}
return cats;
}
/// <summary>
/// Gets the customer with the most orders and also the customers' number of orders.
/// </summary>
/// <param name="numberOfOrders">The number of orders.</param>
/// <returns>the CustomerEntity with the most orders and also the number of orders of this customer</returns>
/// <remarks>No error checking is applied to this routine, it's for illustrating the framework functionality.</remarks>
public CustomerEntity GetCustomerWithMostOrdersAndNumberOfOrders(out int numberOfOrders)
{
Console.WriteLine("GetCustomerWithMostOrdersAndNumberOfOrders called");
CustomerEntity toReturn = null;
using (DataAccessAdapter adapter = new DataAccessAdapter())
{
// create a list to obtain the customerid + # of orders. We'll just fetch the 1st row, ordering on the # of orders.
ResultsetFields orderCustomerFields = new ResultsetFields(2);
orderCustomerFields.DefineField(OrderFields.CustomerId, 0, "CustomerId");
orderCustomerFields.DefineField(OrderFields.OrderId, 1, "NumberOfOrders", "", AggregateFunction.Count);
GroupByCollection groupBy = new GroupByCollection();
groupBy.Add(orderCustomerFields[0]);
SortExpression sorter = new SortExpression();
sorter.Add(new SortClause(orderCustomerFields[1], null, SortOperator.Descending));
// now fetch the list, specify to fetch just 1 row, ordered descending on amount
DataTable orderCustomer = new DataTable();
adapter.FetchTypedList(orderCustomerFields, orderCustomer, null, 1, sorter, true, groupBy);
numberOfOrders = (int)orderCustomer.Rows[0]["NumberOfOrders"];
// we'll assume the data was there, so there is a row.
toReturn = new CustomerEntity(orderCustomer.Rows[0]["CustomerId"].ToString());
adapter.FetchEntity(toReturn);
}
return(toReturn);
}
/// <summary>
/// CTor
/// </summary>
public CustomersByProduct()
{
InitializeComponent();
// construct filter, which will span multiple entities.
_relationsToWalk = new RelationCollection();
// Start with the entity you want to retrieve...
_relationsToWalk.Add(CustomerEntity.Relations.OrderEntityUsingCustomerId);
_relationsToWalk.Add(OrderEntity.Relations.OrderDetailEntityUsingOrderId);
_relationsToWalk.Add(OrderDetailEntity.Relations.ProductEntityUsingProductId); // ... and end with the entity you want to use in your filter...
// create the predicate 'Product.ProductId == value', we will fill in the value later.
_productFilter = (FieldCompareValuePredicate)(ProductFields.ProductId == 0);
////////////////
// Another way of doing the same query is through the FieldCompareSetPredicate class. The amount of data in Northwind is fairly small,
// so the filter with the relations will perform rather quickly. However with loads of data in the database, a FieldCompareSetPredicate class
// can be much more efficient. See the documentation (Filtering and Sorting) for details about this class.
///////////////
// load products, sort them on ProductName asc
ISortExpression productSorter = new SortExpression(ProductFields.ProductName | SortOperator.Ascending);
ProductCollection products = new ProductCollection();
products.GetMulti(null, 0, productSorter);
// bind it to the combo box
productSelectComboBox.DataSource = products;
productSelectComboBox.DisplayMember = "ProductName";
productSelectComboBox.SelectedIndex = 0;
_customerSorter = new SortExpression(CustomerFields.CompanyName | SortOperator.Ascending);
}
public void SortExpression_WithNullColumns_ReturnsSameNumberElemsAsQuery()
{
int number = 100;
var query = QueryTestHelper.FormTestData((x, i) => x.IntProp = i, number);
var sortexpr = new SortExpression<TestClass>(t => t.StringProp);
Assert.Equal(number, sortexpr.Map(query).Count());
}
public static IOrderedQueryable <T> ThenBy <T>(
this IQueryable <T> source,
SortExpression sortExpression)
{
return(OrderingHelper(
source, sortExpression.Expression, sortExpression.Direction, true));
}
public AdminSitesCollection GetAdminSites(int siteUserGuid)
{
MCB.MasterPiece.Data.CollectionClasses.AdminSitesCollection adminSites = new AdminSitesCollection();
IRelationCollection relations = new RelationCollection();
relations.Add(AdminSitesEntity.Relations.AdminSiteModuleEntityUsingSiteGuid);
relations.Add(AdminSiteModuleEntity.Relations.AdminUserAccessEntityUsingSiteModuleGuid);
relations.Add(AdminUserAccessEntity.Relations.AdminUserEntityUsingUserGuid);
IPredicateExpression filter = new PredicateExpression();
filter.Add(AdminUserAccessFields.UserGuid == siteUserGuid);
filter.AddWithAnd(AdminSitesFields.AccountingMarkAsInactive != 1);
IPredicateExpression sensitiveDataFilter = new PredicateExpression();
sensitiveDataFilter.Add(AdminUserFields.HasAccessToSitesWithSensitiveData == 1);
sensitiveDataFilter.AddWithOr(AdminSitesFields.SiteContainsSensitiveData == 0);
filter.AddWithAnd(sensitiveDataFilter);
ISortExpression sort = new SortExpression();
sort.Add(AdminSitesFields.CostumerFullname | SortOperator.Ascending);
adminSites.GetMulti(filter, 0, sort, relations);
return(adminSites);
}
// This is a helper method used to add a sort direction image to the header of the column being sorted.
public void AddSortImage(int columnIndex, GridViewRow row)
{
// Create the sorting image based on the sort direction.
Image sortImage = new Image();
string sortdirec = "";
if (SortDirection == "asc")
{
sortdirec = "Ascending";
}
else if (SortExpression.Contains("desc"))
{
sortdirec = "Decending";
}
if (Convert.ToString(gvImportjob.SortDirection) == sortdirec)
{
sortImage.ImageUrl = "img/table/sort_asc.png";
}
else
{
sortImage.ImageUrl = "img/table/sort_desc.png";
}
// Add the image to the appropriate header cell.
row.Cells[columnIndex].Controls.Add(sortImage);
}
/// <summary>
/// Gets the current sort expression list
/// </summary>
public List <ISortExpression> GetSortExpressions()
{
List <ISortExpression> sortExpressions = new List <ISortExpression>();
if (SortExpression != string.Empty)
{
// Don't split the sort expression when it contains "dbo.", as this means it is a function
// and might have be taking multiple values. This still needs improvement though, as it would
// break if we're mixing sort expressions to use a function and a column name.
// For example: dbo.MyFunction(Col1,Col2),Col3 wouldn't work correctly.
string[] array = (SortExpression.Contains("dbo.")) ? new[] { SortExpression } : SortExpression.Split(',');
foreach (string sortExpression in array)
{
if (SortAscending)
{
sortExpressions.Add(new AscendingSort(sortExpression));
}
else
{
sortExpressions.Add(new DescendingSort(sortExpression));
}
}
}
return(sortExpressions);
}
private static SortExpression ConvertStringToSortExpression(string sortStr, Func <string, IEntityField2> fieldGetter)
{
var sortExpression = new SortExpression();
if (!string.IsNullOrEmpty(sortStr))
{
var sortClauses = sortStr.Split(new[] { ';', ',' }, StringSplitOptions.None);
foreach (var sortClause in sortClauses)
{
var sortClauseElements = sortClause.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
var sortField = fieldGetter(sortClauseElements[0]);
if (sortField == null)
{
continue;
}
sortExpression.Add(new SortClause(
sortField, null,
sortClauseElements.Length > 1 &&
sortClauseElements[1].Equals("desc",
StringComparison.OrdinalIgnoreCase)
? SortOperator.Descending
: SortOperator.Ascending
));
}
}
return(sortExpression);
}
public void Should_FromString_Return_SortExpression_Instance_With_Supported_Descending_Formats(string sorting)
{
var result = SortExpression.FromString(sorting);
result.ShouldNotBeNull();
result.Descending.ShouldBeTrue();
}
/// <summary>
///获取分页数据
/// </summary>
/// <param name="pageIndex">页码</param>
/// <param name="pageCount">页大小</param>
/// <param name="specification">条件</param>
/// <param name="orderByExpressions">是否排序</param>
/// <returns>实体的分页数据</returns>
public PagedList <TEntity> GetPaged(int pageIndex, int pageCount, IDynamicSpecification <TEntity> specification,
SortExpression <TEntity> orderByExpressions = null)
{
if (orderByExpressions == null || !orderByExpressions.IsNeedSort())
{
orderByExpressions = new SortExpression <TEntity>(new List <EditableKeyValuePair <Expression <Func <TEntity, dynamic> >, bool> >
{
new EditableKeyValuePair <Expression <Func <TEntity, dynamic> >, bool>(item => item.Id, false),
});
}
if (pageIndex == 0)
{
pageIndex = 1;
}
//如果动态路由可用则为单库
if (!string.IsNullOrEmpty(specification.Coden))
{
var set = DynamicGetAll(specification);
//如果找到了单库
if (set != null)
{
var queryable = set.Where(specification.SatisfiedBy());
int totel = queryable.Count();
IEnumerable <TEntity> items = orderByExpressions.BuildSort(queryable).Skip(pageCount * (pageIndex - 1)).Take(pageCount);
return(new PagedList <TEntity>(totel, pageCount, pageIndex, items.ToList()));
}
}
//如果找不到单库
int sum = 0;
List <IQueryable <TEntity> > entities = new List <IQueryable <TEntity> >();
foreach (var tmp in DbFactory.GetDynamicDbConfigs(typeof(TEntity)))
{
var queryable = DynamicGetAll(new SampleRouter(tmp.DynamicCoden)).Where(specification.SatisfiedBy());
sum += queryable.Count();
entities.Add(queryable);
}
int newDataIndex = (pageIndex + 1) * pageCount;
//如果在中值之后则反转排序
if (sum < pageIndex * pageCount * 2 && pageIndex * pageCount > sum)
{
orderByExpressions.Reverse();
//反转页码
newDataIndex = sum - pageIndex * pageCount;
var datas = entities.SelectMany(item => orderByExpressions.BuildSort(item).Take(newDataIndex)).ToList();
orderByExpressions.Reverse();
datas = orderByExpressions.BuildSort(datas).Skip(0).Take(pageCount).ToList();
return(new PagedList <TEntity>(sum, pageCount, pageIndex, datas.ToList()));
}
else
{
var datas = entities.SelectMany(item => orderByExpressions.BuildSort(item).Take(newDataIndex))
.Skip(pageCount * (pageIndex - 1)).Take(pageCount).ToList();
return(new PagedList <TEntity>(sum, pageCount, pageIndex, datas.ToList()));
}
}
/// <summary>
/// Efficient pageing for grid.
/// </summary>
/// <param name="pageNumber">Must be greater than zero.</param>
/// <param name="sortDirection">Validne vrijednosti su 'asc' i 'desc'.</param>
public static EntityCollection <PartnerEntity> FetchPartnerCollectionForPaging(DataAccessAdapterBase adapter,
RelationPredicateBucket bucket,
PrefetchPath2 prefetchPath,
int pageNumber,
int pageSize,
string sortField,
bool isSortAscending)
{
string sortDirection = isSortAscending ? "asc" : "desc";
Type sortEntityFieldType = typeof(PartnerFields);
string sortEntityFieldTypeName = SortHelper.GetEntityFieldTypeNameForSorting(sortField, sortEntityFieldType);
if (!string.IsNullOrWhiteSpace(sortEntityFieldTypeName))
{
sortEntityFieldType = Type.GetType(sortEntityFieldTypeName);
}
sortField = SortHelper.GetSortField(sortField);
SortExpression sort = SortHelper.GetSortExpression(sortField, sortDirection, sortEntityFieldType);
EntityCollection <PartnerEntity> toReturn = new EntityCollection <PartnerEntity>(new PartnerEntityFactory());
adapter.FetchEntityCollection(toReturn, bucket, pageSize, sort, prefetchPath, pageNumber, pageSize);
return(toReturn);
}
/*protected void dgAddEditMLs_PageIndexChanged(object sender, DataGridPageChangedEventArgs e)
* {
* this.PopulateML(false, -1, e.NewPageIndex);
* }*/
protected void dgAddEditMLs_SortCommand(object sender, DataGridSortCommandEventArgs e)
{
string sortDirection = String.Empty;
if (!SortExpression.ToUpper().StartsWith(e.SortExpression) && !SortExpression.ToUpper().Trim().EndsWith("ASC"))
{
sortDirection = " asc";
}
else
{
sortDirection = (SortExpression.ToUpper().EndsWith("DESC")) ? " asc" : " desc";
}
this.SortExpression = e.SortExpression + sortDirection;
this.PopulateML(false);
foreach (DataGridColumn col in this.dgAddEditMLs.Columns)
{
if (col.Visible && col.SortExpression == e.SortExpression)
{
col.HeaderStyle.CssClass = "selected " + ((sortDirection.ToUpper() != " DESC") ? "sortDown" : "sortUp");
}
else
{
col.HeaderStyle.CssClass = ((col.HeaderStyle.CssClass == "hide") ? "hide" : string.Empty);
}
}
}
public void GetCompanyInfoList()
{
ConditionExpression ce = null;
QueryCondition qc = new QueryCondition();
ce = new ConditionExpression();
ce.ExpName = "PreCode";
ce.ExpValue = "10";
ce.ExpOperater = eConditionOperator.Equal;
ce.ExpLogical = eLogicalOperator.And;
qc.ConditionList.Add(ce);
ce = new ConditionExpression();
ce.ExpName = "Type";
ce.ExpValue = "Owner";
ce.ExpOperater = eConditionOperator.NotEqual;
ce.ExpLogical = eLogicalOperator.Or;
qc.ConditionList.Add(ce);
SortExpression sort = new SortExpression("PreCode", eSortType.Asc);
qc.SortList.Add(sort);
qc.PageInfo.isAllowPage = false;
Result <List <Base_Company> > result = new Result <List <Base_Company> >();
using (AdminClientProxy proxy = new AdminClientProxy(ProxyEx(Request)))
{
result = proxy.GetCompanyList(qc);
ViewBag.CompanyId = result.Data.ToSelectList("Name", "Id", true);
}
}
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))));
}
//Please write your properties and functions here. This part will not be replaced.
/// <summary>
/// Gets list of doctors by its phone number
/// </summary>
/// <param name="phoneNumber"></param>
/// <returns></returns>
public IList <vDoctor> SearchByClinicPhoneNumber(DoctorSearchByClinicPhoneNumberSP p)
{
string searchablePhoneNumber = UTD.Tricorder.Common.PhoneNumberUtils.MakeSearchablePhoneNumber(p.PhoneNumber);
if (string.IsNullOrEmpty(searchablePhoneNumber) == false)
{
FilterExpression filter = new FilterExpression();
filter.AddFilter(vDoctor.ColumnNames.ClinicPhoneNumberSearchable, searchablePhoneNumber, FilterOperatorEnum.Contains);
SortExpression sort = new SortExpression(vDoctor.ColumnNames.LastName);
List <string> columns = new List <string>();
columns.Add(vDoctor.ColumnNames.NamePrefix);
columns.Add(vDoctor.ColumnNames.FirstName);
columns.Add(vDoctor.ColumnNames.LastName);
columns.Add(vDoctor.ColumnNames.ClinicPhoneNumber);
columns.Add(vDoctor.ColumnNames.ClinicAddress);
columns.Add(vDoctor.ColumnNames.DoctorID);
return(GetByFilterV(new GetByFilterParameters(filter, sort, 0, 10, columns, GetSourceTypeEnum.View)));
}
else
{
return(new List <vDoctor>());
}
}
public static SalesOrderHeaderCollection GetSalesOrderHeaderCollection
(
DateTime FromDate,
DateTime ToDate,
string FirstName,
string LastName,
int OrderID,
string OrderNumber,
string CityName,
string StateName,
string CountryName,
string Zip,
int maxNumberOfItemsToReturn,
bool prefetch
)
{
var relations = new RelationCollection();
var Filter = SalesOrderHeaderFilters.FilterByDateOrderIDOrderNumberCustomerNameAddress(relations, FromDate, ToDate, OrderID, OrderNumber, FirstName, LastName, CityName, StateName, CountryName, Zip);
ISortExpression Sort = new SortExpression {
SalesOrderHeaderFields.OrderDate | SortOperator.Ascending
};
var Orders = new SalesOrderHeaderCollection();
//note Orders.SupportsSorting = true;
IPrefetchPath Prefetch = prefetch ? new PrefetchPath((int)EntityType.SalesOrderHeaderEntity)
{
SalesOrderHeaderEntityBase.PrefetchPathCustomerViewRelated
} : null;
Orders.GetMulti(Filter, maxNumberOfItemsToReturn, Sort, relations, Prefetch);
return(Orders);
}
/// <summary>
/// Gets the pending notification list.
/// </summary>
/// <returns></returns>
public static List <vNotification> GetPendingNotificationList()
{
INotificationService service = (INotificationService)EntityFactory.GetEntityServiceByName(
vNotification.EntityName, "");
FilterExpression filterEmail = new FilterExpression();
filterEmail.AddFilter(new Filter(vNotification.ColumnNames.EmailNotificationStatusID, (int)EntityEnums.NotificationStatusEnum.Pending));
filterEmail.AddFilter(new Filter(vNotification.ColumnNames.IsEmail, true));
filterEmail.AddFilter(new Filter(vNotification.ColumnNames.ReceiverUserEmail, null, FilterOperatorEnum.NotIsNull));
FilterExpression filterSMS = new FilterExpression();
filterSMS.AddFilter(new Filter(vNotification.ColumnNames.SMSNotificationStatusID, (int)EntityEnums.NotificationStatusEnum.Pending));
filterSMS.AddFilter(new Filter(vNotification.ColumnNames.IsSMS, true));
filterSMS.AddFilter(new Filter(vNotification.ColumnNames.ReceiverUserPhoneNumber, null, FilterOperatorEnum.NotIsNull));
FilterExpression filter = new FilterExpression();
filter.AddFilterExpression(filterEmail);
filter.AddFilterExpression(filterSMS);
filter.LogicalOperator = FilterLogicalOperatorEnum.OR;
SortExpression sort = new SortExpression(vNotification.ColumnNames.InsertDate, SortDirectionEnum.ASC);
int numberOfNotifies = 100;
List <vNotification> notificationList = (List <vNotification>)
service.GetByFilter(new GetByFilterParameters(filter, sort, 0, numberOfNotifies, null, GetSourceTypeEnum.View));
return(notificationList);
}
///// <summary>
///// Get available times in format for an specific date
///// </summary>
///// <param name="p">parameters</param>
///// <returns></returns>
//public IList<vDoctorSchedule> GetTimesByRange(DoctorScheduleGetByRangeSP p)
//{
// List<string> columns = new List<string>();
// columns.Add(vDoctorSchedule.ColumnNames.DoctorScheduleID);
// columns.Add(vDoctorSchedule.ColumnNames.SlotUnixEpoch);
// return GetByRangeWithColumns(p, null);
//}
private IList <vDoctorSchedule> GetByRangeWithColumns(DoctorScheduleGetByRangeSP p, List <string> columns)
{
FilterExpression filter = GetByRangeFilter(p);
filter.AndMerge(new FilterExpression(vDoctorSchedule.ColumnNames.NumberOfFreePositions, 0, FilterOperatorEnum.GreaterThan));
SortExpression sort = new SortExpression(vDoctorSchedule.ColumnNames.SlotUnixEpoch);
if (columns != null)
{
if (columns.Contains(vDoctorSchedule.ColumnNames.NumberOfAllowedPatients))
{
columns.Add(vDoctorSchedule.ColumnNames.NumberOfAllowedPatients);
}
if (columns.Contains(vDoctorSchedule.ColumnNames.NumberOfRegisteredPatients))
{
columns.Add(vDoctorSchedule.ColumnNames.NumberOfRegisteredPatients);
}
}
GetByFilterParameters getParams = new GetByFilterParameters(filter, sort, 0, 1000, columns, GetSourceTypeEnum.View);
IList <vDoctorSchedule> list = GetByFilterV(getParams);
return(list);
// we filter the list from database to speed up the process.
//List<vDoctorSchedule> results = new List<vDoctorSchedule>();
//foreach (var item in list)
//{
// if (item.NumberOfAllowedPatients > item.NumberOfRegisteredPatients)
// results.Add(item);
//}
//return results;
}
private int GetSortColumnIndex()
{
// Iterate through the Columns collection to determine the index of the column being sorted.
foreach (DataControlField field in gvImportjob.Columns)
{
if (field.SortExpression != "" && field.SortExpression != null)
{
string sortexp = "";
if (SortExpression.Contains("asc"))
{
sortexp = SortExpression.Replace("asc", "");
}
else if (SortExpression.Contains("desc"))
{
sortexp = SortExpression.Replace("desc", "");
}
if (field.SortExpression.ToString().ToLower() == sortexp.ToLower().Trim())
{
return(gvImportjob.Columns.IndexOf(field));
}
}
}
return(-1);
}
private static IOrderedEnumerable <T> Sort <T>(IEnumerable <T> collection, SortExpressionCollection sortExpressions)
{
IOrderedEnumerable <T> result = null;
if (sortExpressions[0].Order == SortExpression.ORDER.ASC)
{
result = collection.OrderBy(s => GetPropertySort(s, sortExpressions[0].PropertyName));
}
else
{
result = collection.OrderByDescending(s => GetPropertySort(s, sortExpressions[0].PropertyName));
}
for (int i = 1; i < sortExpressions.Count; i++)
{
SortExpression sort = sortExpressions[i];
if (sort.Order == SortExpression.ORDER.ASC)
{
result = result.ThenBy(s => GetPropertySort(s, sort.PropertyName));
}
else
{
result = result.ThenByDescending(s => GetPropertySort(s, sort.PropertyName));
}
}
return(result);
}
/// <summary>
/// İlgili manager'ın entity'lerine ulaşmak için gereken path'i, parametre kullanarak oluşturmalı.
/// </summary>
/// <param name="p">Parametre</param>
/// <param name="path">PathElement, rootPath değil. Bu metod başka manager'dan çağırıldığından, rootPath başka manager'da olacaktır. Bu metod pathElement üretir.</param>
/// <returns></returns>
public IPrefetchPathElement2 GetPathElement(TParameter p, IPrefetchPathElement2 path)
{
IPredicateExpression filterPredicateExpression = new PredicateExpression();
//Filtering
PrepareFilter(p, ref filterPredicateExpression);
path.Filter = filterPredicateExpression;
//Relations
//PrepareRelations(p, path.FilterRelations);
//Sort
ISortExpression sortExpression = new SortExpression();
PrepareSortExpression(p, ref sortExpression);
path.Sorter = sortExpression;
//SubPaths
var subPath = new PrefetchPath2(EntityTypeEnumValue);
if (p.PathsFunc != null)
{
p.PathsFunc.Invoke(subPath);
}
//PrepareSubPaths(p, ref subPath);
path.SubPath = subPath;
return(path);
}
protected virtual SortExpression GetSort(IReadOnlyCollection <QueryExpression> expressionsInScope, ResourceContext resourceContext)
{
if (expressionsInScope == null)
{
throw new ArgumentNullException(nameof(expressionsInScope));
}
if (resourceContext == null)
{
throw new ArgumentNullException(nameof(resourceContext));
}
var sort = expressionsInScope.OfType <SortExpression>().FirstOrDefault();
var resourceDefinition = _resourceDefinitionProvider.Get(resourceContext.ResourceType);
if (resourceDefinition != null)
{
sort = resourceDefinition.OnApplySort(sort);
}
if (sort == null)
{
var idAttribute = resourceContext.Attributes.Single(x => x.Property.Name == nameof(Identifiable.Id));
sort = new SortExpression(new[] { new SortElementExpression(new ResourceFieldChainExpression(idAttribute), true) });
}
return(sort);
}
public void SortExpression_WithOneColumn_ReturnsTheSampleEnumerableBackwards()
{
var query = QueryTestHelper.FormTestData((x, i) => x.IntProp = i, 10);
var back = QueryTestHelper.FormTestData((x, i) => x.IntProp = i, 10).Reverse();
var sortexpr = new SortExpression<TestClass>(new string[] { "IntProp" }, true);
Assert.Equal(back.ToList()[0].IntProp, sortexpr.Map(query).ToList()[0].IntProp);
}
/// <summary>
/// Constructs a TypedList with all the messages in the thread given. Poster info is included, so the
/// returned dataview is bindable at once to the message list repeater.
/// </summary>
/// <param name="threadID">ID of Thread which messages should be returned</param>
/// <param name="pageNo">The page no.</param>
/// <param name="pageSize">Size of the page.</param>
/// <returns>TypedList with all messages in the thread for the page specified</returns>
public static MessagesInThreadTypedList GetAllMessagesInThreadAsTypedList(int threadID, int pageNo, int pageSize)
{
// we'll use a typedlist, MessagesInThread to pull the necessary data from the db. The typedlist contains fields from
// message, user and usertitle.
MessagesInThreadTypedList messages = new MessagesInThreadTypedList();
//create the filter with the threadID passed to the method.
PredicateExpression filter = new PredicateExpression(MessageFields.ThreadID == threadID);
// Sort Messages on posting date, ascending, so the first post is located on top.
SortExpression sorter = new SortExpression(MessageFields.PostingDate.Ascending());
// fetch the data into the typedlist. Pass in the paging information as well, to perform server-side paging.
messages.Fill(0, sorter, true, filter, null, null, pageNo, pageSize);
// update thread entity directly inside the DB with a non-transactional update statement so the # of views is increased by one.
ThreadEntity updater = new ThreadEntity();
// set the NumberOfViews field to an expression which increases it by 1
updater.Fields[(int)ThreadFieldIndex.NumberOfViews].ExpressionToApply = (ThreadFields.NumberOfViews + 1);
updater.IsNew = false;
// update the entity directly, and filter on the PK
ThreadCollection threads = new ThreadCollection();
threads.UpdateMulti(updater, (ThreadFields.ThreadID == threadID));
// return the constructed typedlist
return(messages);
}
private Expression ApplySort(Expression source, SortExpression sort)
{
using var lambdaScope = _lambdaScopeFactory.CreateScope(_elementType);
var builder = new OrderClauseBuilder(source, lambdaScope, _extensionType);
return(builder.ApplyOrderBy(sort));
}
public void SortInfoListTest()
{
SortExpression target = new SortExpression();
ICollection <SortInfo> actual;
actual = target.SortInfoList;
Assert.AreNotEqual(target.SortInfoList, null);
}
/// <inheritdoc />
public SortExpression OnApplySort(Type resourceType, SortExpression existingSort)
{
ArgumentGuard.NotNull(resourceType, nameof(resourceType));
dynamic resourceDefinition = ResolveResourceDefinition(resourceType);
return(resourceDefinition.OnApplySort(existingSort));
}
internal EntityCollection <TEntity> Fetch(IDataAccessAdapter adapter, SortExpression sortExpression,
ExcludeIncludeFieldsList excludedIncludedFields,
IPrefetchPath2 prefetchPath, IRelationPredicateBucket predicateBucket,
int pageNumber,
int pageSize, int limit, out int totalItemCount)
{
return(Fetch(adapter, sortExpression, excludedIncludedFields, prefetchPath, predicateBucket, pageNumber,
pageSize, limit, 0, out totalItemCount));
}
public void GetSortExpressionStringTest()
{
SortExpression target = new SortExpression();
string expected = string.Empty;
string actual;
actual = target.GetSortExpressionString();
Assert.AreEqual(expected, actual);
}
public Expression ApplyOrderBy(SortExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
return(Visit(expression, null));
}
/// <summary>
/// Gets data by doctor id
/// </summary>
/// <param name="DoctorID">doctor identifier</param>
/// <returns></returns>
public IList <vDoctor_Specialty> GetByDoctorID(long DoctorID)
{
FilterExpression filter = new FilterExpression();
filter.AddFilter(vDoctor_Specialty.ColumnNames.DoctorID, DoctorID);
SortExpression sort = new SortExpression(vDoctor_Specialty.ColumnNames.SpecialtyTitle);
return(GetByFilterV(new GetByFilterParameters(filter, sort, 0, int.MaxValue, null, GetSourceTypeEnum.View)));
}
protected virtual ISortExpression <TEntity, TId> GetSortExpression(TQuery request)
{
var sortExpression = new SortExpression <TEntity, TId>();
// Add rules and possible sorts discovered by reflection for type TQuery
_sortService.AddSort <TQuery, TEntity>(sortExpression);
return(sortExpression);
}
public SelectList allAttributes(object selObjId)
{
if (m_allAttributes == null)
{
m_allAttributes = new AttributeCollection();
SortExpression se = new SortExpression(AttributeFields.Name | SortOperator.Ascending);
m_allAttributes.GetMulti(null, 0, se);
}
SelectList selList = new SelectList(m_allAttributes, "Id", "Name", selObjId);
return selList;
}
public SelectList subjectAttributes(object selObjId)
{
if (m_subjectAttributes == null)
{
m_subjectAttributes = new AttributeCollection();
RelationCollection rels = new RelationCollection(AttributeEntity.Relations.ContextEntityUsingContextId);
PredicateExpression pe = new PredicateExpression(ContextFields.Name == "subject");
SortExpression se = new SortExpression(AttributeFields.Name | SortOperator.Ascending);
m_subjectAttributes.GetMulti(pe, 0, se, rels);
}
SelectList selList = new SelectList(m_subjectAttributes, "Id", "Name", selObjId);
return selList;
}
public static TrgovanjeGlavaEntity FetchTrgovanjeGlavaForGuiDisplay(DataAccessAdapterBase adapter, DateTime date)
{
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(TrgovanjeGlavaFields.Datum <= date.Date);
SortExpression sort = new SortExpression(TrgovanjeGlavaFields.Datum | SortOperator.Descending);
EntityCollection<TrgovanjeGlavaEntity> trgovanjeGlavaCollection = new EntityCollection<TrgovanjeGlavaEntity>(new TrgovanjeGlavaEntityFactory());
adapter.FetchEntityCollection(trgovanjeGlavaCollection, bucket, 1, sort);
if (0 == trgovanjeGlavaCollection.Count)
{
sort = new SortExpression(TrgovanjeGlavaFields.Datum | SortOperator.Ascending);
adapter.FetchEntityCollection(trgovanjeGlavaCollection, null, 1, sort);
}
return FetchTrgovanjeGlavaForGuiDisplay(adapter, trgovanjeGlavaCollection.Single().TrgovanjeGlavaId);
}
public RacunViewModel(DataAccessAdapterBase adapter, long? racunGlavaId)
{
if (racunGlavaId.HasValue && racunGlavaId.Value > 0)
{
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.RacunGlavaEntity);
SortExpression racunStavkaSort = new SortExpression(RacunStavkaFields.Pozicija | SortOperator.Ascending);
prefetchPath.Add(RacunGlavaEntity.PrefetchPathRacunStavkaCollection, 0, null, null, racunStavkaSort).
SubPath.Add(RacunStavkaEntity.PrefetchPathArtikl);
this.RacunGlava = RacunGlavaEntity.FetchRacunGlava(adapter, prefetchPath, racunGlavaId.Value);
this.RacunStavkaCollection = this.RacunGlava.RacunStavkaCollection;
}
else
{
this.RacunGlava = new RacunGlavaEntity();
this.RacunGlava.Datum = DateTime.Now;
this.RacunStavkaCollection = new List<RacunStavkaEntity>();
}
}
public Document[] GetLibraryDocuments(string libraryName)
{
List<Document> docs = new List<Document>();
PolicyDocumentCollection policyDocuments = new PolicyDocumentCollection();
RelationCollection rels = new RelationCollection(PolicyDocumentEntity.Relations.LibraryEntityUsingLibraryId);
PredicateExpression pe = new PredicateExpression(LibraryFields.Name == libraryName);
SortExpression se = new SortExpression(PolicyDocumentFields.Name | SortOperator.Ascending);
policyDocuments.GetMulti(pe, 0, se, rels);
foreach (PolicyDocumentEntity doc in policyDocuments)
{
Document wdoc = new Document();
wdoc.Name = doc.Name;
wdoc.Id = doc.Id;
docs.Add(wdoc);
}
return docs.ToArray();
}
public CustomersEntity GetByName(string CustomerName)
{
EntityCollection<CustomersEntity> cus = new EntityCollection<CustomersEntity>();
IPredicateExpression predicate = new PredicateExpression();
predicate.Add(CustomersFields.UserName == CustomerName);
//predicate.AddWithAnd(CustomersFields.Telphone == "");
RelationPredicateBucket filter = new RelationPredicateBucket();
filter.PredicateExpression.Add(predicate);
SortExpression sort = new SortExpression();
sort.Add(CustomersFields.UserName | SortOperator.Ascending);
using (DataAccessAdapterBase adapter = new DataAccessAdapterFactory().CreateAdapter())
{
adapter.FetchEntityCollection(cus, filter, 0, sort);
}
if (cus != null && cus.Count > 0)
return cus[0];
return null;
}
public EntityCollection<CatalogsEntity> GetByParentIdNotId(int Id, int ParentId)
{
EntityCollection<CatalogsEntity> cats = new EntityCollection<CatalogsEntity>();
SortExpression _sort = new SortExpression();
_sort.Add(CatalogsFields.CatalogName | SortOperator.Ascending);
IPredicateExpression predicate = new PredicateExpression();
predicate.Add(CatalogsFields.ParentId == ParentId);
predicate.AddWithAnd(CatalogsFields.Id != Id);
RelationPredicateBucket filter = new RelationPredicateBucket();
filter.PredicateExpression.Add(predicate);
using (DataAccessAdapterBase adapter = new DataAccessAdapterFactory().CreateAdapter())
{
adapter.FetchEntityCollection(cats, filter, 0, _sort);
}
return cats;
}
public ProductCollection GetSpeacialProducts()
{
ProductCollection specialProducts = new ProductCollection();
PredicateExpression filter = new PredicateExpression(ProductFields.IsSpeacialProduct == true);
filter.Add(ProductFields.Status == true);
SortExpression sorter = new SortExpression();
sorter.Add(ProductFields.AddedDate | SortOperator.Descending);
specialProducts.GetMulti(filter,6,sorter);
return specialProducts;
}
/// <summary>
/// Retrieves a list of groups matching the criteria specified via method parameters.
/// </summary>
/// <param name="category">Category name.</param>
/// <param name="categoryId">Category Id</param>
/// <param name="pageNumber">Page number.</param>
/// <param name="pageSize">Page size.</param>
/// <param name="recordCount">Record count.</param>
/// <returns>List of groups.</returns>
public List<MonoSoftware.MonoX.Repositories.SnGroupDTO> GetPopularGroups(string category, Guid categoryId, int pageNumber, int pageSize, out int recordCount)
{
RelationPredicateBucket filter = new RelationPredicateBucket();
//introduced to filter out groups by languages and applications
filter.Relations.Add(SnGroupEntity.Relations.SnGroupCategoryEntityUsingGroupCategoryId, JoinHint.Left);
//Note: MonoX supports the multi application environment so general filter for all DB access calls should contain the application id filter
filter.PredicateExpression.Add(SnGroupCategoryFields.ApplicationId == MonoSoftware.MonoX.Repositories.MembershipRepository.GetInstance().GetApplicationId());
//Note: MonoX in supports the multi language environment so general filter for all DB access calls should contain the language id filter
filter.PredicateExpression.Add(SnGroupCategoryFields.LanguageId == LocalizationUtility.GetCurrentLanguageId());
//Filter groups by category
if (categoryId != Guid.Empty)
{
filter.PredicateExpression.Add(SnGroupFields.GroupCategoryId == categoryId);
}
if (!String.IsNullOrEmpty(category))
{
filter.PredicateExpression.Add(SnGroupCategoryFields.Slug == category);
}
IPrefetchPath2 prefetch = new PrefetchPath2((int)EntityType.SnGroupEntity);
prefetch.Add(SnGroupEntity.PrefetchPathSnGroupCategory);
//Fetch a record from the members table only for the current user so his status could be read
Guid uid = SecurityUtility.GetUserId();
if (!Guid.Empty.Equals(uid))
{
PredicateExpression memberFilter = new PredicateExpression(SnGroupMemberFields.UserId == uid);
prefetch.Add(SnGroupEntity.PrefetchPathSnGroupMembers, 1, memberFilter);
}
#region Popular groups sorter
const string memberCountField = "MemberCountField";
const string memberCountTableName = "MemberCountTable";
EntityFields2 memberFields = new EntityFields2(2);
memberFields.DefineField(SnGroupMemberFields.GroupId, 0);
memberFields.DefineField(SnGroupMemberFields.Id, 1, memberCountField, AggregateFunction.Count);
DerivedTableDefinition memberCountTable = new DerivedTableDefinition(memberFields, memberCountTableName, null, new GroupByCollection(memberFields[0]));
IDynamicRelation memberCountRelation = new DynamicRelation(memberCountTable, JoinHint.Right, MonoSoftware.MonoX.DAL.EntityType.SnGroupEntity, String.Empty, SnGroupMemberFields.GroupId.SetObjectAlias(memberCountTable.Alias) == SnGroupFields.Id);
filter.Relations.Add(memberCountRelation);
ISortExpression sorter = new SortExpression(new SortClause(new EntityField2(memberCountField, null).SetObjectAlias(memberCountTableName), null, SortOperator.Descending));
#endregion
EntityCollection<SnGroupEntity> groups = new EntityCollection<SnGroupEntity>();
//Fetch the group collection
FetchEntityCollection(groups, filter, 0, sorter, prefetch, pageNumber, pageSize);
//Fetch the group total count used by paging
recordCount = GetDbCount(groups, filter);
//Transfer group entities to the DTO
List<MonoSoftware.MonoX.Repositories.SnGroupDTO> toReturn = groups.Select(group => new MonoSoftware.MonoX.Repositories.SnGroupDTO(group)).ToList<MonoSoftware.MonoX.Repositories.SnGroupDTO>();
return toReturn;
}
public void SortExpression_ToString_WithDescending_HasHasDescendingIndicatorInOutput()
{
var sort = new SortExpression<TestClass>(true, prop => prop.IntProp);
Assert.Contains(ParserConstants.DescendingIndicator, sort.ToString());
}
public SelectList combineModes(object selObjId)
{
if (m_combineModes == null)
{
m_combineModes = new CombineModeCollection();
SortExpression se = new SortExpression(CombineModeFields.Name | SortOperator.Ascending);
m_combineModes.GetMulti(null, 0, se);
}
SelectList selList = new SelectList(m_combineModes, "Id", "Name", selObjId);
return selList;
}
public VideosEntity GetVideoByCatTextId(string TextId)
{
VideoCatalogEntity c = VideoCatalogManager.CreateInstant().GetByTextId(TextId);
if (c != null)
{
EntityCollection<VideosEntity> items = new EntityCollection<VideosEntity>();
IPredicateExpression pre = new PredicateExpression();
pre.Add(VideosFields.CatalogId == c.Id);
SortExpression sort = new SortExpression();
sort.Add(VideosFields.Views | SortOperator.Descending);
RelationPredicateBucket filter = new RelationPredicateBucket();
filter.PredicateExpression.Add(pre);
using (DataAccessAdapterBase adapter = new DataAccessAdapterFactory().CreateAdapter())
{
adapter.FetchEntityCollection(items, filter, 1, sort);
}
if (items != null && items.Count > 0)
return items[0];
}
return null;
}
public void LoadTrgovanjeGlavaPrethodniDan(DataAccessAdapterBase adapter)
{
RelationPredicateBucket bucket = new RelationPredicateBucket();
bucket.PredicateExpression.Add(TrgovanjeGlavaFields.Datum < this.Datum);
PrefetchPath2 prefetchPath = new PrefetchPath2(EntityType.TrgovanjeGlavaEntity);
prefetchPath.Add(TrgovanjeGlavaEntity.PrefetchPathTrgovanjeStavkaCollection);
SortExpression sort = new SortExpression(TrgovanjeGlavaFields.Datum | SortOperator.Descending);
EntityCollection<TrgovanjeGlavaEntity> trgovanjeGlavaCollection = new EntityCollection<TrgovanjeGlavaEntity>(new TrgovanjeGlavaEntityFactory());
adapter.FetchEntityCollection(trgovanjeGlavaCollection, bucket, 1, sort, prefetchPath);
_trgovanjeGlavaPrethodniDan = trgovanjeGlavaCollection.SingleOrDefault();
}
/// <summary>
/// Gets all forum data with section name in a typedlist. Sorted on Section.OrderNo, Section.SectionName, Forum.OrderNo, Forum.ForumName.
/// </summary>
/// <returns>Filled typedlist with all forum names / forumIDs and their containing section's name, sorted on Sectionname, and then forumname</returns>
public static ForumsWithSectionNameTypedList GetAllForumsWithSectionNames()
{
ForumsWithSectionNameTypedList toReturn = new ForumsWithSectionNameTypedList();
SortExpression sorter = new SortExpression(SectionFields.OrderNo.Ascending());
sorter.Add(SectionFields.SectionName.Ascending());
sorter.Add(ForumFields.OrderNo.Ascending());
sorter.Add(ForumFields.ForumName.Ascending());
toReturn.Fill(0, sorter);
return toReturn;
}
public void SortExpression_WithTwoColumns_ToString_ContainsSortPrefix()
{
var sort = new SortExpression<TestClass>(prop => prop.IntProp, prop => prop.StringProp);
Assert.True(sort.ToString().StartsWith(ParserConstants.SortIndicator));
}
/// <summary>
/// Constructs a TypedList with all the messages in the thread given. Poster info is included, so the
/// returned dataview is bindable at once to the message list repeater.
/// </summary>
/// <param name="threadID">ID of Thread which messages should be returned</param>
/// <param name="pageNo">The page no.</param>
/// <param name="pageSize">Size of the page.</param>
/// <returns>TypedList with all messages in the thread for the page specified</returns>
public static MessagesInThreadTypedList GetAllMessagesInThreadAsTypedList(int threadID, int pageNo, int pageSize)
{
// we'll use a typedlist, MessagesInThread to pull the necessary data from the db. The typedlist contains fields from
// message, user and usertitle.
MessagesInThreadTypedList messages = new MessagesInThreadTypedList();
//create the filter with the threadID passed to the method.
PredicateExpression filter = new PredicateExpression(MessageFields.ThreadID == threadID);
// Sort Messages on posting date, ascending, so the first post is located on top.
SortExpression sorter = new SortExpression(MessageFields.PostingDate.Ascending());
// fetch the data into the typedlist. Pass in the paging information as well, to perform server-side paging.
messages.Fill(0, sorter, true, filter, null, null, pageNo, pageSize);
// update thread entity directly inside the DB with a non-transactional update statement so the # of views is increased by one.
ThreadEntity updater = new ThreadEntity();
// set the NumberOfViews field to an expression which increases it by 1
updater.Fields[(int)ThreadFieldIndex.NumberOfViews].ExpressionToApply = (ThreadFields.NumberOfViews + 1);
updater.IsNew = false;
// update the entity directly, and filter on the PK
ThreadCollection threads = new ThreadCollection();
threads.UpdateMulti(updater, (ThreadFields.ThreadID == threadID));
// return the constructed typedlist
return messages;
}
public void SortExpression_ExpressionConstructor_WithOneMemberExpression_HasOneColumn()
{
var sort = new SortExpression<TestClass>(prop => prop.IntProp);
Assert.Equal(1, sort.Columns.Length);
}
private static SortExpression ConvertStringToSortExpression(string sortStr, Func<string, IEntityField2> fieldGetter)
{
var sortExpression = new SortExpression();
if (!string.IsNullOrEmpty(sortStr))
{
var sortClauses = sortStr.Split(new[] { ';', ',' }, StringSplitOptions.None);
foreach (var sortClause in sortClauses)
{
var sortClauseElements = sortClause.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
var sortField = fieldGetter(sortClauseElements[0]);
if (sortField == null)
continue;
sortExpression.Add(new SortClause(
sortField, null,
sortClauseElements.Length > 1 &&
sortClauseElements[1].Equals("desc",
StringComparison.OrdinalIgnoreCase)
? SortOperator.Descending
: SortOperator.Ascending
));
}
}
return sortExpression;
}
//public ProductCollection SortProductsByRate(ProductCollection productList, bool isAscending)
//{
//}
public ProductCollection GetLast5AddedProducts(object m)
{
MembershipEntity member = new MembershipEntity(3);
ProductCollection products = new ProductCollection();
RelationCollection relations = new RelationCollection();
relations.Add(ProductEntity.Relations.StoreEntityUsingStoreId);
relations.Add(StoreEntity.Relations.MembershipEntityUsingMembershipId);
IPrefetchPath prefatchPath = new PrefetchPath((int)EntityType.ProductEntity);
prefatchPath.Add(ProductEntity.PrefetchPathStore).SubPath.Add(StoreEntity.PrefetchPathMembership);
PredicateExpression filter = new PredicateExpression();
filter.Add(MembershipFields.Id == member.Id);
SortExpression sorter = new SortExpression();
sorter.Add(ProductFields.AddedDate | SortOperator.Descending);
products.GetMulti(filter, 5, sorter, relations, prefatchPath);
return products;
}
public void SortExpression_ToString_WithOneColumn_HasHasColumnNameInOutput()
{
var sort = new SortExpression<TestClass>(prop => prop.IntProp);
Assert.Contains("intprop", sort.ToString());
}
public LastViewedProductCollection GetLast5ViewedProducts(int storeId)
{
LastViewedProductCollection lastViewedProducts = new LastViewedProductCollection();
RelationCollection relationsToUse = new RelationCollection();
relationsToUse.Add(LastViewedProductEntity.Relations.ProductEntityUsingProductId);
relationsToUse.Add(ProductEntity.Relations.StoreEntityUsingStoreId);
PrefetchPath prefetchPath = new PrefetchPath((int)EntityType.LastViewedProductEntity);
prefetchPath.Add(LastViewedProductEntity.PrefetchPathProduct).SubPath.Add(ProductEntity.PrefetchPathStore);
PredicateExpression filter = new PredicateExpression();
filter.Add(StoreFields.Id == storeId);
SortExpression sorter = new SortExpression();
sorter.Add( LastViewedProductFields.ViewedTime | SortOperator.Descending);
lastViewedProducts.GetMulti(filter, 5, sorter, relationsToUse, prefetchPath);
return lastViewedProducts;
}
public SelectList uriComponents(object selObjId)
{
if (m_uriComponents == null)
{
m_uriComponents = new UriComponentCollection();
SortExpression se = new SortExpression(UriComponentFields.Name | SortOperator.Ascending);
m_uriComponents.GetMulti(null, 0, se);
}
SelectList selList = new SelectList(m_uriComponents, "Name", "Name", selObjId);
return selList;
}
public object GetLastAddedProducts(int topSelect)
{
ProductCollection productList = new ProductCollection();
SortExpression sorter = new SortExpression();
sorter.Add(ProductFields.AddedDate | SortOperator.Descending);
PredicateExpression filter = new PredicateExpression();
filter.Add(ProductFields.Status == true);
productList.GetMulti(filter, topSelect, sorter);
return productList;
}
public ProductCollection GetLast10AddedProducts()
{
ProductCollection products = new ProductCollection();
SortExpression sorter = new SortExpression();
sorter.Add(ProductFields.AddedDate | SortOperator.Descending);
products.GetMulti(null, 10,sorter);
return products;
}
public void SortExpression_WithTwoColumnsAscendingSort_ReturnsSameEnumerable()
{
var random = new Random();
var query = QueryTestHelper.FormTestData((x, i) =>
{
x.IntProp = random.Next(i);
x.CharProp = (char)random.Next((int)char.MinValue, (int)char.MaxValue);
}, 10);
var sorted = new List<TestClass>(query.ToArray()).OrderBy(x => x.IntProp).ThenBy(x => x.CharProp).ToList();
var sortexpr = new SortExpression<TestClass>(new string[] { "IntProp", "CharProp" });
var output = sortexpr.Map(query).ToList();
Assert.Equal(sorted[0].IntProp, output[0].IntProp);
Assert.Equal(sorted[0].CharProp, output[0].CharProp);
}
public void SortExpression_ToString_WithTwoColumns_HasHasBothColumnsInOutput()
{
var sort = new SortExpression<TestClass>(prop => prop.IntProp, prop => prop.StringProp);
Assert.Contains("intprop,stringprop", sort.ToString());
}
public void SortExpression_ExpressionConstructor_WithOneMemberExpression_HasCorrectColumnName()
{
var sort = new SortExpression<TestClass>(prop => prop.IntProp);
Assert.Equal("intprop", sort.Columns[0]);
}
