public SearchLog(WorkingData wd, ISearch isp) { Plugins = isp; Config = wd.Config; Log = wd.Log; Station = new List<StationData>(); }
public static QueryResult ConvertToDto(ISearch search) { using (search) { return Mapper.Map<ISearch, QueryResult>(search); } }
public void Init(ISearch view) { _view = view; _accountRepository = new SPKTCore.Core.DataAccess.Impl.AccountRepository(); _profileRepository = new SPKTCore.Core.DataAccess.Impl.ProfileRepository(); _redirector = new SPKTCore.Core.Impl.Redirector(); }
void AddSearch(ISearch target) { target.Id = Guid.NewGuid(); target.CreatedOnUtc = System.DateTime.UtcNow; var search = new Search(); search.Id = target.Id; search.CreatedOnUtc = target.CreatedOnUtc; search.SearchName = target.SearchName; target.SearchTerms.ForEach(x => { x.Id = Guid.NewGuid(); x.CreatedOnUtc = System.DateTime.UtcNow; search.SearchTerms.Add(new SearchTerm { CreatedOnUtc = x.CreatedOnUtc, Id = x.Id, Score = x.Score, Term = x.Term }); }); using (var ctx = new SearcherEntities()) { ctx.Searches.Add(search); ctx.SaveChanges(); } }
public static ISearch<CustomerDto> GetCustomerSearch() { if (CutomerSearch == null) { CutomerSearch = new CustomerController(); } return CutomerSearch; }
public Storage(string url, GUI owner) { this.PStorage = new PhysicalXML(Util.BASEURL + "\\" + url); this.SongList = this.PStorage.getSongs(); this.owner = owner; // this.search = new Search(); this.search = new IndexSearch(this.SongList.Values); // lucene searcher! Util.NRSONGS = this.SongList.Count; }
private void MeasureSearchAlgorithm(ISearch searcher, int[] array, int x) { Trace.WriteLine("Search type: " + searcher.GetType().Name); Trace.WriteLine("Item to find: " + x); var stopwatch = Stopwatch.StartNew(); searcher.Search(array, x); stopwatch.Stop(); Trace.WriteLine("Result time: " + stopwatch.Elapsed); }
public void SaveSearch(ISearch search) { if (search.SearchTerms.GroupBy(x => x.Term).Any(x => x.Count() > 1)) throw new System.InvalidOperationException("Cannot add duplicate terms to search"); //throw new NotImplementedException(); if (search.Id == Guid.Empty) AddSearch(search); else UpdateSearch(search); }
public SearchViewModel(ISearch search) { _search = search; _search.FilterChanged += delegate { }; _uniqueLocations = new HashSet<Tuple<int, int>>(); ((INotifyCollectionChanged)_search.Results).CollectionChanged += OnResultsCollectionChanged; _search.CurrentResultChanged += Search_CurrentResultChanged; _items = new ObservableCollection<SearchResultItemViewModel>(); OnPropertyChanged("Items"); }
public UserRepository(IUsersDetails userDetails, ISPList spList, IOptions<ListNames> listNames, IOptions<CamlQueries> camlQueries, IOptions<MatterSettings> matterSettings, ISearch search) { this.userDetails = userDetails; this.spList = spList; this.matterSettings = matterSettings.Value; this.camlQueries = camlQueries.Value; this.search = search; this.listNames = listNames.Value; }
internal static ILink Get(ISession session, IntPtr handle, ISearch search = null) { lock (_instanceLock) { NativeLink instance; if (!_instances.TryGetValue(handle, out instance)) { LinkType type; lock (Spotify.Mutex) { type = Spotify.sp_link_type(handle); } switch (type) { case LinkType.Track: instance = new NativeTrackAndOffsetLink(session, handle); break; case LinkType.Album: instance = new NativeAlbumLink(session, handle); break; case LinkType.Artist: instance = new NativeArtistLink(session, handle); break; case LinkType.Search: instance = new NativeSearchLink(session, handle, search); break; case LinkType.Playlist: instance = new NativePlaylistLink(session, handle); break; case LinkType.Profile: instance = new NativeUserLink(session, handle); break; case LinkType.Starred: instance = new NativePlaylistLink(session, handle); break; case LinkType.LocalTrack: instance = new NativeTrackAndOffsetLink(session, handle); break; case LinkType.Image: instance = new NativeImageLink(session, handle); break; default: throw new ArgumentException("Invalid link."); } _instances.Add(handle, instance); instance.Initialize(); } return instance; } }
public AsynchronousSearch( string promptName , string parameterName , IChildPromptItemsService childPromptItemsService , ISearch search) { _search = search; _childPromptItemsService = childPromptItemsService; _parameterName = parameterName; _promptName = promptName; }
public Search(ISearch search) { Albums = search.Albums.Select(x => new Album(x)).ToArray(); Artists = search.Artists.Select(x => new Artist(x)).ToArray(); DidYouMean = search.DidYouMean; Query = search.Query; TotalAlbums = search.TotalAlbums; TotalArtists = search.TotalArtists; TotalTracks = search.TotalTracks; Tracks = search.Tracks.Select(x => new Track(x)).ToArray(); }
public Search(ISearch search, Dispatcher dispatcher) { _dispatcher = dispatcher; _albums = new NotifyCollection<ITorshifyAlbum>(); _artists = new NotifyCollection<ITorshifyArtist>(); _tracks = new NotifyCollection<ITorshifyTrack>(); InternalSearch = search; if (!InternalSearch.IsComplete) { InternalSearch.Completed += OnSearchCompleted; } }
public void SaveSearch(ISearch search) { var searchData = new Dictionary<string, string> { {"startTime", search.StartTime.Ticks.ToString()}, {"endTime", search.EndTime.Ticks.ToString()}, {"processedFilesCount", search.ProcessedFilesCount.ToString(CultureInfo.InvariantCulture)} }; _sqLiteDatabase.Insert("[searches]", searchData); int searchID = int.Parse(_sqLiteDatabase.ExecuteScalar("SELECT seq FROM sqlite_sequence where name=\"searches\"")); foreach (string phrase in search.Phrases) { var phraseData = new Dictionary<string, string> { {"search_id", searchID.ToString(CultureInfo.InvariantCulture)}, {"phrase", phrase}, }; _sqLiteDatabase.Insert("[phrases]", phraseData); } foreach (MatchingFile file in search) { var fileData = new Dictionary<string, string> { {"search_id", searchID.ToString(CultureInfo.InvariantCulture)}, {"fileName", file.FileName}, {"fullPath", file.FullPath}, {"sizeInBytes", file.SizeInBytes.ToString(CultureInfo.InvariantCulture)} }; _sqLiteDatabase.Insert("[files]", fileData); int fileID = int.Parse(_sqLiteDatabase.ExecuteScalar("SELECT seq FROM sqlite_sequence where name=\"files\"")); foreach (Match match in file.Matches) { var matchData = new Dictionary<string, string> { {"file_id", fileID.ToString(CultureInfo.InvariantCulture)}, {"[index]", match.Index.ToString(CultureInfo.InvariantCulture)}, {"value", match.Value}, }; _sqLiteDatabase.Insert("[matches]", matchData); } } }
private void OnNewSearch(ISearch search) { RemoveAllRanges(); if(_currentSearch != null) { ((INotifyCollectionChanged)_currentSearch.Results).CollectionChanged -= Results_CollectionChanged; _currentSearch.CurrentResultChanged -= SearchCurrentResultChanged; } _currentSearch = search; ((INotifyCollectionChanged)_currentSearch.Results).CollectionChanged += Results_CollectionChanged; _currentSearch.CurrentResultChanged += SearchCurrentResultChanged; foreach (ISearchResult result in _currentSearch.Results) { OnNewResult(result); } SearchCurrentResultChanged(this, EventArgs.Empty); }
public bool cleanSearchIndex() { Cursor.Current = Cursors.WaitCursor; this.owner.Enabled = false; try { this.search = new IndexSearch(this.SongList.Values, true); // lucene searcher! (re-index!) } catch (Exception) { this.owner.Enabled = true; Cursor.Current = Cursors.Default; return false; } this.owner.Enabled = true; Cursor.Current = Cursors.Default; return true; }
public void SaveSearch(ISearch search) { Stream stream; var bformatter = new BinaryFormatter(); ICollection<ISearch> historySearches; if (File.Exists(FileName)) { stream = File.Open(FileName, FileMode.Open); historySearches = (ICollection<ISearch>)bformatter.Deserialize(stream); stream.Close(); stream = File.Open(FileName, FileMode.Create); } else { stream = File.Open(FileName, FileMode.Create); historySearches = new Collection<ISearch>(); } historySearches.Add(search); bformatter.Serialize(stream, historySearches); stream.Close(); }
/// <summary> /// Default constructor. /// </summary> /// <param name="repo">The main repository</param> /// <param name="factory">The content factory</param> /// <param name="siteService">The site service</param> /// <param name="pageService">The page service</param> /// <param name="paramService">The param service</param> /// <param name="mediaService">The media service</param> /// <param name="cache">The optional model cache</param> /// <param name="search">The optional search service</param> public PostService(IPostRepository repo, IContentFactory factory, ISiteService siteService, IPageService pageService, IParamService paramService, IMediaService mediaService, ICache cache = null, ISearch search = null) { _repo = repo; _factory = factory; _siteService = siteService; _pageService = pageService; _paramService = paramService; _mediaService = mediaService; _search = search; if ((int)App.CacheLevel > 2) { _cache = cache; } }
public void RegisterSearch(ISearch search) { _searches.Add(search); _currentSearch = search; }
/// <param name='operations'> /// Reference to the Rg.ClientApp.ISearch. /// </param> /// <param name='term'> /// Required. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> public static async Task <SearchResults> GetByTermAsync(this ISearch operations, string term, CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { Microsoft.Rest.HttpOperationResponse <Rg.ClientApp.Models.SearchResults> result = await operations.GetByTermWithOperationResponseAsync(term, cancellationToken).ConfigureAwait(false); return(result.Body); }
public async Task <UsageDataTableResult> GetProgramUsageData(Guid telemetryKey, TelemetryItemTypes itemType , int skip, int take, IEnumerable <Tuple <string, bool> > sortBy, ISearch requestSearch , List <string> searchableColumns) { Program program = await this.portalContext.Programs.FirstOrDefaultAsync(x => x.TelemetryKey == telemetryKey).ConfigureAwait(false); if (program == null) { throw new ArgumentException($"Program with key {telemetryKey} does not exist"); } IQueryable <TelemetryDetail> query; int totalCount; if (itemType == TelemetryItemTypes.View) { query = this.telemetryContext.ViewTelemetryDetails.Where(x => x.TelemetrySummary.View.ProgramId == program.Id); totalCount = await this.telemetryContext.ViewTelemetryDetails.CountAsync(x => x.TelemetrySummary.View.ProgramId == program.Id).ConfigureAwait(false); } else { query = this.telemetryContext.EventTelemetryDetails.Where(x => x.TelemetrySummary.Event.ProgramId == program.Id && !string.IsNullOrEmpty(x.TelemetrySummary.Event.Name)); //todo remove this empty string check after dealing with heartbeat data totalCount = await this.telemetryContext.EventTelemetryDetails.CountAsync(x => x.TelemetrySummary.Event.ProgramId == program.Id && !string.IsNullOrEmpty(x.TelemetrySummary.Event.Name)).ConfigureAwait(false); } IQueryable <TelemetryDetail> filteredQuery = EntityFilter.Match(query , property => property.Contains(requestSearch.Value) , new List <Expression <Func <TelemetryDetail, string> > >() { { x => x.Sequence }, { x => x.IpAddress }, { x => x.UserIdentifier }, { x => x.EntryKey }, }); if (take == -1) { take = totalCount; } List <TelemetryDetail> usages = await ApplyOrderingQuery(sortBy, filteredQuery, skip, take).ConfigureAwait(false); List <DataTableTelemetryData> result = new List <DataTableTelemetryData>(); foreach (TelemetryDetail detail in usages) { DataTableTelemetryData data = new DataTableTelemetryData() { Timestamp = detail.Timestamp , UserName = detail.UserIdentifier , IpAddress = detail.IpAddress , EntryKey = detail.EntryKey , ProgramVersion = detail.FileVersion , Sequence = detail.Sequence , Properties = detail.GetTelemetryUnits().Where(x => x.UnitType == TelemetryUnit.UnitTypes.Property).ToDictionary(x => x.Key, x => x.ValueString) , Metrics = detail.GetTelemetryUnits().Where(x => x.UnitType == TelemetryUnit.UnitTypes.Metric).ToDictionary(x => x.Key, x => x.ValueDouble) }; result.Add(data); } return(new UsageDataTableResult { TotalCount = totalCount, FilteredCount = totalCount, UsageData = result }); }
public HomeControllerTest() { _searchService = DependencyResolver.Current.GetService <ISearch>(); }
public MyAccountPage() { Search = Application.Get(ApplicationSourceRepository.Default()).Search; }
public SearchController(ISearch requestService) { _requestService = requestService; }
public UnitTest1() { Search = new NormalSearch(); }
public HyperspinDataProvider() { _searchGameXml = new XmlSearch <Game>(); }
public SearchController(ISearch context) { _context = context; }
/// <summary> /// Initializes a new instance of the <see cref="T:EPiServer.Commerce.FindSearchProvider.FindSearchQueryBuilder" /> class. /// </summary> /// <param name="client">The client.</param> /// <param name="criteria">The criteria.</param> /// <param name="languageOption">The language option.</param> /// <exception cref="T:System.InvalidOperationException">The Find search query builder only works with clients created by the provider.</exception> public FindSearchQueryBuilder(IClient client, ISearchCriteria criteria, QueryCultureOption languageOption) { ProviderClient providerClient = client as ProviderClient; if (providerClient == null) { throw new InvalidOperationException("The Find search query builder only works with clients created by the provider."); } ISearchConfiguration providerConfiguration = providerClient.ProviderConfiguration; Language language = (Language)null; ITypeSearch <FindDocument> search1 = criteria.IgnoreFilterOnLanguage || !FindSearchQueryBuilder._providerLanguages.TryGetValue(criteria.Locale, out language) ? providerClient.Search <FindDocument>() : providerClient.Search <FindDocument>(language); CatalogEntrySearchCriteria criteria1 = criteria as CatalogEntrySearchCriteria; if (criteria1 != null) { ITypeSearch <FindDocument> search2; if (criteria.IgnoreFilterOnLanguage) { search2 = search1.ForDefaultFields(criteria1.SearchPhrase, string.Empty); } else { ITypeSearch <FindDocument> search3 = search1.ForDefaultFields(criteria1.SearchPhrase, criteria.Locale); HashSet <string> source = new HashSet <string>((IEqualityComparer <string>)StringComparer.OrdinalIgnoreCase); if (language != null && !string.IsNullOrEmpty(language.FieldSuffix) && languageOption.HasFlag((Enum)QueryCultureOption.Neutral)) { source.Add(language.FieldSuffix); } if (!string.IsNullOrEmpty(criteria.Locale) && languageOption.HasFlag((Enum)QueryCultureOption.Specific)) { source.Add(criteria.Locale); } if (!source.Any <string>()) { source.Add(ContentLanguage.PreferredCulture.Name); } search2 = search3.FilterLanguages((IEnumerable <string>)source); } if (DateTime.MinValue < criteria1.StartDate && criteria1.EndDate < DateTime.MaxValue) { search2 = search2.FilterDates(criteria1.StartDate, criteria1.EndDate, criteria1.IncludePreorderEntry); } search1 = search2.FilterCatalogs(this.ToStringEnumerable(criteria1.CatalogNames)).FilterCatalogNodes(this.GetNodes(criteria1)).FilterOutlines(this.GetOutlines(criteria1)).FilterMetaClasses(this.ToStringEnumerable(criteria1.SearchIndex)).FilterCatalogEntryTypes(this.ToStringEnumerable(criteria1.ClassTypes)); if (!criteria1.IncludeInactive) { search1 = search1.FilterInactiveCatalogEntries(); } if (criteria1.MarketId != MarketId.Empty) { search1 = search1.FilterCatalogEntryMarket(criteria1.MarketId); } } ITypeSearch <FindDocument> search4 = search1.AddActiveFilters(criteria).AddFacets(criteria).OrderBy(criteria); if (criteria.StartingRecord > 0) { search4 = search4.Skip <FindDocument>(criteria.StartingRecord); } if (criteria.RecordsToRetrieve > 0) { search4 = search4.Take <FindDocument>(criteria.RecordsToRetrieve); } this.Search = (ISearch <FindDocument>)search4; }
public SearchUser(ISearch model) : base(model) { }
public ProductListModel(ISearch search) : base(search) { }
public BatchReceiptDetailsQueryHandler(ISearch <ReceiptBatch> batches) { this.batches = batches; }
/// <summary> /// /// </summary> /// <typeparam name="TModel"></typeparam> /// <param name="column"></param> /// <param name="search"></param> /// <param name="parameterExpression"></param> /// <returns></returns> /// <exception cref="NotSupportedException">Thrown when the searchquery is based on an regular expression</exception> public override Expression <Func <TModel, bool> > GetExpression <TModel>(IColumn column, ISearch search, ParameterExpression parameterExpression) { var sourcePropertyName = column.Field ?? column.Name; var sourceProperty = GetProperty <TModel> .ByName(sourcePropertyName); var logicalMethod = TargetType.GetMethod(nameof(string.Contains), new[] { typeof(string), typeof(StringComparison) }); var expression = Expression.Call(Expression.Property(parameterExpression, sourceProperty), logicalMethod, Expression.Constant(search.Value), Expression.Constant(StringComparison.CurrentCultureIgnoreCase)); return(Expression.Lambda <Func <TModel, bool> >(expression, new ParameterExpression[] { parameterExpression })); }
protected override IQueryable <Course> SearchAllColumns(IQueryable <Course> queryable, ISearch search) { return(queryable.Where(x => x.Name.Contains(search.Value) || x.Description.Contains(search.Value))); }
public PageService(IPageRepository repo, IContentFactory factory, ISiteService siteService, IParamService paramService, IMediaService mediaService, ICache cache = null, ISearch search = null) { base(); this._repo = repo; this._factory = factory; this._siteService = siteService; this._paramService = paramService; this._mediaService = mediaService; this._search = search; if (App.get_CacheLevel() > 2) { this._cache = cache; } return; }
public SearchService(ISearch dBSearch) { DBSearch = dBSearch; }
public MyAccountPage() { Search = Application.Get().Search; }
public SearchAndReturnPipe(WebResourceManager parent, ISearch engine, InputQuery query, Pipeline pipeline) { // Assert(engine!= null && query != null) _parent = parent; _searchEngine = engine; _inputQuery = query; _thread = new Thread(new ThreadStart(SearchAndReturn)); _thread.IsBackground = true; _thread.Start(); }
private void LoadSearchData(ISearch search) { using (search) { TotalAlbums = search.TotalAlbums; TotalTracks = search.TotalTracks; TotalArtists = search.TotalArtists; Query = search.Query; DidYouMean = search.DidYouMean; foreach (var spotifyAlbum in search.Albums) { _albums.Add(new Album(spotifyAlbum, _dispatcher)); } foreach (var spotifyTrack in search.Tracks) { _tracks.Add(new Track(spotifyTrack, _dispatcher)); } foreach (var spotifyArtist in search.Artists) { _artists.Add(new Artist(spotifyArtist, _dispatcher)); } } search.Completed -= OnSearchCompleted; IsLoading = false; RaiseFinishedLoading(); }
public ExpenseCategoryEditorFormQueryHandler(ISearch <ExpenseCategory> categories) { this.categories = categories; }
public async Task <UsageDataTableResult> GetExceptions(Guid telemetryKey, TelemetryItemTypes itemType, int skip , int take, IEnumerable <Tuple <string, bool> > sortBy, ISearch requestSearch , List <string> searchableColumns) { Program program = await this.portalContext.Programs.FirstOrDefaultAsync(x => x.TelemetryKey == telemetryKey).ConfigureAwait(false); if (program == null) { throw new ArgumentException($"Program with key {telemetryKey} does not exist"); } IQueryable <ExceptionInfo> query = this.telemetryContext.Exceptions.Where(x => x.ProgramId == program.Id); int totalCount = await this.telemetryContext.Exceptions.CountAsync(x => x.ProgramId == program.Id).ConfigureAwait(false); if (take == -1) { take = totalCount; } IQueryable <ExceptionInfo> filteredQuery = EntityFilter.Match(query , property => property.Contains(requestSearch.Value) , new List <Expression <Func <ExceptionInfo, string> > >() { { x => x.Sequence }, { x => x.Message }, { x => x.TypeName }, { x => x.ProgramVersion }, { x => x.ParsedStack }, { x => x.UserName }, }); List <ExceptionInfo> ordered = await ApplyOrderingQuery(sortBy, filteredQuery, skip, take).ConfigureAwait(false); List <ExceptionData> result = new List <ExceptionData>(); foreach (ExceptionInfo exception in ordered) { ExceptionData data = new ExceptionData { Timestamp = exception.Timestamp , UserName = exception.UserName , EntryKey = exception.TypeName , Note = exception.Note , ProgramVersion = exception.ProgramVersion , Sequence = exception.Sequence , ErrorMessage = exception.Message , StackTrace = GetStackTrace(exception.ParsedStack) , Properties = exception.TelemetryUnits.Where(x => x.UnitType == TelemetryUnit.UnitTypes.Property).ToDictionary(x => x.Key, x => x.ValueString) , Metrics = exception.TelemetryUnits.Where(x => x.UnitType == TelemetryUnit.UnitTypes.Metric).ToDictionary(x => x.Key, x => x.ValueDouble) }; result.Add(data); } return(new UsageDataTableResult { TotalCount = totalCount, FilteredCount = totalCount, UsageData = result }); }
public FundsWidgetPostProcessor(ISearch <Fund> funds) { this.funds = funds; }
public bool Commit() { if (!Util.NOCOMMIT) { if (this.PStorage.Commit(this.SongList)) { this.toBeCommited = false; Util.NRSONGS = this.SongList.Count; this.search = new IndexSearch(this.SongList.Values, true); // lucene searcher! (re-index!) return true; } else { return false; } } else { Util.MBoxError("Sie haben keine Berechtigung, Änderungen vorzunehmen!\n" + "Entfernen Sie unter Extras->Optionen..., Allgemein... den Schreibschutz\n" + "oder wenden Sie sich an den Administrator."); return false; } }
public static void ProgressesAsExpected( LinqGraph graph, ISearch <LinqGraph.Node, LinqGraph.Edge> search, int expectedTargetId, (int from, int to)[] expectedSteps)
public void RemoveSearch(ISearch search) { _searches.Remove(search); }
private void ProcessMessage(CompletionTracker completion, IZPushItem item) { if (!_feature.ProcessMessage) { return; } // Check if the message is for the current sequence ChunkIndex?optionalIndex = ChunkIndex.Parse(item.Subject); if (optionalIndex == null) { Logger.Instance.Trace(this, "Not a chunk: {0}", item.Subject); return; } if (optionalIndex.Value.numberOfChunks != CurrentSequence) { // Try to update the current sequence; this message may indicate that it has changed DetermineSequence(); // If it is still not for the current sequence, it's an old message if (optionalIndex.Value.numberOfChunks != CurrentSequence) { Logger.Instance.Trace(this, "Skipping, wrong sequence: {0}", item.Subject); return; } } ChunkIndex index = optionalIndex.Value; // Check if the message is up to date string lastProcessed = GetChunkStateString(index); if (lastProcessed == item.Location) { Logger.Instance.Trace(this, "Already up to date: {0} - {1}", item.Subject, item.Location); return; } // Process it Logger.Instance.Trace(this, "Processing: {0} - {1} - {2}", item.Subject, item.Location, lastProcessed); _feature?.BeginProcessing(); try { if (_feature.ProcessMessageDeleteExisting) { // Delete the old contacts from this chunk using (ISearch <IItem> search = Contacts.Search <IItem>()) { search.AddField(PROP_SEQUENCE, true).SetOperation(SearchOperation.Equal, index.numberOfChunks); search.AddField(PROP_CHUNK, true).SetOperation(SearchOperation.Equal, index.chunk); foreach (IItem oldItem in search.Search()) { Logger.Instance.Trace(this, "Deleting GAB entry: {0}", oldItem.Subject); oldItem.Delete(); } } } // Create the new contacts ProcessChunkBody(completion, item, index); // Update the state SetChunkStateString(index, item.Location); } finally { _feature?.EndProcessing(); } }
void UpdateSearch(ISearch target) { using (var ctx = new SearcherEntities()) { var original = ctx.Searches.Single(x => x.Id == target.Id); var targetTerms = target.SearchTerms.Select(x => x.Term.ToLower()); var sourceTerms = original.SearchTerms.Select(x => x.Term.ToLower()); //handle deletes original.SearchTerms.Where(x => !targetTerms.Contains(x.Term.ToLower())) .ToList() .ForEach(x => { ctx.SearchTerms.Remove(x); }); //handle updates to existing original.SearchTerms.ToList().ForEach(x => { var updated = target.SearchTerms.Single(n => n.Term.ToLower() == x.Term.ToLower()); if (updated.Score != x.Score) { x.Score = updated.Score; x.UpdatedOnUtc = System.DateTime.UtcNow; } }); //handle inserts target.SearchTerms.Where(x => !sourceTerms.Contains(x.Term.ToLower())).ToList().ForEach(x => { var newTerm = new SearchTerm { Id = Guid.NewGuid(), CreatedOnUtc = System.DateTime.UtcNow, Score = x.Score, Term = x.Term }; original.SearchTerms.Add(newTerm); }); ctx.SaveChanges(); } }
public WindowsSearchAPI(ISearch windowsIndexerSearch, bool displayHiddenFiles = false) { this.WindowsIndexerSearch = windowsIndexerSearch; this.DisplayHiddenFiles = displayHiddenFiles; }
/// <summary> /// Initialize a new instance of the SearchViewModel class. /// </summary> /// <param name="Source">The source.</param> public SearchViewModel(ISearch Source) { // Set the source. this.Source = Source; }
public Results Get(string algorithm, long size, int blockSize, int parallelism, string id) { var bufferSize = blockSize * 1000000; var totalSize = size * 1000000; var partitions = (totalSize / bufferSize); var pattern = Encoding.ASCII.GetBytes(id.ToString()); var timer = new Stopwatch(); var results = new Results() { Pattern = id.ToString() }; var parts = new List <long>(); var patternFound = false; for (long i = 0; i < partitions; i++) { parts.Add(Convert.ToInt64(i * bufferSize)); } timer.Start(); Parallel.ForEach(parts, new ParallelOptions { MaxDegreeOfParallelism = parallelism }, (x) => { using (var stream = new FileStream(HostingEnvironment.MapPath($@"~/App_Data/pi-billion.txt"), FileMode.Open, FileAccess.Read)) { var result = new Result { TaskId = Task.CurrentId, FromByte = x, ToByte = x + bufferSize }; if (!patternFound) { stream.Seek(x, SeekOrigin.Begin); var buffer = new byte[bufferSize]; var bytesRead = stream.Read(buffer, 0, bufferSize); if (bytesRead > 0) { ISearch searcher = SearchFactory.Get(algorithm); searcher.SetPattern(pattern); var position = searcher.Search(buffer); if (position > -1) { patternFound = true; result.Position = x + position; var digits = buffer.Skip((position - MyConfig.DigitCount).Min0()).Take(pattern.Length + MyConfig.DigitCount * 2).ToList(); result.Digits = Encoding.ASCII.GetString(digits.ToArray()); } } result.ExecutionTime = timer.Elapsed.TotalSeconds; lock (results) { results.Length += bytesRead; results.Tasks.Add(result); } } } }); timer.Stop(); results.ExecutionTime = Math.Round(timer.Elapsed.TotalSeconds, 3); return(results); }
public SearchWindow(ISearch search) { InitializeComponent(); this.DataContext = new SearchViewModel(search, new NavigationService(this)); }
/// <summary> /// Default constructor. /// </summary> /// <param name="repo">The page repository</param> /// <param name="factory">The content factory</param> /// <param name="langService">The language service</param> /// <param name="cache">The optional cache service</param> /// <param name="search">The optional search service</param> public ContentService(IContentRepository repo, IContentFactory factory, ILanguageService langService, ICache cache = null, ISearch search = null) { _repo = repo; _factory = factory; _langService = langService; if ((int)App.CacheLevel > 2) { _cache = cache; } _search = search; }
internal SearchEventArgs(ISearch result) { this.result = result; }
public ForgotPasswordPage( ) { Search = Application.Get().Search; }
private static KeyValuePair<string, List<SearchResult>> ProcessSearchableType(ISearch instance, string term) { try { return new KeyValuePair<string, List<SearchResult>>(instance.SearchResultMoniker, instance.SimpleQuery(term)); } catch (Exception e) { Current.Log.Add(e); return new KeyValuePair<string, List<SearchResult>>(instance.SearchResultMoniker, new List<SearchResult>()); } }
public AccountEditorFormQueryHandler(ISearch <Account> accounts, ISearch <Fund> funds) { this.accounts = accounts; this.funds = funds; }
public bool RemoveSearchEngine(ISearch searchEngine) { return _searchEngineList.Remove(searchEngine); }
public ToggleReceiptSourceIsActiveCommandHandler(ISearch <ReceiptSource> sources, IUnitOfWork unitOfWork) { this.sources = sources; this.unitOfWork = unitOfWork; }
public bool AddSearchEngine(ISearch searchEngine) { if (searchEngine == null) { return false; } _searchEngineList.Add(searchEngine); return true; }
public Jisho(DiscordBot jisho, ISearch search) { _jisho = jisho; _search = search; }