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());
}
