/// <summary>
/// Applies the roles filter.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="model">The model.</param>
/// <returns>Query with roles filter applied</returns>
private IQueryable<Models.User> ApplyRolesFilter(IQueryable<Models.User> query, GetUsersModel model)
{
if (model.FilterByRoles != null && model.FilterByRoles.Any(role => !string.IsNullOrWhiteSpace(role)))
{
var predicate = (model.FilterByRolesConnector == FilterConnector.Or)
? PredicateBuilder.False<Models.User>()
: PredicateBuilder.True<Models.User>();
foreach (var roleName in model.FilterByRoles)
{
if (!string.IsNullOrWhiteSpace(roleName))
{
Expression<Func<Models.User, bool>> whereClause = user => user.UserRoles.Any(userRole => userRole.Role.Name == roleName && !userRole.Role.IsDeleted);
if (model.FilterByRolesConnector == FilterConnector.Or)
{
predicate = PredicateBuilder.Or(predicate, whereClause);
}
else
{
predicate = PredicateBuilder.And(predicate, whereClause);
}
}
}
query = query.Where(predicate);
}
return query;
}
//Method to fill the contents of a grid view with an IQueryable argument
//protected void FillGrid(object sender, IQueryable q, GridViewSortEventArgs e)
//{
// GridView1.DataSource = q;
// //GridView1.DataSourceID = String.Empty;
// gridView_Sorting(sender, e, GridView1);
// //GridView1.DataBind();
// GridView1.AutoGenerateColumns = true;
// GridView1.Visible = true;
// //GridView1.EnableSortingAndPagingCallbacks = true;
//}
protected void FillGrid(object sender, IQueryable q)
{
GridView1.DataSource = q;
GridView1.DataBind();
GridView1.AutoGenerateColumns = true;
GridView1.Visible = true;
}
public IQueryable<ReclamacaoViewModel> GetReclamacoes()
{
// int filtro = int.Parse(DropDownList1.SelectedValue);
string filtro = DropDownList1.SelectedItem.ToString();
DateTime inicio = calInicio.SelectedDate;
DateTime fim = calFim.SelectedDate;
ReclamaPoaEntities _db = new ReclamaPoaEntities();
query = from r in _db.Reclamacoes
where filtro == r.Bairro.Nome && r.Data >= inicio && r.Data <= fim
select new ReclamacaoViewModel
{
ReclamacaoId = r.ReclamacaoId,
Titulo = r.Titulo,
Descricao = r.Descricao,
Data = r.Data,
Endereco = r.Endereco,
Situacao = r.Situacao.ToString(),
Bairro = r.Bairro.Nome,
Categoria = r.Categoria.Nome,
UrlImagem = r.UrlImagem
};
lvbairros.DataBind();
return query;
}
public IEnumerable<ContributionInfo> ContributionsList(IQueryable<Contribution> query)
{
var q2 = from c in query
let bd = c.BundleDetails.FirstOrDefault()
select new ContributionInfo
{
BundleId = bd == null ? 0 : bd.BundleHeaderId,
ContributionAmount = c.ContributionAmount,
ContributionDate = c.ContributionDate,
ContributionId = c.ContributionId,
ContributionType = c.ContributionType.Description,
ContributionTypeId = c.ContributionTypeId,
Fund = c.ContributionFund.FundName,
NonTaxDed =
c.ContributionTypeId == ContributionTypeCode.NonTaxDed ||
(c.ContributionFund.NonTaxDeductible ?? false),
StatusId = c.ContributionStatusId,
Status = c.ContributionStatus.Description,
Name = c.Person.Name,
PeopleId = c.PeopleId ?? 0,
Description = c.ContributionDesc,
CheckNo = c.CheckNo
};
return q2;
}
private IQueryable<ProductsListViewModel> GetSorted(IQueryable<ProductsListViewModel> allProducts, string sortOrder)
{
ViewBag.CurrentSort = sortOrder;
ViewBag.DateSortParm = String.IsNullOrEmpty(sortOrder) ? "Date" : "";
ViewBag.PriceSortParm = sortOrder == "Price" ? "price_desc" : "Price";
ViewBag.RatingSortParm = sortOrder == "Rating" ? "rating_desc" : "Rating";
switch (sortOrder)
{
case "Rating":
allProducts = allProducts.OrderBy(p => p.Rating);
break;
case "rating_desc":
allProducts = allProducts.OrderByDescending(p => p.Rating);
break;
case "Price":
allProducts = allProducts.OrderBy(p => p.Price);
break;
case "price_desc":
allProducts = allProducts.OrderByDescending(p => p.Price);
break;
case "Date":
allProducts = allProducts.OrderByDescending(p => p.ReleaseDate);
break;
default:
allProducts = allProducts.OrderBy(p => p.ReleaseDate);
break;
}
return allProducts;
}
private IQueryable<SubscriptionPost> AddNeededWhereClauses(string query,
IQueryable<SubscriptionPost> subscriptionPosts)
{
foreach (var whereClause in GetWhereClausesFromQuery(query))
{
switch (whereClause.PropertyName)
{
case PropertyName.Author:
subscriptionPosts = subscriptionPosts
.Where(x => x.Authors.Contains(whereClause.Text) == whereClause.MustContainText);
break;
case PropertyName.Content:
subscriptionPosts = subscriptionPosts
.Where(x => x.Content.Contains(whereClause.Text) == whereClause.MustContainText);
break;
case PropertyName.Categories:
subscriptionPosts = subscriptionPosts
.Where(x => x.Categories.Contains(whereClause.Text) == whereClause.MustContainText);
break;
case PropertyName.Feed:
subscriptionPosts = subscriptionPosts
.Where(x => x.Subscription.Title.Contains(whereClause.Text) == whereClause.MustContainText);
break;
case PropertyName.Title:
subscriptionPosts = subscriptionPosts
.Where(x => x.Title.Contains(whereClause.Text) == whereClause.MustContainText);
break;
}
}
return subscriptionPosts;
}
public static List<BlogPostVModel> BlogPosts(IQueryable<SeqPost> result)
{
List<BlogPostVModel> blogList = new List<BlogPostVModel>();
BlogPostVModel post;
if (result == null) return blogList;
foreach (SeqPost sp in result) {
post = new BlogPostVModel();
post.BlogPostId = sp.PostId;
post.Title = sp.Title;
post.Description = sp.Description;
post.ExtendedDescription = sp.ExtendedText;
post.Excerpt = sp.Excerpt;
post.CreateDate = sp.CreateDate;
post.Permalink = sp.Permalink;
foreach (SeqTag st in sp.SeqTags) {
TagVModel tvm = new TagVModel();
tvm.BlogId = st.BlogId;
tvm.TagId = st.TagId;
tvm.Name = st.Name;
post.Tags.Add(tvm);
}
blogList.Add(post);
}
return blogList;
}
public override IQueryable GetQueryable(IQueryable source)
{
string selectedValue = DropDownList1.SelectedValue;
if (String.IsNullOrEmpty(selectedValue))
{
return source;
}
if (selectedValue == NullValueString)
{
return ApplyEqualityFilter(source, Column.Name, null);
}
IDictionary dict = new Hashtable();
Column.ExtractForeignKey(dict, selectedValue);
foreach (DictionaryEntry entry in dict)
{
string key = (string)entry.Key;
if (DefaultValues != null)
{
DefaultValues[key] = entry.Value;
}
source = ApplyEqualityFilter(source, Column.GetFilterExpression(key), entry.Value);
}
return source;
}
public void QueryLog(IQueryable linqQuery)
{
_querytype = QueryType.LINQ;
_linqQuery = linqQuery.Expression.ToString();
_StoreSQL = ToTraceString(linqQuery);
CreateLogEntry();
}
public UpdatedPackages(
IQueryable<IPackage> installedPackages,
IPackageRepository aggregrateRepository)
{
this.installedPackages = installedPackages;
this.sourceRepository = aggregrateRepository;
}
public IQueryable ApplySelectAndExpand(IQueryable queryable, HttpRequestMessage request )
{
var result = queryable;
var hasSelectOrExpand = false;
var map = request.RequestUri.ParseQueryString();
var selectQueryString = map["$select"];
if (!string.IsNullOrWhiteSpace(selectQueryString)) {
var selectClauses = selectQueryString.Split(',').Select(sc => sc.Replace('/', '.')).ToList();
var elementType = TypeFns.GetElementType(queryable.GetType());
var func = QueryBuilder.BuildSelectFunc(elementType, selectClauses);
result = func(result);
hasSelectOrExpand = true;
}
var expandsQueryString = map["$expand"];
if (!string.IsNullOrWhiteSpace(expandsQueryString)) {
if (!string.IsNullOrWhiteSpace(selectQueryString)) {
throw new Exception("Use of both 'expand' and 'select' in the same query is not currently supported");
}
expandsQueryString.Split(',').Select(s => s.Trim()).ToList().ForEach(expand => {
result = ((dynamic) result).Include(expand.Replace('/', '.'));
});
hasSelectOrExpand = true;
}
return hasSelectOrExpand ? result : null;
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseCollectionResult" /> class.
/// </summary>
/// <param name="query">The query that returns a collection of objects.</param>
/// <param name="edmType">The EDM type reference of the objects.</param>
/// <param name="context">The context where the action is executed.</param>
protected BaseCollectionResult(IQueryable query, IEdmTypeReference edmType, ApiContext context)
: base(edmType, context)
{
Ensure.NotNull(query, "query");
this.Query = query;
}
public IQueryable<EnhancedStudentInformation> ApplyFilter(IQueryable<EnhancedStudentInformation> query, StudentMetricsProviderQueryOptions providerQueryOptions)
{
//If the Staff USI Isn't set, then no-op.
if (providerQueryOptions.StaffUSI <= 0)
return query;
//The only way a Staff member can be associated with a student at LEA is via the Staff Cohort tables. Only check that one table.
if (providerQueryOptions.LocalEducationAgencyId.HasUsableValue() && !providerQueryOptions.SchoolId.HasUsableValue())
{
var staffStudentCohorts = StaffStudentCohortRepository.GetAll();
IQueryable<StaffCohort> staffCohort = StaffCohortRepository.GetAll().Where(sc => sc.StaffUSI == providerQueryOptions.StaffUSI);
return query.Where(si => staffStudentCohorts
.SelectMany(ssc => staffCohort.Where(sc => ssc.StaffCohortId == sc.StaffCohortId).Select(sc => ssc))
.Any(ssc => ssc.StudentUSI == si.StudentUSI));
}
//At the school level, a staff member can be associated by Cohort or by Section. This view collapses the two.
var ssa = StaffStudentAssociationRepository.GetAll();
return query.Where(student => ssa.Any(ms => ms.StudentUSI == student.StudentUSI
&& ms.SchoolId == student.SchoolId
//This filters on school id, because if a teacher is a teacher at two schools,
//We need to filter on the Staff Section records only for the current school.
&& ms.SchoolId == providerQueryOptions.SchoolId.GetValueOrDefault()
&& ms.StaffUSI == providerQueryOptions.StaffUSI));
}
/// <summary>
/// Filters the device list with the supplied filters
/// </summary>
/// <param name="list">Devices to filter</param>
/// <param name="filters">Filters to apply</param>
/// <returns>Set of devices that pass all the filters</returns>
public static IQueryable<dynamic> FilterDeviceList(
IQueryable<dynamic> list,
List<FilterInfo> filters)
{
if (list == null)
{
throw new ArgumentNullException("list");
}
if (filters == null)
{
return list;
}
list = list.Where(GetIsNotNull).AsQueryable();
foreach (var f in filters)
{
if ((f != null) && !string.IsNullOrEmpty(f.ColumnName))
{
list = FilterItems(list, f);
}
}
return list;
}
public static async Task<IQueryable<Package>> SearchCore(
ISearchService searchService,
HttpRequestBase request,
IQueryable<Package> packages,
string searchTerm,
string targetFramework,
bool includePrerelease,
CuratedFeed curatedFeed)
{
SearchFilter searchFilter;
// We can only use Lucene if:
// a) We are looking for the latest version of a package OR the Index contains all versions of each package
// b) The sort order is something Lucene can handle
if (TryReadSearchFilter(searchService.ContainsAllVersions, request.RawUrl, out searchFilter))
{
searchFilter.SearchTerm = searchTerm;
searchFilter.IncludePrerelease = includePrerelease;
searchFilter.CuratedFeed = curatedFeed;
searchFilter.SupportedFramework = targetFramework;
var results = await GetResultsFromSearchService(searchService, searchFilter);
return results;
}
if (!includePrerelease)
{
packages = packages.Where(p => !p.IsPrerelease);
}
return packages.Search(searchTerm);
}
public PackageListViewModel(IQueryable<Package> packages,
string searchTerm,
string sortOrder,
int totalCount,
int pageIndex,
int pageSize,
UrlHelper url,
bool includePrerelease)
{
// TODO: Implement actual sorting
IEnumerable<ListPackageItemViewModel> items;
using (MiniProfiler.Current.Step("Querying and mapping packages to list"))
{
items = packages.ToList()
.Select(pv => new ListPackageItemViewModel(pv, needAuthors: false));
}
PageIndex = pageIndex;
PageSize = pageSize;
TotalCount = totalCount;
SortOrder = sortOrder;
SearchTerm = searchTerm;
int pageCount = (TotalCount + PageSize - 1) / PageSize;
var pager = new PreviousNextPagerViewModel<ListPackageItemViewModel>(
items,
PageIndex,
pageCount,
page => url.PackageList(page, sortOrder, searchTerm, includePrerelease)
);
Items = pager.Items;
FirstResultIndex = 1 + (PageIndex * PageSize);
LastResultIndex = FirstResultIndex + Items.Count() - 1;
Pager = pager;
IncludePrerelease = includePrerelease ? "true" : null;
}
public GroupDescriptorExpressionBuilder(IQueryable queryable, GroupDescriptor groupDescriptor, GroupDescriptorExpressionBuilder childBuilder, IQueryable notPagedData)
: base(queryable)
{
this.groupDescriptor = groupDescriptor;
this.childBuilder = childBuilder;
this.notPagedData = notPagedData;
}
private static List<Quest401kTransactionDto> MapModelToDto(IQueryable<Quest401KTransactions> transactions)
{
//return transactions.Project().To<Quest401kTransactionDto>().ToList();
var transactionsDtos = new List<Quest401kTransactionDto>();
foreach (var transaction in transactions)
{
var dto = new Quest401kTransactionDto
{
Id = transaction.Id,
Row = transaction.Row,
Ticker = transaction.Ticker,
Date = transaction.Date,
Trantype = transaction.Trantype,
Amount = transaction.Amount,
Shares = transaction.Shares,
Nav = transaction.Nav
};
var subTransactionsDtos = new List<Quest401kSubTransactionDto>();
foreach (var subTransaction in transaction.SubTransactions)
{
var subTransactionDto = new Quest401kSubTransactionDto
{
Id = subTransaction.Id,
Trantype = subTransaction.Trantype,
Amount = subTransaction.Amount,
Shares = subTransaction.Shares
};
subTransactionsDtos.Add(subTransactionDto);
}
dto.SubTransactions = subTransactionsDtos;
transactionsDtos.Add(dto);
}
return transactionsDtos;
}
protected override void EstablishContext()
{
//Prepare supplied data collections
suppliedStudentInformationData = GetSuppliedStudentInformation();
suppliedRootMetricNode = GetSuppliedRootNode();
suppliedRootMetricHierarchy = GetSuppliedRootMetricHierarchy();
suppliedRootIEnumerableOfKeyValuePair = GetSuppliedRootKeyValuePairs();
//Set up the mocks
studentInformationRepository = mocks.StrictMock<IRepository<StudentInformation>>();
rootMetricNodeResolver = mocks.StrictMock<IRootMetricNodeResolver>();
domainMetricService = mocks.StrictMock<IDomainMetricService<StudentSchoolMetricInstanceSetRequest>>();
metricTreeToIEnumerableOfKeyValuePairProvider = mocks.StrictMock<IMetricTreeToIEnumerableOfKeyValuePairProvider>();
//Set expectations
Expect.Call(studentInformationRepository.GetAll()).Return(suppliedStudentInformationData);
Expect.Call(rootMetricNodeResolver.GetRootMetricNode()).Return(suppliedRootMetricNode);
Expect.Call(domainMetricService.Get(null))
.Constraints(
new ActionConstraint<StudentSchoolMetricInstanceSetRequest>(x =>
{
Assert.That(x.SchoolId == suppliedSchoolId);
Assert.That(x.StudentUSI == suppliedStudentUSI);
Assert.That(x.MetricVariantId == suppliedRootMetricNode.MetricVariantId);
})
).Return(suppliedRootMetricHierarchy);
Expect.Call(metricTreeToIEnumerableOfKeyValuePairProvider.FlattenMetricTree((ContainerMetric) suppliedRootMetricHierarchy.RootNode)).Return(suppliedRootIEnumerableOfKeyValuePair);
}
public override IQueryable GetQueryable(IQueryable source)
{
string searchString = textBox.Text.Trim();
if (String.IsNullOrEmpty(searchString))
return source;
ConstantExpression searchFilter = Expression.Constant(searchString);
ParameterExpression param = Expression.Parameter(source.ElementType);
MemberExpression property = Expression.Property(param, this.Column.Name);
if (Nullable.GetUnderlyingType(property.Type) != null)
property = Expression.Property(property, "Value");
MethodInfo method = typeof(String).GetMethod("Contains", new[] { typeof(String) });
var containsMethodExp = Expression.Call(property, method, searchFilter);
var containsLambda = Expression.Lambda(containsMethodExp, param);
var resultExpression = Expression.Call(
typeof(Queryable),
"Where",
new Type[] { source.ElementType },
source.Expression,
Expression.Quote(containsLambda));
return source.Provider.CreateQuery(resultExpression);
}
public void AddSampleDocuments()
{
AddDocument(new SampleDocument { Name = "Documents Bill", Id = "X.Y.1.2", Version = new Version("1.0"), NullableScalar = 5 });
AddDocument(new SampleDocument { Name = "Bills Document", Id = "X.Z.1.3", Version = new Version("1.5"), NullableScalar = 1, NumericBool = true});
documents = provider.AsQueryable<SampleDocument>();
}
/// <summary>
/// Initializes a new instance of the <see cref="AggregateCatalog"/> class
/// with the specified catalogs.
/// </summary>
/// <param name="catalogs">
/// An <see cref="IEnumerable{T}"/> of <see cref="ComposablePartCatalog"/> objects to add
/// to the <see cref="AggregateCatalog"/>; or <see langword="null"/> to
/// create an <see cref="AggregateCatalog"/> that is empty.
/// </param>
/// <exception cref="ArgumentException">
/// <paramref name="catalogs"/> contains an element that is <see langword="null"/>.
/// </exception>
public AggregateCatalog(IEnumerable<ComposablePartCatalog> catalogs)
{
Requires.NullOrNotNullElements(catalogs, "catalogs");
this._catalogs = new ComposablePartCatalogCollection(catalogs, this.OnChanged, this.OnChanging);
this._partsQuery = this._catalogs.AsQueryable().SelectMany(catalog => catalog.Parts);
}
private static IQueryable<Customer> FilterCustomers(IQueryable<Customer> customers, Rule rule)
{
if (rule.field == "CustomerId")
{
int result;
if (!int.TryParse(rule.data, out result))
return customers;
return customers.Where(c => c.CustomerID == Convert.ToInt32(rule.data));
}
if (rule.field == "Name")
return from c in customers
where c.FirstName.Contains(rule.data) || c.LastName.Contains(rule.data)
select c;
if (rule.field == "Company")
return customers.Where(c => c.CompanyName.Contains(rule.data));
if (rule.field == "EmailAddress")
return customers.Where(c => c.EmailAddress.Contains(rule.data));
if (rule.field == "Last Modified")
{
DateTime result;
if (!DateTime.TryParse(rule.data, out result))
return customers;
if (result < new DateTime(1754, 1, 1)) // sql can't handle dates before 1-1-1753
return customers;
return customers.Where(c => c.ModifiedDate.Date == Convert.ToDateTime(rule.data).Date);
}
if (rule.field == "Telephone")
return customers.Where(c => c.Phone.Contains(rule.data));
return customers;
}
public PackageListViewModel(
IQueryable<Package> packages,
DateTime? indexTimestampUtc,
string searchTerm,
int totalCount,
int pageIndex,
int pageSize,
UrlHelper url,
string curatedFeed)
{
// TODO: Implement actual sorting
IEnumerable<ListPackageItemViewModel> items = packages.ToList().Select(pv => new ListPackageItemViewModel(pv));
PageIndex = pageIndex;
IndexTimestampUtc = indexTimestampUtc;
PageSize = pageSize;
TotalCount = totalCount;
SearchTerm = searchTerm;
int pageCount = (TotalCount + PageSize - 1) / PageSize;
var pager = new PreviousNextPagerViewModel<ListPackageItemViewModel>(
items,
PageIndex,
pageCount,
page => curatedFeed == null ?
url.PackageList(page, searchTerm) :
url.CuratedPackageList(page, searchTerm, curatedFeed)
);
Items = pager.Items;
FirstResultIndex = 1 + (PageIndex * PageSize);
LastResultIndex = FirstResultIndex + Items.Count() - 1;
Pager = pager;
}
protected override void ExecuteTest()
{
studentResults = filter.ApplyFilter(query, new StudentMetricsProviderQueryOptions
{
SchoolId = SuppliedSchoolId2
});
}
public override Expression BuildLinqExpression(IQueryable query, Expression expression, Expression item = null)
{
var leftExpression = this.LeftNode.BuildLinqExpression(query, expression, item);
var rightExpression = this.RightNode.BuildLinqExpression(query, expression, item);
// Nasty workaround to avoid comparison of Aggregate functions to true or false which breaks Entity framework
if (leftExpression.Type == typeof(bool) && rightExpression.Type == typeof(bool) && rightExpression is ConstantExpression)
{
if ((bool)(rightExpression as ConstantExpression).Value)
{
return leftExpression;
}
return Expression.Not(leftExpression);
}
if (rightExpression.Type == typeof(bool) && leftExpression.Type == typeof(bool)
&& leftExpression is ConstantExpression)
{
if ((bool)(leftExpression as ConstantExpression).Value)
{
return rightExpression;
}
return Expression.Not(rightExpression);
}
NormalizeTypes(ref leftExpression, ref rightExpression);
return ApplyEnsuringNullablesHaveValues(Expression.Equal, leftExpression, rightExpression);
}
public static MemberAccessExpressionBuilderBase MemberAccess(IQueryable source, Type memberType, string memberName)
{
var builder = MemberAccess(source.ElementType, memberType, memberName);
builder.Options.LiftMemberAccessToNull = source.Provider.IsLinqToObjectsProvider();
return builder;
}
protected override void EstablishContext()
{
//Prepare supplied data collections
suppliedStudentMetricBenchmarkAssessmentData = GetSuppliedStudentMetricBenchmarkAssessment();
suppliedSchoolGoal = GetSuppliedMetricGoal();
suppliedMetricState = GetSuppliedMetricState();
//Set up the mocks
metricNodeResolver = mocks.StrictMock<IMetricNodeResolver>();
studentMetricBenchmarkAssessmentRepository = mocks.StrictMock<IRepository<StudentMetricBenchmarkAssessment>>();
metricGoalProvider = mocks.StrictMock<IMetricGoalProvider>();
metricStateProvider = mocks.StrictMock<IMetricStateProvider>();
metricInstanceSetKeyResolver = mocks.StrictMock<IMetricInstanceSetKeyResolver<StudentSchoolMetricInstanceSetRequest>>();
//Set expectations
Expect.Call(metricNodeResolver.GetMetricNodeForStudentFromMetricVariantId(suppliedSchoolId, suppliedMetricVariantId)).Return(GetMetricMetadataNode());
Expect.Call(studentMetricBenchmarkAssessmentRepository.GetAll()).Return(suppliedStudentMetricBenchmarkAssessmentData);
Expect.Call(
metricInstanceSetKeyResolver.GetMetricInstanceSetKey(null))
.Constraints(
new ActionConstraint<StudentSchoolMetricInstanceSetRequest>(x =>
{
Assert.That(x.SchoolId == suppliedSchoolId);
Assert.That(x.MetricVariantId == suppliedMetricVariantId);
Assert.That(x.StudentUSI == suppliedStudentUSI);
})
).Return(suppliedMetricInstanceSetKey);
Expect.Call(metricGoalProvider.GetMetricGoal(suppliedMetricInstanceSetKey, suppliedMetricId)).Return(suppliedSchoolGoal);
Expect.Call(metricStateProvider.GetState(suppliedMetricId, suppliedMetricValueStr, "System.Double")).Repeat.Any().Return(suppliedMetricState);
Expect.Call(metricStateProvider.GetState(suppliedMetricId, "", "System.Double")).Return(suppliedMetricState);
}
public static MvcHtmlString CreateFilteredRequestTable(this HtmlHelper helper, IQueryable<FilteredRequestRecord> filteredRequestRecords, Localizer T)
{
StringBuilder sb = new StringBuilder();
if (filteredRequestRecords == null || !filteredRequestRecords.Any())
{
sb.AppendLine(T("No requests are filtered yet.").Text);
}
else
{
sb.AppendLine("<table><tr>");
sb.AppendFormat("<th>{0}</th>", T("Request time"));
sb.AppendFormat("<th>{0}</th>", T("Url"));
sb.AppendFormat("<th>{0}</th>", T("User Host Address"));
sb.AppendFormat("<th>{0}</th>", T("User Agent"));
sb.AppendLine("</tr>");
foreach (FilteredRequestRecord filteredRequest in filteredRequestRecords.OrderByDescending(r => r.RequestTime))
{
sb.AppendLine("<tr>");
sb.AppendFormat("<td>{0}</td>", filteredRequest.RequestTime);
sb.AppendFormat("<td>{0}</td>", filteredRequest.Url);
sb.AppendFormat("<td>{0}</td>", filteredRequest.UserHostAddress);
sb.AppendFormat("<td>{0}</td>", filteredRequest.UserAgent);
sb.AppendLine("</tr>");
}
sb.AppendLine("</table>");
}
return new MvcHtmlString(sb.ToString());
}
/// <summary>
/// 返回数据条数
/// </summary>
/// <param name="entityQueryable"></param>
public int ResultDataCount(IQueryable <T_Sys_Users> entityQueryable)
{
return(_repository.ResultDataCount(entityQueryable));
}
public IQueryable <TEntity> Include <TEntity, TProperty>(IQueryable <TEntity> source, Expression <Func <TEntity, TProperty> > navigationPropertyPath) where TEntity : class
{
return(EntityFrameworkQueryableExtensions.Include(source, navigationPropertyPath));
}
public static IQueryable <ChatUser> Online(this IQueryable <ChatUser> source)
{
return(source.Where(u => u.Status != (int)UserStatus.Offline));
}
protected override IQueryable <User> ApplySorting(IQueryable <User> query, PagedResultRequestDto input)
{
return(query.OrderBy(r => r.UserName));
}
/// <summary>Gets the query to fetch the typed list EmployeeJoined</summary>
/// <param name="root">Optional. If specified (not null) it's used as the root of the query to fetch the typed list, otherwise a new IQueryable(Of EmployeeClassificationEntity) is used</param>
/// <returns>IQueryable</returns>
public IQueryable <LLBLGenPro.OrmCookbook.TypedListClasses.EmployeeJoinedRow> GetEmployeeJoinedTypedList(IQueryable <EmployeeClassificationEntity> root = null)
{
var current0 = root ?? this.EmployeeClassification;
var current1 = from employeeClassification in current0
join employee in this.Employee on employeeClassification.EmployeeClassificationKey equals employee.EmployeeClassificationKey
select new LLBLGenPro.OrmCookbook.TypedListClasses.EmployeeJoinedRow()
{
CellPhone = employee.CellPhone, EmployeeKey = employee.EmployeeKey, FirstName = employee.FirstName, LastName = employee.LastName, MiddleName = employee.MiddleName, OfficePhone = employee.OfficePhone, Title = employee.Title, EmployeeClassificationKey = employeeClassification.EmployeeClassificationKey, EmployeeClassificationName = employeeClassification.EmployeeClassificationName, IsEmployee = employeeClassification.IsEmployee, IsExempt = employeeClassification.IsExempt
};
return(current1);
}
public static async Task <CustomList <T> > CreateAsync(IQueryable <T> source)
{
return(new CustomList <T>(List <T> list)); //do whatever you need in the contructor, constructor omitted
}
public override void BulkDelete(IQueryable <TEntity> query)
{
query.Delete();
}
public override void BulkUpdate(IQueryable <TEntity> query, Expression <Func <TEntity, TEntity> > updateExpression)
{
query.Update(updateExpression);
}
public async Task <InventoryObject[]> GetAllInventoryObjectsAsync()
{
IQueryable <InventoryObject> query = _appDbContext.InventoryObjects;
return(await query.ToArrayAsync());
}
public static IQueryable <T> ApplySort <T>(this IQueryable <T> source, string orderBy,
Dictionary <string, PropertyMappingValue> mappingDictionary)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (mappingDictionary == null)
{
throw new ArgumentNullException(nameof(mappingDictionary));
}
if (string.IsNullOrWhiteSpace(orderBy))
{
return(source);
}
// the orderBy string is separated by ",", so we split it.
var orderByAfterSplit = orderBy.Split(',');
// apply each orderby clause in reverse order - otherwise, the
// IQueryable will be ordered in the wrong order
foreach (var orderByClause in orderByAfterSplit.Reverse())
{
// trim the orderBy clause, as it might contain leading
// or trailing spaces. Can't trim the var in foreach,
// so use another var.
var trimmedOrderByClause = orderByClause.Trim();
// if the sort option ends with with " desc", we order
// descending, ortherwise ascending
var orderDescending = trimmedOrderByClause.EndsWith(" desc");
// remove " asc" or " desc" from the orderBy clause, so we
// get the property name to look for in the mapping dictionary
var indexOfFirstSpace = trimmedOrderByClause.IndexOf(" ");
var propertyName = indexOfFirstSpace == -1 ?
trimmedOrderByClause : trimmedOrderByClause.Remove(indexOfFirstSpace);
// find the matching property
if (!mappingDictionary.ContainsKey(propertyName))
{
throw new ArgumentException($"Key mapping for {propertyName} is missing");
}
// get the PropertyMappingValue
var propertyMappingValue = mappingDictionary[propertyName];
if (propertyMappingValue == null)
{
throw new ArgumentNullException("propertyMappingValue");
}
// Run through the property names in reverse
// so the orderby clauses are applied in the correct order
foreach (var destinationProperty in
propertyMappingValue.DestinationProperties.Reverse())
{
// revert sort order if necessary
if (propertyMappingValue.Revert)
{
orderDescending = !orderDescending;
}
source = source.OrderBy(destinationProperty +
(orderDescending ? " descending" : " ascending"));
}
}
return(source);
}
/// <summary>
/// 分页数据
/// </summary>
/// <param name="sortKey">排序</param>
/// <param name="pageNumber">当前页数</param>
/// <param name="pageSize">展示数据条数</param>
/// <returns>返回符合条件数据列表</returns>
public IQueryable <T_Sys_Users> FindDataByPageFilter(string sortKey, int pageNumber, int pageSize, IQueryable <T_Sys_Users> entityList = null)
{
return(_repository.FindDataByPageFilter(sortKey, pageNumber, pageSize, entityList));
}
public ExcelResult(IQueryable rows, string fileName, string[] headers, string[] properties, string title)
: this(rows, fileName, headers, properties, title, null, null, null)
{
}
// GET: Agencies
public async Task <ActionResult> Index(string sortOrder, string currentFilter, string searchString, int?page)
{
//return View(await agencys.ToListAsync());
ViewBag.NameSortParm = String.IsNullOrEmpty(sortOrder) ? "Name_desc" : "";
ViewBag.ContactPersonSortParm = sortOrder == "ContactPerson" ? "ContactPerson_desc" : "ContactPerson";
ViewBag.EmailSortParm = sortOrder == "Email" ? "Email_desc" : "Email";
ViewBag.PhoneNumberSortParm = sortOrder == "Phone" ? "Phone_desc" : "Phone";
//ViewBag.SubscriptionSortParm = sortOrder == "Subscription" ? "Subscription_desc" : "Subscription";
ViewBag.AmountSortParm = sortOrder == "Amount" ? "Amount_desc" : "Amount";
ViewBag.PaidSortParm = sortOrder == "Paid" ? "Paid_desc" : "Paid";
IQueryable <AgencyViewModel> agencysData = from agencys in db.Agencys.Include(a => a.Subscription)
select new AgencyViewModel()
{
AgencyID = agencys.AgencyID,
Name = agencys.Name,
ContactPerson = agencys.ContactPerson,
Email = agencys.Email,
Phone = agencys.Phone,
//Subscription = agencys.Subscription.Name,
Amount = agencys.Subscription.Amount,
Paid = agencys.Subscription.Paid
};
//Paging
if (searchString != null)
{
page = 1;
}
else
{
searchString = currentFilter;
}
ViewBag.CurrentFilter = searchString;
//Filtering
if (!String.IsNullOrEmpty(searchString))
{
agencysData = agencysData.Where
(s => s.Name.ToString().ToUpper().Contains(searchString.ToUpper()) ||
s.ContactPerson.ToString().ToUpper().Contains(searchString.ToUpper())
);
}
switch (sortOrder)
{
case "Name_desc":
agencysData = agencysData.OrderByDescending(s => s.Name);
break;
case "ContactPerson":
agencysData = agencysData.OrderBy(s => s.ContactPerson);
break;
case "ContactPerson_desc":
agencysData = agencysData.OrderByDescending(s => s.ContactPerson);
break;
case "Email":
agencysData = agencysData.OrderBy(s => s.Email);
break;
case "Email_desc":
agencysData = agencysData.OrderByDescending(s => s.Email);
break;
case "Phone":
agencysData = agencysData.OrderBy(s => s.Phone);
break;
case "Phone_desc":
agencysData = agencysData.OrderByDescending(s => s.Phone);
break;
//case "Subscription":
// agencysData = agencysData.OrderBy(s => s.Subscription);
// break;
//case "Subscription_desc":
// agencysData = agencysData.OrderByDescending(s => s.Subscription);
// break;
case "Amount":
agencysData = agencysData.OrderBy(s => s.Amount);
break;
case "Amount_desc":
agencysData = agencysData.OrderByDescending(s => s.Amount);
break;
case "Paid":
agencysData = agencysData.OrderBy(s => s.Paid);
break;
case "Paid_desc":
agencysData = agencysData.OrderByDescending(s => s.Paid);
break;
default:
agencysData = agencysData.OrderBy(s => s.Name);
break;
}
int pageSize = 15;
int pageNumber = (page ?? 1);
return(View(await agencysData.ToPagedListAsync(pageNumber, pageSize)));
}
public IQueryable <TSource> OrderByDescending(IQueryable <TSource> query, string[] keyNames, object comparer)
{
return(AddOrAppendOrderBy(query, keyNames, false, comparer));
}
private static IQueryable <T> OfNotDeleted <T>(this IQueryable <T> query) where T : class, IIsDeletedFlagEntity
{
return(query.Where(_ => !_.IsDeleted));
}
public IQueryable <TSource> OrderBy(IQueryable <TSource> query, string[] keyNames)
{
return(AddOrAppendOrderBy(query, keyNames, true));
}
public ExcelResult(IQueryable rows, string fileName, string[] headers)
: this(rows, fileName, null, null, null, null, null, null)
{
}
public static IQueryable <T> SelectPage <T>(this IQueryable <T> collection, Page page)
{
return(collection.Skip((page.Number - 1) * page.Size).Take(page.Size));
}
public IQueryable <TSource> OrderByDescending(IQueryable <TSource> query, string[] keyNames)
{
return(AddOrAppendOrderBy(query, keyNames, false));
}
public bool IsNameDuplicated(CountryLocation model)
{
IQueryable <CountryLocation> items = FindAll(x => x.Name == model.Name && !x.IsDeleted && x.Id != model.Id && x.OfficeId == model.OfficeId);
return(items.Count() > 0 ? true : false);
}
protected override IQueryable <Role> ApplySorting(IQueryable <Role> query, PagedRoleResultRequestDto input)
{
return(query.OrderBy(r => r.DisplayName));
}
private IQueryable FilterOnKeys(IQueryable queryable, IEdmCollectionType edmCollectionType,
KeyValuePathSegment segmentKey)
{
// need to filter down the entity
var entityType = GetEdmEntityType(edmCollectionType);
// make sure we found the key and entity
if (entityType == null || segmentKey == null)
{
throw new WebAPIDataServiceException("Keys not found", new KeyNotFoundException());
}
var entityKeys = entityType.DeclaredKey.Select(dk => dk.Name).ToArray();
// key can be pass in either , or name value pair
var segmentKeys = segmentKey.Value.Split(',');
if (segmentKeys.Length == entityKeys.Length)
{
//ToDo this won't handle the edge cases where a value contains an equal sign
var passedInKeys = segmentKeys.Select(k => k.Split('='))
.Where(k => k.Length == 2)
.Select(
k =>
new KeyValuePair<string, string>(k[0], k[1]))
.ToArray();
if (passedInKeys.Length > 0)
{
if (!entityKeys.OrderBy(k => k)
.SequenceEqual(passedInKeys.Select(kv => kv.Key)
.OrderBy(n => n)))
{
throw new WebAPIDataServiceException("Keys don't match entity model", new KeyNotFoundException());
}
}
else
{
// build up keyvalue pairs from entitykeys
passedInKeys = segmentKeys.Zip(entityKeys,
(s, k) => new KeyValuePair<string, string>(k, s))
.ToArray();
}
// need to build the where clause
var type = GetIEdmTypeToCLRType(entityType);
var tSource = Expression.Parameter(type);
var bodyList = new List<Expression>();
foreach (var keyPairs in passedInKeys)
{
var tProperty = Expression.Property(tSource, keyPairs.Key);
var proptype = type.GetProperty(keyPairs.Key).PropertyType;
var keyValue = keyPairs.Value;
if (proptype == typeof (string))
{
// strings usually start with ' and end with ' in OData Calls
if (keyValue.StartsWith("'") && keyValue.EndsWith("'"))
{
keyValue = keyValue.Substring(1, keyValue.Length - 2);
}
}
// Since using EF going to parameterize this
var tupleType = typeof (Tuple<>).MakeGenericType(proptype);
var tuple = Activator.CreateInstance(tupleType,
Convert.ChangeType(keyValue, proptype));
bodyList.Add(Expression.Equal(tProperty,
Expression.Property(Expression.Constant(tuple),
"Item1")));
}
// build up the body expressions adding the And method between each check check
var body = bodyList[0];
for (var b = 1; b < bodyList.Count; b++)
{
body = Expression.And(body, bodyList[b]);
}
// Expression<Func<TSource, bool>> predicate
var where =
Expression.Lambda(typeof (Func<,>).MakeGenericType(type, typeof (bool)),
body,
tSource);
// Call the Queryable.Where
var call = Expression.Call(typeof (Queryable), "Where", new[] {type}, queryable.Expression, where);
// return back the IQueryable
return queryable.Provider.CreateQuery(call);
}
throw new WebAPIDataServiceException("Keys don't match entity model", new KeyNotFoundException());
}
public Task <T> GetFirtOrDefaultAsync(Expression <Func <T, bool> > predicate, params Expression <Func <T, object> >[] includes)
{
IQueryable <T> query = SetIncludeWithFilter(predicate, includes);
return(query.FirstOrDefaultAsync());
}
public Task <T> FirstOrDefaultAsync <T>(IQueryable <T> source)
{
return(EntityFrameworkQueryableExtensions.FirstOrDefaultAsync(source));
}
public static IQueryable<Recipient> Active(this IQueryable<Recipient> source) => source.Where(e => e.Active);
private void Init()
{
IQueryable <Achievement> achievements =
(new[]
{
new Achievement
{
Id = 1,
GameId = 1,
Name = "Achievement 1 for Game 1",
Description = "Achievement Description",
ImageUrl = "http://example.com/image.png"
},
new Achievement
{
Id = 2,
GameId = 1,
Name = "Achievement 2 for Game 1",
Description = "Achievement Description",
ImageUrl = "http://example.com/image.png"
},
new Achievement
{
Id = 3,
GameId = 1,
Name = "Achievement 3 for Game 1",
Description = "Achievement Description",
ImageUrl = "http://example.com/image.png"
},
new Achievement
{
Id = 4,
GameId = 2,
Name = "Achievement 1 for Game 2",
Description = "Achievement Description",
ImageUrl = "http://example.com/image.png"
},
new Achievement
{
Id = 5,
GameId = 2,
Name = "Achievement 2 for Game 2",
Description = "Achievement Description",
ImageUrl = "http://example.com/image.png"
}
}).AsQueryable();
IQueryable <Game> games =
(new[]
{
new Game {
Id = 1, Abbreviation = "game1", Name = "Game 1"
},
new Game {
Id = 2, Abbreviation = "game2", Name = "Game 2"
}
}).AsQueryable();
IQueryable <User> users =
(new[]
{
new User {
FacebookUserId = 1234567890, SteamUserId = "user1"
},
new User {
FacebookUserId = 1234567891, SteamUserId = "user2"
}
}).AsQueryable();
IQueryable <UserAchievement> userAchievements =
(new[]
{
new UserAchievement
{
Id = 1,
AchievementId = 1,
Date = DateTime.Now,
SteamUserId = "user1",
Achievement = achievements.Single(a => a.Id == 1)
},
new UserAchievement
{
Id = 2,
AchievementId = 2,
Date = DateTime.Now,
SteamUserId = "user1",
Achievement = achievements.Single(a => a.Id == 2)
},
new UserAchievement
{
Id = 3,
AchievementId = 3,
Date = DateTime.Now,
SteamUserId = "user1",
Achievement = achievements.Single(a => a.Id == 3)
}
}).AsQueryable();
Achievements = achievements;
Games = games;
UserAchievements = userAchievements;
Users = users;
}
public IQueryable <TEntity> Include <TEntity>(IQueryable <TEntity> source, string navigationPropertyPath) where TEntity : class
{
return(EntityFrameworkQueryableExtensions.Include(source, navigationPropertyPath));
}
public Task <T> FirstOrDefaultAsync <T>(IQueryable <T> source, Expression <Func <T, bool> > predicate)
{
return(EntityFrameworkQueryableExtensions.FirstOrDefaultAsync(source, predicate));
}
public Task <TSource> SingleOrDefaultAsync <TSource>(IQueryable <TSource> source, Expression <Func <TSource, bool> > predicate)
{
return(EntityFrameworkQueryableExtensions.SingleOrDefaultAsync(source, predicate));
}
public Task <int> CountAsync <T>(IQueryable <T> source, Expression <Func <T, bool> > predicate)
{
return(EntityFrameworkQueryableExtensions.CountAsync(source, predicate));
}
public void Country_Get_All()
{
//Arrange
data = new List<Country>() {
new Country() { Id = 1, Name = "US" },
new Country() { Id = 2, Name = "India" },
new Country() { Id = 3, Name = "Russia" }
}.AsQueryable();
mockContext = new Mock<IContext>();
mockSet = new Mock<IDbSet<Country>>();
mockSet.Setup(m => m.Provider).Returns(data.Provider);
mockSet.Setup(m => m.Expression).Returns(data.Expression);
mockSet.Setup(m => m.ElementType).Returns(data.ElementType);
mockSet.Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
mockContext.SetupGet(c => c.Countries).Returns(mockSet.Object);
_service = new CountryService(mockContext.Object);
//Act
IQueryable<Country> results = _service.GetAll() as IQueryable<Country>;
//Assert
Assert.IsNotNull(results);
Assert.AreEqual(3, results.ToList().Count);
}