public List <Record> SearchTitle(string title) { Console.WriteLine("SearchingTitle:" + title); var result = records.Find(filterBuilder.Regex(record => record.title, new BsonRegularExpression(title, "i"))); return(result.ToList()); }
public override FilterDefinition <MongoContentEntity> Visit(SingleValueFunctionCallNode nodeIn) { var fieldNode = nodeIn.Parameters.ElementAt(0); var valueNode = nodeIn.Parameters.ElementAt(1); if (nodeIn.Name == "endswith") { var value = BuildRegex(valueNode, v => v + "$"); return(Filter.Regex(BuildFieldDefinition(fieldNode), value)); } if (nodeIn.Name == "startswith") { var value = BuildRegex(valueNode, v => "^" + v); return(Filter.Regex(BuildFieldDefinition(fieldNode), value)); } if (nodeIn.Name == "contains") { var value = BuildRegex(valueNode, v => v); return(Filter.Regex(BuildFieldDefinition(fieldNode), value)); } throw new NotSupportedException(); }
public override FilterDefinition <MongoContentEntity> Visit(SingleValueFunctionCallNode nodeIn) { var fieldNode = nodeIn.Parameters.ElementAt(0); var valueNode = nodeIn.Parameters.ElementAt(1); if (string.Equals(nodeIn.Name, "endswith", StringComparison.OrdinalIgnoreCase)) { var value = BuildRegex(valueNode, v => v + "$"); return(Filter.Regex(BuildFieldDefinition(fieldNode), value)); } if (string.Equals(nodeIn.Name, "startswith", StringComparison.OrdinalIgnoreCase)) { var value = BuildRegex(valueNode, v => "^" + v); return(Filter.Regex(BuildFieldDefinition(fieldNode), value)); } if (string.Equals(nodeIn.Name, "contains", StringComparison.OrdinalIgnoreCase)) { var value = BuildRegex(valueNode, v => v); return(Filter.Regex(BuildFieldDefinition(fieldNode), value)); } throw new NotSupportedException(); }
public async Task <List <LinkTable> > GetSearch(string line)//выборка для общего списка { // строитель фильтров var builder = new FilterDefinitionBuilder <LinkTable>(); var filters = builder.Or(builder.Regex("Longlink", line), builder.Regex("Shortlink", line)); // фильтр для выборки всех документов return(await Links.Find(filters).ToListAsync()); }
public void AddFavorityGenreToFantasyBooks() { var filter = _filter.Regex(BooksTableFieldNames.Genre, "fantasy") & _filter.Regex(BooksTableFieldNames.Genre, "^((?!favority).)*$"); var update = _update.AddToSet(BooksTableFieldNames.Genre, "favority"); _context.Books.UpdateMany(filter, update); }
public override FilterDefinition <T> Visit(CompareFilter <ClrValue> nodeIn, None args) { var propertyName = nodeIn.Path.ToString(); var value = nodeIn.Value.Value; switch (nodeIn.Operator) { case CompareOperator.Empty: return(Filter.Or( Filter.Exists(propertyName, false), Filter.Eq <object?>(propertyName, null), Filter.Eq <object?>(propertyName, string.Empty), Filter.Size(propertyName, 0))); case CompareOperator.Exists: return(Filter.And( Filter.Exists(propertyName, true), Filter.Ne <object?>(propertyName, null))); case CompareOperator.Matchs: return(Filter.Regex(propertyName, BuildMatchRegex(nodeIn))); case CompareOperator.StartsWith: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => "^" + s))); case CompareOperator.Contains: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s))); case CompareOperator.EndsWith: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s + "$"))); case CompareOperator.Equals: return(Filter.Eq(propertyName, value)); case CompareOperator.GreaterThan: return(Filter.Gt(propertyName, value)); case CompareOperator.GreaterThanOrEqual: return(Filter.Gte(propertyName, value)); case CompareOperator.LessThan: return(Filter.Lt(propertyName, value)); case CompareOperator.LessThanOrEqual: return(Filter.Lte(propertyName, value)); case CompareOperator.NotEquals: return(Filter.Ne(propertyName, value)); case CompareOperator.In: return(Filter.In(propertyName, ((IList)value !).OfType <object>())); } throw new NotSupportedException(); }
public static IList <BsonDocument> GetSrmStartEventsForWorker(int workerId, IMongoCollection <BsonDocument> collection) { var filter = Query.And(Query.Eq("worker", workerId), Query.Eq("k", "msg"), Query.Regex("v", new BsonRegularExpression("^Resource Manager: listening on port"))); return(collection.Find(filter).ToList()); }
public static Dictionary <int, IList <BsonDocument> > GetQueriesBySessionIdForLogfile(string file, IMongoCollection <BsonDocument> collection) { Dictionary <int, IList <BsonDocument> > queryLinesBySession = new Dictionary <int, IList <BsonDocument> >(); var filter = Query.And( Query.Eq("file", file), Query.Or(Query.Regex("message", new BsonRegularExpression("QueryExecute")), Query.Regex("message", new BsonRegularExpression("StatementPrepare")), Query.Regex("message", new BsonRegularExpression("StatementExecute")))); var cursor = collection.Find(filter).ToCursor(); foreach (var document in cursor.ToEnumerable()) { string message = BsonDocumentHelper.GetString("message", document); if (String.IsNullOrWhiteSpace(message)) { continue; } // Get the first space-delimited segment in the message. int indexOfSpace = message.IndexOf(' '); if (indexOfSpace == -1) { var line = BsonDocumentHelper.GetInt("line", document); Log.WarnFormat("Failed to find expected session ID in message '{0}'. ({1}:{2}) Skipping event..", message, file, line); continue; } string firstMessageSegment = message.Substring(0, indexOfSpace); // Get Session ID out of the segment. int sessionId = 0; bool parsedSessionId = false; if (!String.IsNullOrWhiteSpace(firstMessageSegment)) { string sessionIdString = firstMessageSegment.Replace("Session", "").Replace(":", ""); parsedSessionId = Int32.TryParse(sessionIdString, out sessionId); } if (!parsedSessionId) { var line = BsonDocumentHelper.GetInt("line", document); Log.WarnFormat("Failed to parse expected session ID in message '{0}'. ({1}:{2}) Skipping event..", message, file, line); continue; } if (!queryLinesBySession.ContainsKey(sessionId)) { queryLinesBySession[sessionId] = new List <BsonDocument>(); } queryLinesBySession[sessionId].Add(document); } return(queryLinesBySession); }
public async Task DeleteByPrefixAsync(string prefix, CancellationToken ct = default) { var name = GetFileName(prefix, nameof(prefix)); try { var match = new BsonRegularExpression($"^{name}"); var fileQuery = await bucket.FindAsync(Filters.Regex(x => x.Id, match), cancellationToken : ct); await fileQuery.ForEachAsync(async file => { try { await bucket.DeleteAsync(file.Id, ct); } catch (GridFSFileNotFoundException) { return; } }, ct); } catch (GridFSFileNotFoundException) { return; } }
private FilterDefinition <ToDoListEntity> ApplyWhereStatement(FilterDefinitionBuilder <ToDoListEntity> builder, ListQueryDataStructure queryDataStructure) { FilterDefinition <ToDoListEntity> filter = builder.Ne(x => x.Status, (int)ToDoListStatus.Archived); if (queryDataStructure.Id.HasValue) { filter = filter & (builder.Eq(x => x.Id, queryDataStructure.Id.Value)); } if (queryDataStructure.UserId.HasValue) { filter = filter & (builder.Eq(x => x.UserId, queryDataStructure.UserId.Value)); } if (!string.IsNullOrWhiteSpace(queryDataStructure.Name)) { filter = filter & (builder.Regex(x => x.Name, queryDataStructure.Name)); } if (queryDataStructure.Statuses != null && queryDataStructure.Statuses.Any()) { filter = filter & (builder.In(x => x.Status, queryDataStructure.Statuses)); } return(filter); }
public async Task <IReadOnlyList <IConfigurationEntry> > GetEntries(string component, ConfigurationPath pathPrefix, bool forPages = false, bool recursive = true) { var filterBuilder = new FilterDefinitionBuilder <MongoDbConfigurationDocument>(); if (string.IsNullOrWhiteSpace(component)) { component = "root"; } var filter = filterBuilder.Eq(a => a.Component, component); if (!ConfigurationPath.IsNullOrEmpty(pathPrefix)) { filter = recursive ? filterBuilder.Regex(a => a.Path, new Regex(pathPrefix.ToString(asPrefix: true))) : filterBuilder.Eq(a => a.Path, pathPrefix.ToString()); } if (forPages) { filter = filter & filterBuilder.Eq(a => a.VisibleToPages, true); } var results = await settingsCollectionData.FindAsync(filter); var records = await results.ToListAsync(); return(records.Select(doc => RebuildConfigurationEntry(doc)).ToList()); }
private FilterDefinition <ForumQuestionItem> GetRegexFilter( FilterDefinitionBuilder <ForumQuestionItem> builder, string prop, string term ) { return(builder.Regex(prop, new BsonRegularExpression("/" + term + "/is") )); }
private List <Book> GetBooksOfFantasyGenre() { var filter = _filter.Regex(BooksTableFieldNames.Genre, "fantasy"); return(_context.Books.Find(filter).ToEnumerable() .Select(doc => BookConverter.ConvertDocumentToBook(doc)) .ToList()); }
/// <summary> /// Creates a regular expression filter to perform a case-insensitive search. /// </summary> /// <typeparam name="T">The data object type.</typeparam> /// <param name="filter">The filter definition builder.</param> /// <param name="propertyPath">The property path.</param> /// <param name="propertyValue">The property value.</param> /// <returns>The regular expression filter definition.</returns> public static FilterDefinition <T> EqIgnoreCase <T>(this FilterDefinitionBuilder <T> filter, string propertyPath, string propertyValue) { if (string.IsNullOrEmpty(propertyPath) || propertyValue == null) { return(null); } return(filter.Regex(propertyPath, new BsonRegularExpression("^" + Regex.Escape(propertyValue) + "$", "i"))); }
private FilterDefinition <MessageJournalEntryDocument> BuildFilter(MessageJournalFilter filter, FilterDefinition <MessageJournalEntryDocument> filterDef, FilterDefinitionBuilder <MessageJournalEntryDocument> fb) { if (filter == null) { return(filterDef); } if (filter.Topics.Any()) { var topics = filter.Topics.Select(Normalize); filterDef = filterDef & fb.In(e => e.Topic, topics); } if (filter.Categories.Any()) { var categories = filter.Categories.Select(Normalize); filterDef = filterDef & fb.In(e => e.Category, categories); } if (filter.From != null) { filterDef = filterDef & fb.Gte(e => e.Timestamp, filter.From); } if (filter.To != null) { filterDef = filterDef & fb.Lte(e => e.Timestamp, filter.To); } if (filter.Origination != null) { var origination = Normalize(filter.Origination); filterDef = filterDef & fb.Eq(e => e.Origination, origination); } if (filter.Destination != null) { var destination = Normalize(filter.Destination); filterDef = filterDef & fb.Eq(e => e.Destination, destination); } if (!string.IsNullOrWhiteSpace(filter.MessageName)) { var partial = Normalize(filter.MessageName); var pattern = ".*" + Regex.Escape(partial) + ".*"; var regex = new BsonRegularExpression(pattern, "i"); filterDef = filterDef & fb.Regex(e => e.MessageName, regex); } if (filter.RelatedTo != null) { var relatedTo = Normalize(filter.RelatedTo); filterDef = filterDef & fb.Eq(e => e.RelatedTo, relatedTo); } return(filterDef); }
public async Task <PublicCompanyDataModel> GetCompanyById(string companyname) { var filter = _builder.Regex(e => e.CompanyName, $"/^{companyname}$/i"); var mongouser = await _context.Companies.Find(filter).FirstOrDefaultAsync(); var returnuser = _mapper.Map <PublicCompanyDataModel>(mongouser); return(returnuser); }
public override FilterDefinition <T> Visit(FilterComparison nodeIn) { var propertyName = string.Join(".", nodeIn.Lhs); switch (nodeIn.Operator) { case FilterOperator.Empty: return(Filter.Or(Filter.Exists(propertyName, false), Filter.Eq(propertyName, default(T)), Filter.Eq(propertyName, string.Empty), Filter.Eq(propertyName, new T[0]))); case FilterOperator.StartsWith: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => "^" + s))); case FilterOperator.Contains: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s))); case FilterOperator.EndsWith: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s + "$"))); case FilterOperator.Equals: return(Filter.Eq(propertyName, nodeIn.Rhs.Value)); case FilterOperator.GreaterThan: return(Filter.Gt(propertyName, nodeIn.Rhs.Value)); case FilterOperator.GreaterThanOrEqual: return(Filter.Gte(propertyName, nodeIn.Rhs.Value)); case FilterOperator.LessThan: return(Filter.Lt(propertyName, nodeIn.Rhs.Value)); case FilterOperator.LessThanOrEqual: return(Filter.Lte(propertyName, nodeIn.Rhs.Value)); case FilterOperator.NotEquals: return(Filter.Ne(propertyName, nodeIn.Rhs.Value)); case FilterOperator.In: return(Filter.In(propertyName, ((IList)nodeIn.Rhs.Value).OfType <object>())); } throw new NotSupportedException(); }
/// <summary> /// 搜索按钮点击时触发事件 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void searchBtn_Click(object sender, EventArgs e) { string text = searchText.Text.Trim(); if (string.IsNullOrEmpty(text)) { MessageBox.Show("请输入要查询的内容"); return; } string name = title.SelectedItem.ToString(); //将中文对应到数据库中的要查询的key Dictionary <string, string> searchKey = new Dictionary <string, string> { { "同义词", "standard" }, { "停用词", "stopword" }, { "专有名词", "properNouns" } }; switch (name) { case STOPWORD: { //设置过滤器 FilterDefinitionBuilder <Stopword> builderFilter = new FilterDefinitionBuilder <Stopword>(); //使用正则表达式匹配所有包含text的value BsonRegularExpression regex = new BsonRegularExpression(string.Format(".*{0}.*", text)); FilterDefinition <Stopword> filter = builderFilter.Regex(searchKey[name], regex); databind(name, filterStop: filter); } break; case SYNONYM: { //设置过滤器 FilterDefinitionBuilder <Synonym> builderFilter = new FilterDefinitionBuilder <Synonym>(); //使用正则表达式匹配所有包含text的value BsonRegularExpression regex = new BsonRegularExpression(string.Format(".*{0}.*", text)); FilterDefinition <Synonym> filter = builderFilter.Regex(searchKey[name], regex); databind(name, filterSynonym: filter); } break; case PROPERNOUNS: { //设置过滤器 FilterDefinitionBuilder <Proper> builderFilter = new FilterDefinitionBuilder <Proper>(); //使用正则表达式匹配所有包含text的value BsonRegularExpression regex = new BsonRegularExpression(string.Format(".*{0}.*", text)); FilterDefinition <Proper> filter = builderFilter.Regex(searchKey[name], regex); databind(name, filterProper: filter); } break; } }
public async Task <IEnumerable <Product> > GetProducts(string name) { var builder = new FilterDefinitionBuilder <Product>(); var filter = builder.Empty; if (!string.IsNullOrWhiteSpace(name)) { filter &= builder.Regex("name", new BsonRegularExpression(name)); } return(await products.Find(filter).ToListAsync()); }
//Переход по ссылке public async Task <string> ClickOnTheLink(string link) { var builder = new FilterDefinitionBuilder <Link>(); var filter = builder.Regex("Hash", new BsonRegularExpression(link)); var fullLink = await Links.Find(filter).FirstOrDefaultAsync(); fullLink.NumberOfTransitions++; await Links.ReplaceOneAsync(new BsonDocument("Hash", link), fullLink); return(fullLink.Title); }
public override async Task <IEnumerable <Product> > GetAll(string query = null) { var builder = new FilterDefinitionBuilder <Product>(); var filter = builder.Empty; if (!String.IsNullOrWhiteSpace(query)) { filter = filter & builder.Regex(x => x.Name, BsonRegularExpression.Create(new Regex(query, RegexOptions.IgnoreCase))); } return(await Items.Find(filter).ToListAsync()); }
//Получение полной ссылки по сокращённой public async Task <string> GetLink(string abbreviated) { CounterOfVisits visits = await Visits.Find(c => c.Id == "5e392e65fc42fe269cb9dc0a").FirstOrDefaultAsync(); visits.Counter++; await Visits.ReplaceOneAsync(new BsonDocument("_id", new ObjectId("5e392e65fc42fe269cb9dc0a")), visits); var builder = new FilterDefinitionBuilder <Link>(); var filter2 = builder.Regex("AbbreviatedTitle", new BsonRegularExpression(abbreviated)); var link = await Links.Find(filter2).FirstOrDefaultAsync(); return(link.Title); }
public override FilterDefinition <T> VisitFuncOp([NotNull] FilterParser.FuncOpContext context) { string id = context.ID().GetText(); string str = context.STRING().GetText().Trim('\'');; var func = context.func.Type; switch (func) { case FilterParser.STARTSWITH: return(_builder.Regex(id, new BsonRegularExpression($"^{str}", "i"))); case FilterParser.ENDSWITH: return(_builder.Regex(id, new BsonRegularExpression($"{str}$", "i"))); case FilterParser.SUBSTRINGOF: return(_builder.Regex(id, new BsonRegularExpression($"{str}", "i"))); default: throw new InvalidOperationException($"Invalid StringOp {context.GetText()}"); } }
public async Task <IEnumerable <User> > GetUsers(string name, long chatId) { var builder = new FilterDefinitionBuilder <User>(); var filter = builder.Empty; if (!String.IsNullOrWhiteSpace(name)) { filter &= builder.Regex("Name", new BsonRegularExpression(name)); } filter &= builder.Eq("ChatId", chatId); return(await Users.Find(filter).ToListAsync()); }
public async Task <List <Models.Task> > GetTasks( long?id, DateTime?date, string?title, string?category, long?assigneeId, bool?isCompleted, long?teamId ) { var filterBuilder = new FilterDefinitionBuilder <Task>(); var filter = filterBuilder.Empty; if (!String.IsNullOrWhiteSpace(title)) { filter = filter & filterBuilder.Regex("title", new BsonRegularExpression(title)); } if (id.HasValue) { filter = filter & filterBuilder.Eq("id", id.Value); } if (date.HasValue) { filter = filter & filterBuilder.Eq("date", date.ToString()); } if (assigneeId.HasValue) { filter = filter & filterBuilder.Eq("assigneeId", assigneeId.Value); } if (isCompleted.HasValue) { filter = filter & filterBuilder.Eq("isCompleted", isCompleted.Value); } if (!String.IsNullOrWhiteSpace(category)) { filter = filter & filterBuilder.Eq("category", category); } if (teamId.HasValue) { filter = filter & filterBuilder.Eq("teamId", teamId.Value); } return(await Tasks.Find(filter).ToListAsync()); }
public async Task LoadAsync() { var value = this.searchText; if (string.IsNullOrWhiteSpace(value)) { this.Searched = false; this.Things.Clear(); this.Words.Collection.Clear(); } else { this.Searched = true; var builder = new FilterDefinitionBuilder <Thing>(); FilterDefinition <Thing> filter; switch (this.SearchModes.Selected.Value.Value) { case SearchMode.Normal: filter = builder.Regex( PropertySelector <Thing> .Start().SelectMany(z => z.Words).Select(z => z.Text).ToString(), new Regex(Regex.Escape(value), RegexOptions.IgnoreCase)); break; case SearchMode.WholeWord: filter = builder.Eq(PropertySelector <Thing> .Start().SelectMany(z => z.Words).Select(z => z.Text).ToString(), value); break; default: throw new ArgumentOutOfRangeException(); } string category = null; if (this.ExistsCategorys.Selected != string.Empty) { category = this.ExistsCategorys.Selected; filter = filter & builder.AnyEq(z => z.Categorys, this.ExistsCategorys.Selected); } filter = builder.Eq(z => z.Id, value) | filter; var queryResult = await App.Current.ThingSetAccessor.FindAsync(filter, 20); this.HasNext = queryResult.HasNext; var sortedItems = await queryResult.Items .OrderBy(z => z.Words.Any(x => x.Text == value)? -1 : 1) .ThenBy(z => z.Words.Any(x => x.Text.Equals(value, StringComparison.OrdinalIgnoreCase)) ? -1 : 1) .ToArrayAsync(); this.Things.Reset(sortedItems.Select(z => new ThingViewModel(z, category))); this.Words.Collection.Reset(this.Things.SelectMany(z => z.Words)); } this.RefreshProperties(); }
public static FilterDefinition <BsonDocument> GetApacheRequests(IMongoCollection <BsonDocument> collection, bool includeGatewayHealthCheckRequests = false) { // Filter down to only access files. FilterDefinition <BsonDocument> query = Query.Regex("file", new BsonRegularExpression("^access.*")); // Gateway health check requests are generally noise, but may be desired in some situations. if (!includeGatewayHealthCheckRequests) { query = Query.And(query, Query.Ne("resource", "/favicon.ico")); } return(query); }
public IPageList <T> Query <T>(FilterCondition filter) where T : IBaseObject { this.CheckType <T>(); IMongoCollection <T> collection = this.GetCollection <T>(); FilterDefinitionBuilder <T> filter2 = Builders <T> .Filter; SortDefinitionBuilder <T> sort = Builders <T> .Sort; FilterDefinition <T> filterDefinition = filter2.Empty; foreach (FilterValue current in filter.Fields) { switch (current.FilterType) { case FilterType.LTE: filterDefinition &= filter2.Lte <object>(current.FieldName, current.Value); break; case FilterType.GTE: filterDefinition &= filter2.Gte <object>(current.FieldName, current.Value); break; case FilterType.LT: filterDefinition &= filter2.Lt <object>(current.FieldName, current.Value); break; case FilterType.GT: filterDefinition &= filter2.Gt <object>(current.FieldName, current.Value); break; case FilterType.EQ: goto IL_12E; case FilterType.Like: filterDefinition &= filter2.Regex(current.FieldName, new Regex(current.Value.ToString(), RegexOptions.IgnoreCase)); break; default: goto IL_12E; } continue; IL_12E: filterDefinition &= filter2.Eq <object>(current.FieldName, current.Value); } Task <long> task = collection.CountAsync(filterDefinition, null, default(CancellationToken)); SortDefinition <T> sort2 = (filter.Direction == OrderDirection.DESC) ? sort.Descending(filter.OrderBy) : sort.Ascending(filter.OrderBy); Task <List <T> > task2 = collection.Find(filterDefinition, null).Sort(sort2).Limit(new int?(filter.PageSize)).Skip(new int?((filter.PageIndex - 1) * filter.PageSize)).ToListAsync(default(CancellationToken)); return(new PageList <T>(task2.Result, filter.PageIndex, filter.PageSize, (int)task.Result)); }
public async Task <IEnumerable <NoSQLFile> > GetFiles(Dictionary <string, string> filterCriteria) { // filter builder var builder = new FilterDefinitionBuilder <NoSQLFile>(); var filter = builder.Empty; // get all documents // filter by FileName foreach (var item in filterCriteria) { if (!String.IsNullOrWhiteSpace(item.Value)) { filter = filter & builder.Regex(item.Key, new BsonRegularExpression(item.Value)); } } return(await _files.Find(filter).ToListAsync()); }
/// <summary> /// Get commands for the apache session using the list of vizqlsessionIDs /// /// </summary> /// <param name="browserSession">Browser session</param> /// <param name="mongoDatabase"></param> /// <param name="vizqlSessionIds">vizqlSessionIDs used in case of correlated vizql sessions</param> /// <returns></returns> private List <TabCommand> GetVizqlServerCommands(BrowserSession browserSession, IMongoDatabase mongoDatabase, List <string> vizqlSessionIds) { var commands = new List <TabCommand>(); var vizqlSessionCollection = mongoDatabase.GetCollection <BsonDocument>("vizqlserver_cpp"); foreach (var vizqlSessionId in vizqlSessionIds) { // making query compatible with old and newer command name, suggest to remove command-pre when tableau version < 2018.3 becomes less relevant var commandQuery = Query.And(Query.Regex("sess", vizqlSessionId + "*"), Query.Or(Query.Eq("k", "command-pre"), Query.Eq("k", "begin-commands-controller.invoke-command"))); var commandsLogs = vizqlSessionCollection.Find(commandQuery).ToList(); Log.DebugFormat("Getting commands for vizqlserver session {0}", vizqlSessionId); foreach (var commandLog in commandsLogs) { //convert the current time to UTC var browserStartTime = (DateTime)commandLog.GetElement("ts").Value - _timeOffset; var timeStr = browserStartTime.ToUniversalTime().ToString(UtcDateFormat); var jsonCmd = commandLog["v"]["args"].ToString(); var command = BuildCommand(jsonCmd); if (command == null) { Log.WarnFormat("Failed to build command from-- {0}", jsonCmd); continue; } //get the user name if it is not already there if (browserSession.User == null) { var user = (string)commandLog.GetValue("user", null); if (user != null) { browserSession.User = user; } } var commandValue = new TabCommand(timeStr, command); commands.Add(commandValue); } } //sort them as due to querying multiple vizqlsession the commands might come in different order commands.Sort(); return(commands); }