public void AddFields() { QueryOptions o = new QueryOptions().AddFields("f1", "f2"); Assert.AreEqual(2, o.Fields.Count); Assert.AreEqual("f1", o.Fields.First()); Assert.AreEqual("f2", o.Fields.ElementAt(1)); }
public ISolrQueryResults<BaseballGame> ExecuteQuery() { List<ISolrQuery> fieldQueries = new List<ISolrQuery>(); QueryOptions options = new QueryOptions(); options.Facet = BuildBaseFacetQuery(); options.Rows = 200; if (this.AppliedFacets.Count > 0) { var facetGroups = this.AppliedFacets.Select(t => t.Item1).Distinct().ToList(); foreach(var group in facetGroups) { List<ISolrQuery> queries = this.AppliedFacets.Where(fg => fg.Item1 == group).Select(q => new SolrQueryByField(q.Item1, q.Item2) as ISolrQuery).ToList(); SolrMultipleCriteriaQuery smcq = new SolrMultipleCriteriaQuery(queries,"OR"); fieldQueries.Add(smcq); } ISolrQuery multipleCriteriaQuery = new SolrMultipleCriteriaQuery(fieldQueries, "AND"); options.AddFilterQueries(multipleCriteriaQuery); } options.OrderBy.Add(new SortOrder(this.CurrentSortTerm, this.SortDirection == "D" ? Order.DESC : Order.ASC)); options.AddFilterQueries(new SolrQueryByField("docType", DocType.BaseballGame.ToString())); ISolrQuery finalQuery = SolrQuery.All; if (!string.IsNullOrEmpty(this.SearchTerm)) { finalQuery = new SolrQuery(this.SearchTerm); } return _solrOperations.Query(finalQuery, options); }
private async void BrowseButton_Click(object sender, RoutedEventArgs e) { try { var folderPicker = new FolderPicker() { CommitButtonText = "Open", SuggestedStartLocation = PickerLocationId.DocumentsLibrary, ViewMode = PickerViewMode.List }; folderPicker.FileTypeFilter.Add(".shp"); _folder = await folderPicker.PickSingleFolderAsync(); if (_folder != null) { var qopts = new QueryOptions(CommonFileQuery.OrderByName, new string[] { ".shp" }); var query = _folder.CreateFileQueryWithOptions(qopts); var files = await query.GetFilesAsync(); FileListCombo.ItemsSource = files; FileListCombo.Visibility = (files.Any()) ? Visibility.Visible : Visibility.Collapsed; } } catch (Exception ex) { var _ = new MessageDialog(ex.Message, "Sample Error").ShowAsync(); } }
public dynamic GetRealTimeData(QueryOptions queryOptions, string token) { using (var client = new HttpClient()) { client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token); var url = queryOptions.Dimensions == null ? string.Format( "https://content.googleapis.com/analytics/v3/data/realtime?ids={0}&metrics={1}", queryOptions.TableId, queryOptions.Metrics) : string.Format( "https://content.googleapis.com/analytics/v3/data/realtime?ids={0}&metrics={1}&dimensions={2}", queryOptions.TableId, queryOptions.Metrics, queryOptions.Dimensions); var result = client.GetAsync(url).GetAwaiter().GetResult(); switch (result.StatusCode) { case HttpStatusCode.Unauthorized: throw new UnauthorizedException(); case HttpStatusCode.BadRequest: throw new Exception("GetRealTimeData: Bad Request"); } var json = result.Content.ReadAsStringAsync().GetAwaiter().GetResult(); return JsonConvert.DeserializeObject(json); } }
public void Client_SetQueryOptions() { var client = new Client(); var opts = new QueryOptions() { Datacenter = "foo", Consistency = ConsistencyMode.Consistent, WaitIndex = 1000, WaitTime = new TimeSpan(0, 0, 100), Token = "12345" }; var request = client.CreateQuery("/v1/kv/foo", opts); try { request.Execute(); } catch (Exception) { // ignored } Assert.AreEqual("foo", request.Params["dc"]); Assert.IsTrue(request.Params.ContainsKey("consistent")); Assert.AreEqual("1000", request.Params["index"]); Assert.AreEqual("1m40s", request.Params["wait"]); Assert.AreEqual("12345", request.Params["token"]); }
public async Task KeepassFilesThatPassOrFail() { var queryOptions = new QueryOptions(CommonFileQuery.OrderByName, new[] { ".kdbx" }); queryOptions.FolderDepth = FolderDepth.Shallow; var samples = await Package.Current.InstalledLocation.GetFolderAsync("Samples"); var query = samples.CreateFileQueryWithOptions(queryOptions); IReadOnlyList<StorageFile> fileList = await query.GetFilesAsync(); var listOfFails = new List<object>(); foreach (var file in fileList) { string lastFileToTry = file.Name; try { await Scenarios.LoadDatabase(file, "password", null); } catch (Exception e) { listOfFails.Add(lastFileToTry); } } Assert.AreEqual(listOfFails.Count(), 7); }
/// <summary> /// </summary> /// <param name="dictPars">查询参数字典</param> /// <param name="start">分页开始标识</param> /// <param name="rows">每页数量</param> /// <param name="startTime">开始时间</param> /// <param name="endTime">结束时间</param> /// <param name="count">输出参数 总个数</param> /// <returns></returns> /// <remarks>peng.li 2015年7月23日14:11:43</remarks> public static List<int> GroupingSerach(Dictionary<string, string> dictPars, int start, int rows, DateTime startTime, DateTime endTime, out int count) { //定义solr var solr = ServiceLocator.Current.GetInstance<ISolrOperations<LogItems>>(); var queryOptions = new QueryOptions(); //定义分组 var groupingParameters = new GroupingParameters(); groupingParameters.Fields = new Collection<string> { "logs_id" }; groupingParameters.Ngroups = true; //设置查询分组的总个数为true //定义过滤条件 var timeRange = new SolrQueryByRange<DateTime>("logs_time", startTime, endTime); queryOptions.AddFilterQueries(timeRange); foreach (string key in dictPars.Keys) { queryOptions.AddFilterQueries(new SolrQueryByField(key, dictPars[key])); } //定义排序 queryOptions.OrderBy = new Collection<SortOrder> { new SortOrder("logs_id", Order.DESC) }; queryOptions.Grouping = groupingParameters; queryOptions.Start = start; queryOptions.Rows = rows; SolrQueryResults<LogItems> res = solr.Query(SolrQuery.All, queryOptions); GroupedResults<LogItems> items = res.Grouping["logs_id"]; count = items.Ngroups ?? 0; return items.Groups.Select(item => Convert.ToInt32(item.GroupValue)).ToList(); }
//public ObservableCollection<ImageItem> Source = new ObservableCollection<ImageItem>(); public async Task Init() { var queryOptions = new QueryOptions(CommonFileQuery.OrderByDate, new string[] { ".jpg", ".png", ".jpeg", ".bmp" }) { FolderDepth = FolderDepth.Deep, IndexerOption = IndexerOption.OnlyUseIndexer, UserSearchFilter = "System.Kind:=System.Kind#Picture" }; queryOptions.SetThumbnailPrefetch(ThumbnailMode.SingleItem, 256, ThumbnailOptions.UseCurrentScale); var _fileQueryResult = KnownFolders.PicturesLibrary.CreateFileQueryWithOptions(queryOptions); var files = await _fileQueryResult.GetFilesAsync(); Debug.WriteLine("Count " + files.Count); var list = new List<ImageItem>(); foreach (var f in files) { list.Add(new ImageItem() { LocalPath = f.Path }); } Source = new RangeCollection(list); Source.Init(); }
public virtual object Translate(LinqExpression expression, QueryOptions queryOptions) { this.rootCriteria = null; this.options = queryOptions; return TranslateInternal(expression); }
sealed protected override async Task DoCleanup(Regex pattern, DateTime threshold) { var toDelete = new List<StorageFile>(); foreach (var file in await _logFolder.GetFilesAsync()) { if (pattern.Match(file.Name).Success && file.DateCreated <= threshold) toDelete.Add(file); } var qo = new QueryOptions(CommonFileQuery.DefaultQuery, new [] {".zip"}) { FolderDepth = FolderDepth.Shallow, UserSearchFilter = "System.FileName:~<\"Log -\"" }; var query = ApplicationData.Current.TemporaryFolder.CreateFileQueryWithOptions(qo); var oldLogs = await query.GetFilesAsync(); toDelete.AddRange(oldLogs); // walk... foreach (var file in toDelete) { try { await file.DeleteAsync(); } catch (Exception ex) { InternalLogger.Current.Warn(string.Format("Failed to delete '{0}'.", file.Path), ex); } } }
public virtual object Translate(LinqExpression expression, ICriteria rootCriteria) { this.rootCriteria = rootCriteria; this.options = null; return TranslateInternal(expression); }
protected QueryOptions GetQueryOptions() { MembershipUser user = Membership.GetUser(); Guid ui; QueryOptions qo; if (user == null) ui = GetGuestId(); // Get the guest user id. else ui = (Guid)user.ProviderUserKey; qo = db.QueryOptions.FirstOrDefault(QueryOptions => QueryOptions.UserId.Equals(ui)); if (qo == null) { // create the default user profile qo = new QueryOptions { IncludeExternal = false, Databases = new List<Database>(), DataFields = new List<DataField>(), SortOptionId = 1, UserId = ui }; db.QueryOptions.Add(qo); db.SaveChanges(); } return qo; }
public static async Task<List<string>> GetMatchingFilesByPrefixAsync(string prefix, List<string> excludeFiles) { try { List<string> result = new List<string>(); var folder = ApplicationData.Current.LocalFolder; QueryOptions queryOptions = new QueryOptions(CommonFileQuery.DefaultQuery, new List<string>() { "*" }); queryOptions.UserSearchFilter = $"{prefix}*.*"; queryOptions.FolderDepth = FolderDepth.Shallow; queryOptions.IndexerOption = IndexerOption.UseIndexerWhenAvailable; StorageFileQueryResult queryResult = folder.CreateFileQueryWithOptions(queryOptions); IReadOnlyList<StorageFile> matchingFiles = await queryResult.GetFilesAsync(); if (matchingFiles.Count > 0) { result.AddRange( matchingFiles.Where(f => !excludeFiles.Contains(f.Name)).Select(f => f.Name) ); } return result; } catch (Exception ex) { Debug.WriteLine(ex); } return null; }
public void QueryOption() { var queryOption = new QueryOptions<FakeModel>(); queryOption.QueryExpressions.Add(f => f.Property1 == "Property1"); queryOption.QueryExpressions.Should().HaveCount(1); }
public void GivenQueryOptionForFakeModel_ShouldCastToAnotherFakeModel() { var queryOption = new QueryOptions<FakeModel>(); queryOption.QueryExpressions.Add(f => f.Property1 == "Value of Property1"); var output = queryOption.ToLogString(); Trace.WriteLine(output); }
public virtual object Translate(LinqExpression expression, QueryOptions queryOptions) { this.rootCriteria = null; this.options = queryOptions; Visit(expression); //ensure criteria var visitor = new RootVisitor(rootCriteria, session, true); visitor.Visit(expression); return visitor.Results; }
public async Task CanWriteKeePassFiles() { var queryOptions = new QueryOptions(CommonFileQuery.OrderByName, new[] { ".kdbx" }); queryOptions.FolderDepth = FolderDepth.Shallow; var samples = await Package.Current.InstalledLocation.GetFolderAsync("Samples2"); var query = samples.CreateFileQueryWithOptions(queryOptions); IReadOnlyList<StorageFile> fileList = await query.GetFilesAsync(); var writer = new Kdb4Writer(new Kdb4HeaderWriter(), new WinRTCrypto(), new MultiThreadedBouncyCastleCrypto(), new SHA256HasherRT(), new GZipFactoryRT()); var listOfFails = new List<object>(); foreach (var file in fileList) { PwDatabase database = null; string lastFileToTry = file.Name; await TryCleanup(lastFileToTry); try { database = await Scenarios.LoadDatabase(file, "password", null); var newFile = await KnownFolders.DocumentsLibrary.CreateFileAsync(lastFileToTry); await writer.Write(database, new WinRTFile(newFile)); await Scenarios.LoadDatabase(newFile, "password", null); } catch (FormatException e) { listOfFails.Add(lastFileToTry); } catch (Exception e) { if(Debugger.IsAttached) { Debugger.Break(); } Assert.Fail(); } finally { //TryCleanup(lastFileToTry); } } Assert.AreEqual(listOfFails.Count(), 7); }
public static MvcHtmlString BuildSortableLink(this HtmlHelper htmlHelper, string fieldName, string actionName, string sortField, QueryOptions queryOptions) { var urlHelper = new UrlHelper(htmlHelper.ViewContext.RequestContext); var isCurrentSortField = queryOptions.SortField == sortField; return new MvcHtmlString(string.Format("<a href=\"{0}\">{1} {2}</a>", urlHelper.Action(actionName, new { SortField = sortField, SortOrder = (isCurrentSortField && queryOptions.SortOrder == SortOrder.ASC)? SortOrder.DESC : SortOrder.ASC}), fieldName, BuildSortIcon(isCurrentSortField, queryOptions))); }
/// <summary> /// Gets a list of collaboration spaces, filtered and sorted according to the options /// </summary> /// <param name="options"></param> /// <returns></returns> public List<CollaborationSpace> GetCollaborationSpaces(QueryOptions options) { if (options == null) return _context.CollaborationSpaces.Take(20).ToList(); throw new InvalidOperationException("Query not supported"); //var positions = from p in m_ent.ProjectOpenPositions.Include("Band") // where p.ProjectOpenPositionId == openPositionId // select p; }
public void CollideRectangle(Vector3 position, Vector3 impulse, Vector3 size, QueryOptions options, float elasticity, Viewpoint viewpoint, out MultipleHits<CollisionResult> horizontalResults, out MultipleHits<CollisionResult> verticalResults) { Vector3 impulse1 = viewpoint == Viewpoint.Front || viewpoint == Viewpoint.Back ? new Vector3(impulse.X, 0.0f, 0.0f) : new Vector3(0.0f, 0.0f, impulse.Z); Vector3 impulse2 = new Vector3(0.0f, impulse.Y, 0.0f); Vector3 halfSize = size / 2f; horizontalResults = this.CollideEdge(position, impulse1, halfSize, Direction2D.Horizontal, options, elasticity, viewpoint); verticalResults = this.CollideEdge(position, impulse2, halfSize, Direction2D.Vertical, options, elasticity, viewpoint); if ((options & QueryOptions.Simple) == QueryOptions.Simple || BoxCollisionResultExtensions.AnyCollided(horizontalResults) || BoxCollisionResultExtensions.AnyCollided(verticalResults)) return; horizontalResults = this.CollideEdge(position + impulse2, impulse1, halfSize, Direction2D.Horizontal, options, elasticity, viewpoint); verticalResults = this.CollideEdge(position + impulse1, impulse2, halfSize, Direction2D.Vertical, options, elasticity, viewpoint); }
public List<Vehicle> Get(QueryOptions qo) { int start = QueryUtility.GetStart(qo); var vehicles = db.Vehicles. OrderBy(qo.Sort). Skip(start). Take(qo.PageSize); qo.TotalPages = QueryUtility.GetTotal(db.Vehicles.Count(), qo.PageSize); return vehicles.ToList(); }
private static Configuration GetConfig(QueryOptions queryOptions = null) { return new Configuration(new Policies(), new ProtocolOptions(), null, new SocketOptions(), new ClientOptions(), NoneAuthProvider.Instance, null, queryOptions ?? DefaultQueryOptions, new DefaultAddressTranslator()); }
private async void Initialize() { try { ProgressRingActive = true; StorageFolder picturesFolder = KnownFolders.PicturesLibrary; var query = CommonFileQuery.DefaultQuery; var queryOptions = new QueryOptions(query, new[] { ".png", ".jpg" }); queryOptions.FolderDepth = FolderDepth.Deep; var queryResult = picturesFolder.CreateFileQueryWithOptions(queryOptions); var files = await queryResult.GetFilesAsync(); //var files = await picturesFolder.GetFilesAsync(CommonFileQuery.OrderByDate); foreach (var f in files) { /* if (!ImageExtensions.Contains(Path.GetExtension(f.Name).ToUpperInvariant())) continue;*/ var stream = await f.OpenReadAsync(); streamList.Add((StorageFile) f); var bitmapImage = new BitmapImage(); #if PHONE await bitmapImage.SetSourceAsync(await f.GetScaledImageAsThumbnailAsync(ThumbnailMode.SingleItem,240,ThumbnailOptions.ResizeThumbnail)); #else await bitmapImage.SetSourceAsync(stream); #endif bitMapsList.Add(bitmapImage); pathes.Add(f.Path); await GetImageProperties((StorageFile) f); //thumbnails var thumbnailImage = new BitmapImage(); #if PHONE thumbnailImage.SetSource(await f.GetThumbnailAsync(ThumbnailMode.ListView,80)); #else thumbnailImage.SetSource(await f.GetThumbnailAsync(ThumbnailMode.PicturesView)); #endif thumbnailsList.Add(thumbnailImage); } if (bitMapsList.Count >= 1) { ImgSource = bitMapsList[currentBitmapIndex]; InformationsTextBlock = generateInformations(imageProps[currentBitmapIndex]); } } catch (Exception ex) { MessageDialog msg = new MessageDialog(ex.Message); await msg.ShowAsync(); } finally { ProgressRingActive = false; } }
public void RequestHandler_GetRequest_SimpleStatement_QueryOptions_Are_Used() { var stmt = new SimpleStatement("DUMMY QUERY"); Assert.AreEqual(0, stmt.PageSize); Assert.Null(stmt.ConsistencyLevel); var queryOptions = new QueryOptions().SetConsistencyLevel(ConsistencyLevel.LocalQuorum).SetPageSize(100); var request = (QueryRequest)RequestHandler<RowSet>.GetRequest(stmt, new Serializer(2), GetConfig(queryOptions)); Assert.AreEqual(100, request.PageSize); Assert.AreEqual(queryOptions.GetPageSize(), request.PageSize); Assert.AreEqual(queryOptions.GetConsistencyLevel(), request.Consistency); Assert.AreEqual(ConsistencyLevel.Any, request.SerialConsistency); }
public List<Author> Get(QueryOptions queryOptions) { var start = QueryOptionsCalculator.CalculateStart(queryOptions); var authors = db.Authors. OrderBy(queryOptions.Sort). Skip(start). Take(queryOptions.PageSize); queryOptions.TotalPages = QueryOptionsCalculator.CaclulateTotalPages(db.Authors.Count(), queryOptions.PageSize); return authors.ToList(); }
public async Task<PagedResult<CatalogEntryModel>> SearchAsync(QueryOptions options, string criteria = null) { var products = await _repositories.Products.Search(options, criteria); var models = products.Items.Select(product => new CatalogEntryModel { ProductId = product.Id, DateAdded = product.CreatedAt, Description = product.Description, Name = product.Name, QuantityAvailable = product.QuantityAvailable }); return new PagedResult<CatalogEntryModel>(models.ToList(), products.TotalRecords); }
public void ShouldFetchAndParseDocWithContent() { var queryOptions = new QueryOptions { FilterQueries = new[] { new SolrQueryByField("solr_id", "paragraph19338"), new SolrQueryByField("doc_type", "Paragraph") } }; var results = solr_searchable.Query(SolrQuery.All, queryOptions); Assert.AreEqual(1, results.NumFound); }
public static async Task<List<StorageFile>> LoadFolderFiles(StorageFolder storageFolder) { var queryOptions = new QueryOptions ( CommonFileQuery.OrderByName, new List<string> { ".3g2", ".3gp2", ".3gp", ".3gpp", ".m4a", ".m4v", ".mp4v", ".mp4", ".mov", ".m2ts", ".asf", ".wm", ".vob", ".wmv", ".wma", ".aac", ".adt", ".mp3", ".wav", ".avi", ".ac3", ".ec3" } ); var fileQuery = storageFolder.CreateFileQueryWithOptions(queryOptions); var ass = await fileQuery.GetFilesAsync(); return ass.ToList(); }
private static string BuildSortIcon(bool isCurrentSortField, QueryOptions queryOptions) { string sortIcon = "sort"; if (isCurrentSortField) { sortIcon += "-by-alphabet"; if (queryOptions.SortOrder == SortOrder.DESC.ToString()) sortIcon += "-alt"; } return string.Format("<span class=\"{0} {1}{2}\"></span>", "glyphicon", "glyphicon-", sortIcon); }
private static string BuildNextLink(UrlHelper urlHelper, QueryOptions queryOptions, string actionName) { //disable button, user click on disable button then do nothing if (queryOptions.CurrentPage == queryOptions.TotalPages) return "<a href=\"#\">Next <span aria-hidden=\"true\">→</span></a>"; return string.Format( "<a href=\"{0}\">Next <span aria-hidden=\"true\">→</span></a>", urlHelper.Action(actionName, new { SortOrder = queryOptions.SortOrder, SortField = queryOptions.SortField, CurrentPage = queryOptions.CurrentPage + 1, PageSize = queryOptions.PageSize })); }
public IEnumerable <T> List(QueryOptions <T> options) { throw new NotImplementedException(); }
protected override IQueryable OnOrder(IQueryable query, QueryOptions options) { return(((IQueryable <Bus>)query).OrderBy(x => x.Id)); }
protected override IQueryable OnSearch(IQueryable query, QueryOptions options) { string keyword = options.SearchKeyword; return(((IQueryable <Bus>)query).Where(x => x.Name.Contains(keyword) || x.Model.Contains(keyword))); }
/// <summary> /// Executes a query /// </summary> /// <param name="query"></param> /// <param name="options"></param> /// <returns></returns> public SolrQueryResults <T> Query(ISolrQuery query, QueryOptions options) { return(basicServer.Query(query, options)); }
public Task <SolrQueryResults <T> > QueryAsync(ISolrQuery query, QueryOptions options) => basicServer.QueryAsync(query, options);
//[Auth("AccountType_Get")] public List <AccountTypeGetDto> SelectAccountType(QueryOptions options) => Select <AccountType, AccountTypeGetDto>(options);
internal HttpMessage CreateDeleteEntityRequest(string table, string partitionKey, string rowKey, int?timeout, string requestId, QueryOptions queryOptions) { var message = _pipeline.CreateMessage(); var request = message.Request; request.Method = RequestMethod.Delete; var uri = new RawRequestUriBuilder(); uri.AppendRaw(url, false); uri.AppendPath("/", false); uri.AppendPath(table, true); uri.AppendPath("(PartitionKey='", false); uri.AppendPath(partitionKey, true); uri.AppendPath("',RowKey='", false); uri.AppendPath(rowKey, true); uri.AppendPath("')", false); if (timeout != null) { uri.AppendQuery("timeout", timeout.Value, true); } if (queryOptions?.Format != null) { uri.AppendQuery("$format", queryOptions.Format.Value.ToString(), true); } request.Uri = uri; request.Headers.Add("x-ms-version", version); if (requestId != null) { request.Headers.Add("x-ms-client-request-id", requestId); } request.Headers.Add("DataServiceVersion", "3.0"); if (queryOptions?.IfMatch != null) { request.Headers.Add(TableConstants.HeaderNames.IfMatch, queryOptions.IfMatch); } return(message); }
public async void getPhotos(JObject options, IPromise promise) { try { if (options["first"] == null) { promise.Reject(new ArgumentNullException("The option [first] must be defined.")); return; } if ((int)options["first"] < 1) { promise.Reject(new ArgumentException("The option [first] is not valid.")); return; } var limit = (uint)(options["first"]); // TODO: // after // mimeTypes, groupName if (options["groupTypes"] != null) { promise.Reject(new ArgumentException("The option [groupTypes] is not supported on UWP")); return; } QueryOptions queryOption; switch ((string)(options["assetType"])) { case "All": queryOption = new QueryOptions(CommonFileQuery.OrderByDate, SupportedVideoFileTypes .Concat(SupportedImageFileTypes) .ToList() ); break; case "Videos": queryOption = new QueryOptions(CommonFileQuery.OrderByDate, SupportedVideoFileTypes); break; case "Photos": default: queryOption = new QueryOptions(CommonFileQuery.OrderByDate, SupportedImageFileTypes); break; } StorageFolder picturesFolder = KnownFolders.CameraRoll; queryOption.FolderDepth = FolderDepth.Deep; IReadOnlyList <StorageFile> sortedItems = await picturesFolder .CreateFileQueryWithOptions(queryOption) .GetFilesAsync(0, limit); var result = new JObject(); var edges = new JArray(); var pageinfo = new JObject(); var endcursor = ""; foreach (StorageFile file in sortedItems) { var node = new JObject(); var nodeObj = new JObject(); var image = new JObject(); var location = new JObject(); var uri = new Uri(file.Path); ImageProperties imageProperties = await file.Properties.GetImagePropertiesAsync(); // Put ImageInfo image.Add("uri", uri); image.Add("width", imageProperties.Width); image.Add("height", imageProperties.Height); // Put BasicNodeInfo node.Add("image", image); node.Add("type", file.ContentType); node.Add("timestamp", imageProperties.DateTaken.ToUnixTimeSeconds()); node.Add("group_name", file.DisplayName); // Put LocationInfo if (imageProperties.Latitude != null && imageProperties.Longitude != null) { location.Add("latitude", imageProperties.Latitude); location.Add("longitude", imageProperties.Longitude); node.Add("location", location); } nodeObj.Add("node", node); edges.Add(nodeObj); endcursor = imageProperties.DateTaken.ToString(); } // Put PageInfo pageinfo.Add("has_next_page", limit < sortedItems.Count); pageinfo.Add("end_cursor", endcursor); // Put Edges result.Add("edges", edges); result.Add("page_info", pageinfo); promise.Resolve(result); } catch (Exception ex) { promise.Reject(new InvalidOperationException("CameraRoll.getPhotos()", ex)); } }
public void GetPath_LoopNoLoop() { var g = Assets.GetTinyLoopGraph(); _output.WriteLine(g.GetDot()); { var paths = g.GetPaths("a", "a1", options: QueryOptions.Default(4)).ToArray(); paths.Length.ShouldBe(3); var p0 = paths[0]; _output.WriteLine(p0.Print()); p0.Depth.ShouldBe(1); p0.Vertexes.Length.ShouldBe(1); p0.Edges.Length.ShouldBe(0); p0.Vertexes[0].Value.ShouldBe("A1"); var p1 = paths[1]; _output.WriteLine(p1.Print()); p1.Depth.ShouldBe(2); p1.Vertexes.Length.ShouldBe(2); p1.Edges.Length.ShouldBe(1); p1.Vertexes[0].Value.ShouldBe("A1"); p1.Edges[0].Value.ShouldBe("X1"); p1.Vertexes[1].Value.ShouldBe("A2"); var p2 = paths[2]; _output.WriteLine(p2.Print()); p2.Depth.ShouldBe(3); p2.Vertexes.Length.ShouldBe(3); p2.Edges.Length.ShouldBe(2); p2.Vertexes[0].Value.ShouldBe("A1"); p2.Edges[0].Value.ShouldBe("X1"); p2.Vertexes[1].Value.ShouldBe("A2"); p2.Edges[1].Value.ShouldBe("Z1"); p2.Vertexes[2].Value.ShouldBe("A1"); } { var paths = g.GetPaths("a", "a2", options: QueryOptions.Default(2)).ToArray(); paths.Length.ShouldBe(2); var p0 = paths[0]; _output.WriteLine(p0.Print()); p0.Depth.ShouldBe(1); p0.Vertexes.Length.ShouldBe(1); p0.Edges.Length.ShouldBe(0); p0.Vertexes[0].Value.ShouldBe("A2"); var p1 = paths[1]; _output.WriteLine(p1.Print()); p1.Depth.ShouldBe(2); p1.Vertexes.Length.ShouldBe(2); p1.Edges.Length.ShouldBe(1); p1.Vertexes[0].Value.ShouldBe("A2"); p1.Vertexes[1].Value.ShouldBe("A1"); p1.Edges[0].Value.ShouldBe("Z1"); } { var paths = g.GetPaths("a", "a2", options: QueryOptions.NoLoops(10)).ToArray(); paths.Length.ShouldBe(2); var p0 = paths[0]; _output.WriteLine(p0.Print()); p0.Depth.ShouldBe(1); p0.Vertexes.Length.ShouldBe(1); p0.Edges.Length.ShouldBe(0); p0.Vertexes[0].Value.ShouldBe("A2"); var p1 = paths[1]; _output.WriteLine(p1.Print()); p1.Depth.ShouldBe(2); p1.Vertexes.Length.ShouldBe(2); p1.Edges.Length.ShouldBe(1); p1.Vertexes[0].Value.ShouldBe("A2"); p1.Vertexes[1].Value.ShouldBe("A1"); p1.Edges[0].Value.ShouldBe("Z1"); } }
private static string isPreviousDisabled(QueryOptions queryOptions) { return((queryOptions.CurrentPage == 1) ? "disabled" : string.Empty); }
public async Task <ActivityPageModel> BuildActivityPageModelAsync(Guid siteId, Guid userId, QueryOptions options) { var user = await _dbContext.Users.FirstOrDefaultAsync(x => x.Id == userId); if (user == null) { return(null); } var result = new ActivityPageModel { User = new ActivityPageModel.UserModel { Id = user.Id, DisplayName = user.DisplayName } }; var query = _dbContext.Events.Where(x => x.SiteId == siteId && x.UserId == userId); if (!string.IsNullOrWhiteSpace(options.Search)) { query = query.Where(x => x.Type.Contains(options.Search) || x.TargetType.Contains(options.Search) || x.Data.Contains(options.Search)); } var events = await query .OrderByDescending(x => x.TimeStamp) .Skip(options.Skip) .Take(options.PageSize) .ToListAsync(); var items = new List <ActivityPageModel.EventModel>(); foreach (var @event in events) { var model = new ActivityPageModel.EventModel { Id = @event.Id, Type = @event.Type, TargetId = @event.TargetId, TargetType = @event.TargetType, TimeStamp = @event.TimeStamp }; var data = new Dictionary <string, string> { { nameof(@event.TargetId), @event.TargetId.ToString() } }; if (!string.IsNullOrWhiteSpace(@event.Data) && @event.Data != "null") { var parsedData = JObject.Parse(@event.Data); foreach (var x in parsedData) { if (x.Key == nameof(@event.Id) || x.Key == nameof(@event.TargetId) || x.Key == nameof(@event.TargetType) || x.Key == nameof(@event.SiteId) || x.Key == nameof(@event.UserId)) { continue; } var value = !string.IsNullOrWhiteSpace(x.Value.ToString()) ? x.Value.ToString() : "<null>"; data.Add(x.Key, value); } } model.Data = data; items.Add(model); } var totalRecords = await query.CountAsync(); result.Events = new PaginatedData <ActivityPageModel.EventModel>(items, totalRecords, options.PageSize); return(result); }
public async Task Initialize() { if (this.IsLoading) { return; } this.IsLoading = true; if ((null == DefaultPlaylist) || (null == CurrentPlaylist)) { // default playlist file path string defaultPath = Path.Combine(Package.Current.InstalledLocation.Path, "playlist.json"); try { // try to open and read it StorageFile defaultFile = await StorageFile.GetFileFromPathAsync(defaultPath); string fileContents = await FileIO.ReadTextAsync(defaultFile); // if we got some data if (!String.IsNullOrWhiteSpace(fileContents)) { // deserialize it DefaultPlaylist = JsonConvert.DeserializeObject<Playlist>(fileContents); } } catch (FileNotFoundException) { } // if we failed to load the defaults if (null == DefaultPlaylist) { // create them DefaultPlaylist = Playlist.CreateDefault(); } // find the first playlist file we can and load that as the current language IReadOnlyList<StorageFile> files = null; try { // file spec pattern; playlist files are named "playlist.json" string startsWith = "playlist"; // get the config object ConfigurationService configurationService = (ConfigurationService)SimpleIoc.Default.GetInstance<ConfigurationService>(); if (null != configurationService) { // get the folder where our playlist files are stored StorageFolder queryFolder = await configurationService.GetLocalStorageFolder(); // build query for json files QueryOptions options = new QueryOptions(CommonFileQuery.OrderByName, new List<string>() { ".json" }); StorageFileQueryResult query = queryFolder.CreateFileQueryWithOptions(options); // execute the query files = await query.GetFilesAsync(); // if we got results if ((null != files) && (files.Count > 0)) { // loop through them foreach (StorageFile file in files) { // find the first that matches our app prefix and optional language spec if (file.Name.StartsWith(startsWith, StringComparison.InvariantCultureIgnoreCase)) { // read its contents string fileContents = await FileIO.ReadTextAsync(file); // deserialize into our language object CurrentPlaylist = JsonConvert.DeserializeObject<Playlist>(fileContents); } } } } } catch (Exception ex) { } // if we failed to load the current language if (null == CurrentPlaylist) { // set it to the default CurrentPlaylist = DefaultPlaylist; } } this.IsLoaded = true; this.IsLoading = false; }
/// <summary> /// Apply paging from query options /// </summary> /// <param name="querable"></param> /// <param name="queryOptions"></param> /// <returns></returns> public static SQLinq.SQLinq <TEntity> ApplyQueryOptions <TEntity>(this SQLinq.SQLinq <TEntity> querable, QueryOptions queryOptions = null) { if (querable == null || queryOptions == null) { return(querable); } querable = querable.Skip(queryOptions.PageSize * (queryOptions.Page - 1)) .Take(queryOptions.PageSize); return(querable); }
public static QueryOptions ParseOptions(IMVCGridDefinition grid, NameValueCollection queryString) { string qsKeyPage = grid.QueryStringPrefix + QueryStringSuffix_Page; string qsKeySort = grid.QueryStringPrefix + QueryStringSuffix_Sort; string qsKeyDirection = grid.QueryStringPrefix + QueryStringSuffix_SortDir; string qsKeyEngine = grid.QueryStringPrefix + QueryStringSuffix_Engine; string qsKeyPageSize = grid.QueryStringPrefix + QueryStringSuffix_ItemsPerPage; string qsColumns = grid.QueryStringPrefix + QueryStringSuffix_Columns; var options = new QueryOptions(); if (queryString[qsKeyEngine] != null) { string re = queryString[qsKeyEngine]; options.RenderingEngineName = re; } if (!grid.Paging) { options.ItemsPerPage = null; options.PageIndex = null; } else { options.ItemsPerPage = grid.ItemsPerPage; if (grid.AllowChangingPageSize) { if (queryString[qsKeyPageSize] != null) { int pageSize; if (Int32.TryParse(queryString[qsKeyPageSize], out pageSize)) { options.ItemsPerPage = pageSize; } } if (grid.MaxItemsPerPage.HasValue && grid.MaxItemsPerPage.Value < options.ItemsPerPage) { options.ItemsPerPage = grid.MaxItemsPerPage.Value; } } if (options.ItemsPerPage <= 0) { options.ItemsPerPage = 20; } options.PageIndex = 0; if (queryString[qsKeyPage] != null) { int pageNum; if (Int32.TryParse(queryString[qsKeyPage], out pageNum)) { options.PageIndex = pageNum - 1; if (options.PageIndex < 0) { options.PageIndex = 0; } } } } if (!grid.Filtering) { //options.Filters } else { var filterableColumns = grid.GetColumns().Where(p => p.EnableFiltering); foreach (var col in filterableColumns) { string qsKey = grid.QueryStringPrefix + col.ColumnName; if (queryString[qsKey] != null) { string filterValue = queryString[qsKey]; if (!String.IsNullOrWhiteSpace(filterValue)) { options.Filters.Add(col.ColumnName, filterValue); } } } } if (!grid.Sorting) { options.SortColumnName = null; options.SortColumnData = null; options.SortDirection = SortDirection.Unspecified; } else { options.SortColumnName = null; string sortColName = null; if (queryString[qsKeySort] != null) { sortColName = queryString[qsKeySort]; } if (String.IsNullOrWhiteSpace(sortColName)) { sortColName = grid.DefaultSortColumn; } string thisSortColName = sortColName.Trim().ToLower(); // validate SortColumn var colDef = grid.GetColumns().SingleOrDefault(p => p.ColumnName.ToLower() == thisSortColName); if (colDef != null && !colDef.EnableSorting) { colDef = null; } if (colDef != null) { options.SortColumnName = colDef.ColumnName; options.SortColumnData = colDef.SortColumnData; } options.SortDirection = grid.DefaultSortDirection; if (queryString[qsKeyDirection] != null) { string sortDir = queryString[qsKeyDirection]; if (String.Compare(sortDir, "dsc", true) == 0) { options.SortDirection = SortDirection.Dsc; } else if (String.Compare(sortDir, "asc", true) == 0) { options.SortDirection = SortDirection.Asc; } } } if (grid.AdditionalQueryOptionNames.Count > 0) { foreach (var aqon in grid.AdditionalQueryOptionNames) { string qsKeyAQO = grid.QueryStringPrefix + aqon; string val = ""; if (queryString[qsKeyAQO] != null) { val = queryString[qsKeyAQO]; } options.AdditionalQueryOptions.Add(aqon, val); } } if (grid.PageParameterNames.Count > 0) { foreach (var aqon in grid.PageParameterNames) { string qsKeyAQO = QueryStringPrefix_PageParameter + grid.QueryStringPrefix + aqon; string val = ""; if (queryString[qsKeyAQO] != null) { val = queryString[qsKeyAQO]; } options.PageParameters.Add(aqon, val); } } var gridColumns = grid.GetColumns(); List <ColumnVisibility> requestedColumns = new List <ColumnVisibility>(); if (queryString[qsColumns] == null) { foreach (var gridColumn in gridColumns) { requestedColumns.Add( new ColumnVisibility() { ColumnName = gridColumn.ColumnName, Visible = gridColumn.Visible }); } } else { string cols = queryString[qsColumns]; string[] colParts = cols.Split(',', ';'); foreach (var colPart in colParts) { if (String.IsNullOrWhiteSpace(colPart)) { continue; } string thisColPart = colPart.ToLower().Trim(); var gridColumn = gridColumns.SingleOrDefault(p => p.ColumnName.ToLower() == thisColPart); if (gridColumn != null) { if (requestedColumns.SingleOrDefault(p => p.ColumnName == gridColumn.ColumnName) == null) { requestedColumns.Add( new ColumnVisibility() { ColumnName = gridColumn.ColumnName, Visible = true }); } } } } foreach (var gridColumn in gridColumns) { var requestedCol = requestedColumns.SingleOrDefault(p => p.ColumnName == gridColumn.ColumnName); if (requestedCol == null) { requestedCol = new ColumnVisibility() { ColumnName = gridColumn.ColumnName, Visible = false }; requestedColumns.Add(requestedCol); } if (!requestedCol.Visible && gridColumn.Visible && !gridColumn.AllowChangeVisibility) { requestedCol.Visible = true; } } options.ColumnVisibility.AddRange(requestedColumns); return(options); }
public T Get(QueryOptions <T> options) { throw new NotImplementedException(); }
// Should be unnecessary when https://github.com/Azure/azure-rest-api-specs/pull/8151/files#r415950870 is implemented. internal HttpMessage CreateQueryEntitiesRequest(string table, int?timeout, string requestId, QueryOptions queryOptions) { var message = _pipeline.CreateMessage(); var request = message.Request; request.Method = RequestMethod.Get; var uri = new RawRequestUriBuilder(); uri.AppendRaw(url, false); uri.AppendPath("/", false); uri.AppendPath(table, true); uri.AppendPath("()", false); if (timeout != null) { uri.AppendQuery("timeout", timeout.Value, true); } if (queryOptions?.Format != null) { uri.AppendQuery("$format", queryOptions.Format.Value.ToString(), true); } if (queryOptions?.Top != null) { uri.AppendQuery("$top", queryOptions.Top.Value, true); } if (queryOptions?.Select != null) { uri.AppendQuery("$select", queryOptions.Select, true); } if (queryOptions?.Filter != null) { uri.AppendQuery("$filter", queryOptions.Filter, true); } if (queryOptions?.NextPartitionKey != null) { uri.AppendQuery(TableConstants.QueryParameterNames.NextPartitionKey, queryOptions.NextPartitionKey, true); } if (queryOptions?.NextRowKey != null) { uri.AppendQuery(TableConstants.QueryParameterNames.NextRowKey, queryOptions.NextRowKey, true); } request.Uri = uri; request.Headers.Add("x-ms-version", version); if (requestId != null) { request.Headers.Add("x-ms-client-request-id", requestId); } request.Headers.Add("DataServiceVersion", "3.0"); return(message); }
public static int CalculateStart(QueryOptions queryOptions) { return((queryOptions.CurrentPage - 1) * queryOptions.PageSize); }
// All Merge related methods Should be unnecessary when https://github.com/Azure/azure-rest-api-specs/pull/8151/files/f5cb6fb416ae0a06329599db9dc17c8fdd7f95c7#r417331328 is implemented. internal HttpMessage CreateMergeEntityRequest(string table, string partitionKey, string rowKey, int?timeout, string requestId, IDictionary <string, object> tableEntityProperties, QueryOptions queryOptions) { var message = _pipeline.CreateMessage(); var request = message.Request; request.Method = new RequestMethod("MERGE"); var uri = new RawRequestUriBuilder(); uri.AppendRaw(url, false); uri.AppendPath("/", false); uri.AppendPath(table, true); uri.AppendPath("(PartitionKey='", false); uri.AppendPath(partitionKey, true); uri.AppendPath("',RowKey='", false); uri.AppendPath(rowKey, true); uri.AppendPath("')", false); if (timeout != null) { uri.AppendQuery("timeout", timeout.Value, true); } if (queryOptions?.Format != null) { uri.AppendQuery("$format", queryOptions.Format.Value.ToString(), true); } request.Uri = uri; request.Headers.Add("x-ms-version", version); if (requestId != null) { request.Headers.Add("x-ms-client-request-id", requestId); } request.Headers.Add("DataServiceVersion", "3.0"); request.Headers.Add("Content-Type", "application/json;odata=nometadata"); if (queryOptions?.IfMatch != null) { request.Headers.Add(TableConstants.HeaderNames.IfMatch, queryOptions.IfMatch); } if (tableEntityProperties != null) { using var content = new Utf8JsonRequestContent(); content.JsonWriter.WriteStartObject(); foreach (var item in tableEntityProperties) { content.JsonWriter.WritePropertyName(item.Key); content.JsonWriter.WriteObjectValue(item.Value); } content.JsonWriter.WriteEndObject(); request.Content = content; } return(message); }
/// <summary> /// Executes a query /// </summary> /// <param name="q"></param> /// <param name="options"></param> /// <returns></returns> public SolrQueryResults <T> Query(string q, QueryOptions options) { return(basicServer.Query(new SolrQuery(q), options)); }
public IActionResult Index(QueryOptions options, HotelSearchedByNameViewModel model) { return(View(_repository.Hotels(options, model.Hotelid, true))); }
public Task <SolrQueryResults <T> > QueryAsync(ISolrQuery query, QueryOptions options, CancellationToken cancellationToken = default(CancellationToken)) { return(this.queryExecuter.ExecuteAsync(query, options, cancellationToken)); }
public Task <SolrQueryResults <T> > QueryAsync(string q, QueryOptions options) => QueryAsync(new SolrQuery(q), options);
public SolrQueryResults <T> Query(ISolrQuery query, QueryOptions options) { return(queryExecuter.Execute(query, options)); }
/// <summary> Merge entity in a table. </summary> /// <param name="table"> The name of the table. </param> /// <param name="partitionKey"> The partition key of the entity. </param> /// <param name="rowKey"> The row key of the entity. </param> /// <param name="timeout"> The The timeout parameter is expressed in seconds. For more information, see <a href="https://docs.microsoft.com/en-us/rest/api/storageservices/setting-timeouts-for-queue-service-operations>Setting Timeouts for Queue Service Operations.</a>. </param> /// <param name="requestId"> Provides a client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage analytics logging is enabled. </param> /// <param name="tableEntityProperties"> The properties for the table entity. </param> /// <param name="queryOptions"> Parameter group. </param> /// <param name="cancellationToken"> The cancellation token to use. </param> public ResponseWithHeaders <TableInternalMergeEntityHeaders> MergeEntity(string table, string partitionKey, string rowKey, int?timeout = null, string requestId = null, IDictionary <string, object> tableEntityProperties = null, QueryOptions queryOptions = null, CancellationToken cancellationToken = default) { if (table == null) { throw new ArgumentNullException(nameof(table)); } if (partitionKey == null) { throw new ArgumentNullException(nameof(partitionKey)); } if (rowKey == null) { throw new ArgumentNullException(nameof(rowKey)); } using var scope = _clientDiagnostics.CreateScope("TableInternalClient.UpdateEntity"); scope.Start(); try { using var message = CreateMergeEntityRequest(table, partitionKey, rowKey, timeout, requestId, tableEntityProperties, queryOptions); _pipeline.Send(message, cancellationToken); var headers = new TableInternalMergeEntityHeaders(message.Response); switch (message.Response.Status) { case 204: return(ResponseWithHeaders.FromValue(headers, message.Response)); default: throw _clientDiagnostics.CreateRequestFailedException(message.Response); } } catch (Exception e) { scope.Failed(e); throw; } }
public IActionResult Index(QueryOptions options) { //System.Console.Clear(); //return View(repository.Products as IQueryable<Product>) ; return(View(repository.GetProducts(options))); }
public async ValueTask <ResponseWithHeaders <TableQueryResponse, TableInternalQueryHeaders> > QueryAsync(string requestId = null, QueryOptions queryOptions = null, CancellationToken cancellationToken = default) { using var scope = _clientDiagnostics.CreateScope("TableInternalClient.Query"); scope.Start(); try { using var message = CreateQueryRequest(requestId, queryOptions); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); var headers = new TableInternalQueryHeaders(message.Response); switch (message.Response.Status) { case 200: { TableQueryResponse value = default; using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false); if (document.RootElement.ValueKind == JsonValueKind.Null) { value = null; } else { value = TableQueryResponse.DeserializeTableQueryResponse(document.RootElement); } return(ResponseWithHeaders.FromValue(value, headers, message.Response)); }
private async void FrameCapture() { RenderComplete.Visibility = Visibility.Collapsed; composition = new MediaComposition(); List <string> fileTypeFilter = new List <string>(); fileTypeFilter.Add("*"); QueryOptions queryOptions = new QueryOptions(CommonFileQuery.DefaultQuery, fileTypeFilter); queryOptions.UserSearchFilter = "Lapses"; StorageFileQueryResult z = PictureLapsesFolder.CreateFileQueryWithOptions(queryOptions); IReadOnlyList <StorageFile> files = await z.GetFilesAsync(); if (files.Count == 0) { NoFiles.Visibility = Visibility.Visible; return; } files.OrderBy(x => x.DateCreated); String framesPS = (FramesPerSecond.SelectedIndex + 1).ToString("D2"); string desiredName = "Rendered-" + framesPS + "-FPS.mp4"; StorageFolder localFolder = ProjectFolder; Windows.Storage.StorageFile pickedVidFile = await localFolder.CreateFileAsync(desiredName, CreationCollisionOption.GenerateUniqueName); DarnSeconds q = (DarnSeconds)((ComboBoxItem)FramesPerSecond.SelectedItem).Tag; foreach (StorageFile j in files) { if (j == null) { //ShowErrorMessage("File picking cancelled"); return; } // These files could be picked from a location that we won't have access to later var storageItemAccessList = Windows.Storage.AccessCache.StorageApplicationPermissions.FutureAccessList; //torageItemAccessList.Add(pickedFile); var clip = await MediaClip.CreateFromImageFileAsync(j, TimeSpan.FromMilliseconds(q.HowManyDarnSeconds)); composition.Clips.Add(clip); } await composition.RenderToFileAsync(pickedVidFile); RenderComplete.Visibility = Visibility.Visible; //await composition.SaveAsync(MediaStreamSample); }
// GET api/<controller> public async Task <IEnumerable <BusInfo> > Get([FromUri] QueryOptions queryOptions) { return(Map <IList <BusInfo> >(await ApplyQueryOptions(Buses, queryOptions) .AsNoTracking().ToArrayAsync())); }
//[Auth("AccountType_Get")] public int CountOfAccountType(QueryOptions options) => Count <AccountType>(options);
internal override IList <IEnumerable <KeyValuePair <long, TSource> > > GetOrderedEnumerables(QueryOptions options) { var first = Parent.GetOrderedEnumerables(options); var second = Second.GetOrderedEnumerables(options); var checker = new ConcurrentDictionary <TSource, object> (comparer); InitConcurrentDictionary(checker, second, (e) => e.Value); return(first .Select((f, i) => GetEnumerable <KeyValuePair <long, TSource> > (f, second[i], checker, (e) => e.Value)) .ToList()); }