protected override bool Process(IInteraction parameters) { bool success = true; // FileSystemInfo[] infos = rootDirectory.GetFileSystemInfos ("*", SearchOption.AllDirectories); IEnumerable <FileSystemInfo> infos = rootDirectory.EnumerateFileSystemInfos("*", SearchOption.AllDirectories); IEnumerator <FileSystemInfo> infoEnumerator = infos.GetEnumerator(); while (infoEnumerator.MoveNext()) { try { FileSystemInfo info = infoEnumerator.Current; if (info is FileInfo) { success &= FileFound.TryProcess(new FileInteraction(info, this.RootPath, parameters)); } else if (info is DirectoryInfo) { success &= DirectoryFound.TryProcess(new DirectoryInteraction(info, this.RootPath, parameters)); } } catch (Exception ex) { Secretary.Report(5, "Inclusion of new file failed; ", ex.Message); } } return(success); }
public void Search(string directory, string searchPattern) { foreach (var file in Directory.EnumerateFiles(directory, searchPattern)) { FileFound?.Invoke(this, new FileFoundArgs(file)); } }
protected override bool Process(IInteraction parameters) { string fullPath = ""; bool success = true; while (Changes.Count > 0) { fullPath = Changes.Dequeue(); if (Directory.Exists(fullPath)) { success &= DirectoryFound.TryProcess(new DirectoryInteraction(new DirectoryInfo(fullPath), RootPath, parameters)); } else if (File.Exists(fullPath)) { success &= FileFound.TryProcess(new FileInteraction(new FileInfo(fullPath), RootPath, parameters)); } else { success &= Gone.TryProcess(new FSInteraction(new FileInfo(fullPath), RootPath, parameters)); } } return(success); }
public bool FindFileByName(string name, string currentPath) { var files = GetFiles(currentPath); if (files != null) { foreach (var file in files) { if (file.Name.ToLower().Contains(name)) { var folderContent = GetFolderContent(currentPath).ToList(); FileFound?.Invoke(folderContent.FindIndex(s => s.FullName.ToLower().Contains(name.ToLower())), currentPath, folderContent.Count); return(true); } } } var folders = GetFolders(currentPath); if (folders != null) { foreach (var folder in folders) { var result = FindFileByName(name, folder.FullName); if (result) { return(true); } } } return(false); }
static void AddRow(FileFound found) { var file = new FileInfo("pictures.xlsx"); var newFile = !file.Exists; try { using (var package = newFile ? new ExcelPackage() : new ExcelPackage(file)) { // get the first worksheet in the workbook if (package.Workbook.Worksheets.Count == 0) package.Workbook.Worksheets.Add("Pics"); var worksheet = package.Workbook.Worksheets[1]; var start = int.Parse( Convert.ToString(worksheet.Cells[1, 1].Value ?? "2") ); worksheet.Cells[1, 1].Value = start + 1; worksheet.Cells[start, 1].Value = found.Location; if (newFile) package.SaveAs(file); else package.Save(); } // the using statement automatically calls Dispose() which closes the package. } catch (Exception e) { _logger.ErrorException("Could not add to excel sheet", e); } }
private void AddNewRow(FileFound file) { var row = new DataGridViewRow { Tag = file }; foreach (DataGridViewColumn col in gridFiles.Columns) { switch (col.Name) { case "colSequence": row.Cells.Add(GetCell(file.Sequence)); break; case "colFilePath": row.Cells.Add(GetCell(file.Path)); break; case "colContent": row.Cells.Add(GetCell(file.Content)); break; } } this.gridFiles.Rows.Add(row); }
private void _watcher_Created(FileSystemEventArgs e) { if (e.Name.ToUpper().StartsWith("QUERY_DATA")) { _log.Info("File found via file '" + e.ChangeType + "; importing."); Application.Current.Dispatcher.BeginInvoke(new Action(() => { FileFound?.Invoke(e.FullPath); })); } }
public void on_found_handler_arg_is_the_file_found_instance_passed_to_the_on_found_method() { FileFound handlerArg = null; ClassUnderTest.AddHandler(x => handlerArg = x); ClassUnderTest.OnFound(_ff); handlerArg.ShouldEqual(_ff); }
void OnFileFound(string filename) { Application.Current.Dispatcher.Invoke ( () => FileFound?.Invoke(this, new ExplorerEventArgs { FileName = filename }) ); }
private void SearchFiles(string path, string searchValue, int searchId) { searchValue = searchValue.ToLower(); // Search Files #region SearchFiles string[] files = Directory.GetFiles(path); foreach (string file in files) { try { // Get file Info #region GetFileInfo string fileName = Path.GetFileNameWithoutExtension(file); string filePath = Path.GetFullPath(file); string fileExtension = Path.GetExtension(file); #endregion FileCounter++; if (fileName.ToLower().Contains(searchValue)) { // Add Result to DB and Notify File Found using (ResultLogic logic = new ResultLogic()) { FileFoundCounter++; logic.AddResult(fileName, filePath, searchId); FileFound?.Invoke(this, new FileEventArgs(fileName, fileExtension, filePath)); } } } #region Exceptions catch (PathTooLongException ex) { UnreachableCounter++; TotalErrorCounter++; } catch (Exception ex) { UnhandledErrors++; TotalErrorCounter++; ErrorLog.Add(ex.Message); } #endregion } #endregion // Search Directories #region SearchDirectories string[] directories = Directory.GetDirectories(path); foreach (string d in directories) { try { SearchFiles(d, searchValue, searchId); } }
protected virtual void OnFileFound(ContentFindedEventArgs e) { if (ReferenceEquals(e, null)) { throw new ArgumentNullException(); } FileFound?.Invoke(this, e); _searchStopped = e.StopSearch; }
IEnumerable <FileSystemInfo> GetFileSystemInfo(DirectoryInfo directoryInfo) { var allElements = directoryInfo.GetFileSystemInfos(); foreach (var fileSystemInfo in allElements) { var itemFoundEventArgs = new FileSystemInfoEventArgs(fileSystemInfo.FullName); var itemFilteredEventArgs = new FilteredFileSystemInfoEventArgs(fileSystemInfo.FullName); if (fileSystemInfo is FileInfo) { FileFound?.Invoke(this, itemFoundEventArgs); if (itemFoundEventArgs.StopSearch) { yield break; } if (_matchPredicate(fileSystemInfo) && !itemFoundEventArgs.Exclude) { FileFiltered?.Invoke(this, itemFilteredEventArgs); if (itemFilteredEventArgs.StopSearch) { yield break; } if (!itemFilteredEventArgs.Exclude) { yield return(fileSystemInfo); } } } else if (fileSystemInfo is DirectoryInfo nextDirectory) { DirectoryFound?.Invoke(this, itemFoundEventArgs); if (itemFoundEventArgs.StopSearch) { yield break; } if (_matchPredicate(fileSystemInfo) && !itemFoundEventArgs.Exclude) { foreach (var nextFileSystemInfo in GetFileSystemInfo(nextDirectory)) { yield return(nextFileSystemInfo); } DirectoryFiltered?.Invoke(this, itemFilteredEventArgs); if (itemFilteredEventArgs.StopSearch) { yield break; } if (!itemFilteredEventArgs.Exclude) { yield return(fileSystemInfo); } } } } }
private void SearchDirectory(string directory, string searchPattern) { foreach (var file in Directory.EnumerateFiles(directory, searchPattern)) { var args = new FileFoundArgs(file); FileFound?.Invoke(this, args); if (args.CancelRequested) { break; } } }
internal void SearchFilesInDirectory(string directory, string searchPattern) { foreach (var file in Directory.EnumerateFiles(directory, searchPattern)) { PathDecomposition pathDecomp = new PathDecomposition(file, CurrentDirectory); pathDecomp.PuttingItTogether(); var args = new FileFoundArgs(file); FileFound?.Invoke(this, args); //if (args.CancelRequested) // break; } }
private void ProcessFoundEntry(FileSystemInfoBase systemInfoBase) { var isDirectory = systemInfoBase.Attributes.HasFlag(FileAttributes.Directory); if (isDirectory) { DirectoryFound?.Invoke(systemInfoBase, EventArgs.Empty); } else { FileFound?.Invoke(systemInfoBase, EventArgs.Empty); } }
private void FileSearch(string path) { foreach (string file in Directory.GetFiles(path)) { if (!_subscription) { return; } FileFound?.Invoke(this, new FileArgs(file)); Thread.Sleep(1000); } CatalogSearch(path); }
void _worker_DoWork(object sender, DoWorkEventArgs e) { foreach (var directory in GetPartiallyFlatDirectories(_searchPath, 4)) { if (_worker.CancellationPending) { break; } foreach (var file in directory.GetFiles(_template, SearchOption.AllDirectories)) { FileFound.Raise(file); } } }
private void ScanFile(string file) { try { if (CheckForValidHeader && !DicomFile.HasValidHeader(file)) { return; } var df = DicomFile.Open(file); FileFound?.Invoke(this, df, file); } catch { // ignore exceptions? } }
private void GetFiles(string path, string pattern, string searchKey) //searches the directories for targeted files { var File = new List <string>(); try { if (searchTrigger) { Console.WriteLine("search stopped, press any key to return."); if (Console.KeyAvailable) { Console.ReadKey(); } Console.ReadKey(); Console.Clear(); SearchHandler handler = new SearchHandler(); handler.Start(); } //get all files directly within a certain directory and checking them for out search input // displaying matches in real time, and adding them to the list for transfer to database. File.AddRange(Directory.GetFiles(path, pattern, SearchOption.TopDirectoryOnly)); foreach (var item in File) { if (Path.GetFileNameWithoutExtension(item).ToLower().Contains(searchKey.ToLower())) { Counter++; FileFound?.Invoke(this, new SearchResultEvent(item, Counter)); } } // //performing the same action on every directoy in our path foreach (var directory in Directory.GetDirectories(path)) { GetFiles(directory, pattern, searchKey); } // } catch (UnauthorizedAccessException) { } catch (PathTooLongException) { } }
private bool VisitFile(FileInfo fileInfo, FolderNode rootNode) { if (_searchIsStopped) { return(false); } var file = Map(fileInfo, rootNode); var filterResult = _filterBy == null ? true : _filterBy.Invoke(file); if (filterResult) { var fEvent = new FileNodeFindEvent(file); FileFound?.Invoke(this, fEvent); ProcessEvent(rootNode, file, fEvent); return(fEvent.ShouldBeAdd); } return(false); }
private void TestFile(FileInfo file, FileQueryFilterList filters) { if (Logger.IsDebugEnabled) { Logger.Debug("Testing file: " + file); } bool accept = true; foreach (var filter in filters) { if (abortSearch || accept == false) { // No need to continue break; } // Apply the filter if (Logger.IsDebugEnabled) { Logger.Debug("Checking filter: " + filter.ToString()); } accept = filter.Accept(file); } if (accept) { if (Logger.IsDebugEnabled) { Logger.Debug("File passed all filters: " + file); } Results.Add(file); FileFound?.Invoke(this, new FileFoundEventArgs() { fileInfo = file }); } }
protected virtual void OnFileFound(HyperFileCheckEventArgs e) { FileFound?.Invoke(this, e); }
protected override void beforeEach() { _ff = new FileFound("a.spark", "a", ""); }
private void OnFileFound(VisitArgs args) { FileFound.Run(this, args); }
protected virtual void OnFileFound(SystemVisitorEventArgs e) => FileFound?.Invoke(this, e);
public async Task <List <string> > Found([FromRoute] FileFound fileFound) { return(await _nodesService.FoundNode(fileFound.NodeId, SpisumNames.NodeTypes.File)); }
protected virtual void OnFileFound(ItemFoundInfoEventArgs e) { FileFound?.Invoke(this, e); }
/// <summary> /// Executed when a file is found. /// </summary> /// <param name="file">The found file.</param> protected virtual void OnFileFound(string file) { FileFound?.Invoke(file); }
private FileSystemInfoCustomCollection <CustomFileItem> GetItemsRecursively(string directoryPath, FilterMask filterMask) { var directoryInfo = (CustomDirectoryInfo)customDirectoryInfoFactory.CreateInstance(directoryPath); var output = new FileSystemInfoCustomCollection <CustomFileItem>(); if (isFirstFilteredFileFound && filterMask.HasFlag(FilterMask.FirstOnly)) { return(output); } if (!filterMask.HasFlag(FilterMask.NoFolders)) { DirectoryFound?.Invoke(this, new ItemFoundArgs { Item = directoryInfo }); if (filterMask.HasFlag(FilterMask.IgnoreFilterFunction) || FileFilterDelegate.Invoke(directoryInfo)) { FilteredDirectoryFound?.Invoke(this, new ItemFoundArgs { Item = directoryInfo }); output.Add(directoryInfo); isFirstFilteredFileFound = true; if (isFirstFilteredFileFound && filterMask.HasFlag(FilterMask.FirstOnly)) { return(output); } } } var files = directoryInfo.GetFiles(); foreach (var file in files) { FileFound?.Invoke(this, new ItemFoundArgs { Item = file }); if (filterMask.HasFlag(FilterMask.IgnoreFilterFunction) || FileFilterDelegate.Invoke(file)) { FilteredFileFound?.Invoke(this, new ItemFoundArgs { Item = file }); output.Add(file); isFirstFilteredFileFound = true; if (isFirstFilteredFileFound && filterMask.HasFlag(FilterMask.FirstOnly)) { return(output); } } } var directories = directoryInfo.GetDirectories(); foreach (var directory in directories) { var result = GetItemsRecursively(directory.FullName, filterMask); foreach (var item in result) { output.Add(item); } } return(output); }
protected virtual void OnRaiseFileFoundEvent(FileEventArgs fileEventArgs) { FileFound?.Invoke(this, fileEventArgs); }
protected virtual void OnFileFound(string fileName) { FileFound?.Invoke(this, fileName); }