/// <summary>
/// Filters a query based upon the predicate provided.
/// </summary>
/// <typeparam name="TSource">The type of ParseObject being queried for.</typeparam>
/// <param name="source">The base <see cref="ParseQuery{TSource}"/> to which
/// the predicate will be added.</param>
/// <param name="predicate">A function to test each ParseObject for a condition.
/// The predicate must be able to be represented by one of the standard Where
/// functions on ParseQuery</param>
/// <returns>A new ParseQuery whose results will match the given predicate as
/// well as the source's filters.</returns>
public static ParseQuery <TSource> Where <TSource>(
this ParseQuery <TSource> source, Expression <Func <TSource, bool> > predicate)
where TSource : ParseObject
{
// Handle top-level logic operators && and ||
var binaryExpression = predicate.Body as BinaryExpression;
if (binaryExpression != null)
{
if (binaryExpression.NodeType == ExpressionType.AndAlso)
{
return(source
.Where(Expression.Lambda <Func <TSource, bool> >(
binaryExpression.Left, predicate.Parameters))
.Where(Expression.Lambda <Func <TSource, bool> >(
binaryExpression.Right, predicate.Parameters)));
}
if (binaryExpression.NodeType == ExpressionType.OrElse)
{
var left = source.Where(Expression.Lambda <Func <TSource, bool> >(
binaryExpression.Left, predicate.Parameters));
var right = source.Where(Expression.Lambda <Func <TSource, bool> >(
binaryExpression.Right, predicate.Parameters));
return(left.Or(right));
}
}
var normalized = new WhereNormalizer().Visit(predicate.Body);
var methodCallExpr = normalized as MethodCallExpression;
if (methodCallExpr != null)
{
return(source.WhereMethodCall(predicate, methodCallExpr));
}
var binaryExpr = normalized as BinaryExpression;
if (binaryExpr != null)
{
return(source.WhereBinaryExpression(predicate, binaryExpr));
}
var unaryExpr = normalized as UnaryExpression;
if (unaryExpr != null && unaryExpr.NodeType == ExpressionType.Not)
{
var node = unaryExpr.Operand as MethodCallExpression;
if (IsParseObjectGet(node) && (node.Type == typeof(bool) || node.Type == typeof(bool?)))
{
// This is a raw boolean field access like 'where !obj.Get<bool>("foo")'
return(source.WhereNotEqualTo(GetValue(node.Arguments[0]) as string, true));
}
}
throw new InvalidOperationException(
"Encountered an unsupported expression for ParseQueries.");
}
public async Task<IList<Site>> GetSites(string searchText, double latitude = 0, double longitude = 0)
{
var sitesQuery = new ParseQuery<ApParseSite>()
.OrderByDescending(x => x.UseCount)
.Limit(100);
if (!string.IsNullOrEmpty(searchText))
{
var lowerSearchText = searchText.ToLower();
sitesQuery = sitesQuery.Where(s => s.Search.Contains(lowerSearchText));
}
else
{
sitesQuery = sitesQuery.WhereGreaterThan("UseCount", 1000);
}
var allSites = (await sitesQuery.FindAsync())
.Select(s => ConvertToSite(s, new ParseGeoPoint(latitude, longitude)));
// Remove duplicates
var siteIds = new HashSet<long>();
var sites = new List<Site>();
foreach (var site in allSites)
{
if (site.SiteId.HasValue)
{
if (!siteIds.Contains(site.SiteId.Value))
{
siteIds.Add(site.SiteId.Value);
sites.Add(site);
}
}
}
return sites
.OrderByDescending(s => s.DistanceKm)
.ThenBy(s => s.UseCount)
.ToList();
}
ParseQuery<ParseProduct> addProductVisibilityConditions(ParseQuery<ParseProduct> query)
{
var result = query.Where(p => p.NotVisible == false && p.Status == (int)ProductStatus.Approved && p.IsBlocked == false);
return result;
}
private ParseQuery<ParseProduct> getFilteredProductQuery(ParseQuery<ParseProduct> query, IProductFilter filter)
{
if (filter != null)
{
if (filter.Category != null)
{
query = query.Where(p => p.Category == ParseObject.CreateWithoutData<ParseProductCategory>(filter.Category.ID));
}
if (filter.Subcategory != null)
{
query = query.Where(p => p.Subcategory == ParseObject.CreateWithoutData<ParseProductSubcategory>(filter.Subcategory.ID));
}
if (filter.Country != null)
{
query = query.Where(p => p.Country == ParseObject.CreateWithoutData<ParseCountry>(filter.Country.ID));
}
if (filter.City != null)
{
query = query.Where(p => p.City == ParseObject.CreateWithoutData<ParseCity>(filter.City.ID));
}
if (filter.Tags != null && filter.Tags.Count > 0)
{
query = getContainsAllQuery(query, "tags", filter.Tags);
}
if (filter.StartPrice != null)
{
query = query.Where(p => p.Price >= filter.StartPrice.Value);
}
if (filter.EndPrice != null)
{
query = query.Where(p => p.Price <= filter.EndPrice.Value);
}
}
return query;
}
private async void updateTicket(string status)
{
try
{
ParseQuery<ParseObject> query = new ParseQuery<ParseObject>("HelpDeskTickets");
var q = await query.Where(obj => obj.ObjectId == t.ObjectId).FindAsync();
ParseObject ticket = q.First();
ticket["status"] = status;
await ticket.SaveAsync();
var xDoc = new XDocument(
new XElement("toast",
new XElement("visual",
new XElement("binding", new XAttribute("template", "ToastGeneric"),
new XElement("text", "SpartaHack 2016"),
new XElement("text", "Ticket Updated")
)
)
)
);
var xmlDoc = new Windows.Data.Xml.Dom.XmlDocument();
xmlDoc.LoadXml(xDoc.ToString());
var notifi = ToastNotificationManager.CreateToastNotifier();
notifi.Show(new ToastNotification(xmlDoc));
if (MainPage.rootFrame.CanGoBack)
MainPage.rootFrame.GoBack();
}
catch
{
}
}
private ParseQuery<ParseStore> getFilteredStoreQuery(ParseQuery<ParseStore> query, IStoreFilter filter)
{
if (filter != null)
{
if (filter.Category != null)
{
query = query.Where(s => s.Category == ParseObject.CreateWithoutData<ParseStoreCategory>(filter.Category.ID));
}
if (filter.Country != null)
{
query = query.Where(s => s.Country == ParseObject.CreateWithoutData<ParseCountry>(filter.Country.ID));
}
if (filter.City != null)
{
query = query.Where(s => s.City == ParseObject.CreateWithoutData<ParseCity>(filter.City.ID));
}
if (filter.Tags != null && filter.Tags.Count > 0)
{
query = getContainsAllQuery(query, "tags", filter.Tags);
}
}
return query;
}
public async Task<bool> CheckStoreNameIsReserved(string storeName, string currentStoreID = null)
{
using (var tokenSource = new CancellationTokenSource(Constants.DefaultTimeout))
{
var query = new ParseQuery<ReservedName>().Where(r => r.Name == storeName && r.Type == (int)ReservedNameType.Store);
var result = await query.FirstOrDefaultAsync(tokenSource.Token).ConfigureAwait(false);
if (result != null)
return true;
var storeQuery = new ParseQuery<ParseStore>().Where(s => s.LowercaseName == storeName).Select("objectId");
if (!string.IsNullOrEmpty(currentStoreID))
{
storeQuery = storeQuery.Where(s => s.ObjectId != currentStoreID);
}
var store = await storeQuery.FirstOrDefaultAsync(tokenSource.Token).ConfigureAwait(false);
if (store != null)
return true;
return false;
}
}