Пример #1
0
 public void Search(string directory, string searchPattern)
 {
     foreach (var file in Directory.EnumerateFiles(directory, searchPattern))
     {
         FileFound?.Invoke(this, new FileFoundArgs(file));
     }
 }
        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);
        }
Пример #3
0
 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); }));
     }
 }
Пример #4
0
 void OnFileFound(string filename)
 {
     Application.Current.Dispatcher.Invoke
     (
         () => FileFound?.Invoke(this, new ExplorerEventArgs {
         FileName = filename
     })
     );
 }
Пример #5
0
        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);
                }
            }
Пример #6
0
        protected virtual void OnFileFound(ContentFindedEventArgs e)
        {
            if (ReferenceEquals(e, null))
            {
                throw new ArgumentNullException();
            }

            FileFound?.Invoke(this, e);

            _searchStopped = e.StopSearch;
        }
Пример #7
0
        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);
                        }
                    }
                }
            }
        }
Пример #8
0
 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;
         }
     }
 }
Пример #9
0
 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;
     }
 }
Пример #10
0
        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);
            }
        }
Пример #11
0
 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);
 }
Пример #12
0
        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?
            }
        }
Пример #13
0
        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) { }
        }
Пример #14
0
        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);
        }
Пример #15
0
        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
                });
            }
        }
Пример #16
0
 protected virtual void OnFileFound(HyperFileCheckEventArgs e)
 {
     FileFound?.Invoke(this, e);
 }
 protected void OnFileFoundReached(FoundEventArgs e)
 {
     FileFound?.Invoke(this, e);
 }
Пример #18
0
        private void SearchFiles(string path, string filters, bool searchRecursively, bool searchHidden, FoundFilesOrderByFilter order)
        {
            try
            {
                LOGGER.Info($"Searching for files");
                LOGGER.Info($"Parameters => path: '{path}', filters: '{filters}', recursive: {searchRecursively}, hidden: {searchHidden}, order by: {order}");

                runningCount++;
                State = RunningState.Running;

                if (State == RunningState.CancelPending)
                {
                    LOGGER.Info($"Canceling search");

                    return;
                }

                if (!searchHidden && new DirectoryInfo(path).Attributes.HasFlag(FileAttributes.Hidden))
                {
                    LOGGER.Info($"Path '{path}' is hidden and hidden search is disabled => skipping directory");
                    return;
                }

                string[] singleFilters = filters.Split(';');

                foreach (var filter in singleFilters)
                {
                    var files = Directory.GetFiles(path, filter).Select(p => new FileInfo(p)).ToArray();

                    LOGGER.Info($"Found {files.Length} files for filter '{filter}' in path '{path}'");

                    switch (order)
                    {
                    case FoundFilesOrderByFilter.NameAsc:
                        files = files.OrderBy((file) => file.Name).ToArray();
                        break;

                    case FoundFilesOrderByFilter.NameDsc:
                        files = files.OrderByDescending((file) => file.Name).ToArray();
                        break;

                    case FoundFilesOrderByFilter.CreationDateAsc:
                        files = files.OrderBy((file) => file.CreationTimeUtc).ToArray();
                        break;

                    case FoundFilesOrderByFilter.CreationDateDsc:
                        files = files.OrderByDescending((file) => file.CreationTimeUtc).ToArray();
                        break;

                    case FoundFilesOrderByFilter.ChangedDateAsc:
                        files = files.OrderBy((file) => file.LastWriteTimeUtc).ToArray();
                        break;

                    case FoundFilesOrderByFilter.ChangedDateDsc:
                        files = files.OrderByDescending((file) => file.LastWriteTimeUtc).ToArray();
                        break;

                    case FoundFilesOrderByFilter.SizeAsc:
                        files = files.OrderBy((file) => file.Length).ToArray();
                        break;

                    case FoundFilesOrderByFilter.SizeDsc:
                        files = files.OrderByDescending((file) => file.Length).ToArray();
                        break;

                    default:
                        files = files.OrderBy((file) => file.Name).ToArray();
                        break;
                    }

                    foreach (var file in files.Where(f => !f.Name.StartsWith("_") && IsVideoAnalyzer.IsVideo(f.Name)))
                    {
                        LOGGER.Info($"Found video file '{file.FullName}'");

                        FileFound?.Invoke(new FileSystemEventArgs(WatcherChangeTypes.All, file.DirectoryName, file.Name));
                    }
                }

                if (searchRecursively)
                {
                    LOGGER.Info($"Recursive mode is enabled => searching sub directories");

                    Directory.GetDirectories(path)
                    .ToList()
                    .ForEach(s => SearchFiles(s, filters, true, searchHidden, order));
                }
            }
            catch (UnauthorizedAccessException ex)
            {
                LOGGER.Error($"Access to directory was denied", ex);
            }
            catch (ThreadAbortException ex)
            {
                LOGGER.Error($"Search thread was aborted", ex);
            }
            finally
            {
                LOGGER.Info($"Search for files in directory '{path}' has been finished");

                runningCount--;

                if (runningCount == 0)
                {
                    LOGGER.Info($"Searcher finished search");

                    State = RunningState.NotRunning;
                }
            }
        }
Пример #19
0
        public void TraverseTree(string root)
        {
            // Data structure to hold names of subfolders to be
            // examined for files.
            Stack <string> dirs = new Stack <string>(20);

            if (!System.IO.Directory.Exists(root))
            {
                throw new ArgumentException();
            }

            dirs.Push(root);

            while (dirs.Count > 0 && HasCancelFlag == false)
            {
                string   currentDir = dirs.Pop();
                string[] subDirs;
                try
                {
                    subDirs = System.IO.Directory.GetDirectories(currentDir);
                }

                catch (UnauthorizedAccessException e)
                {
                    Console.WriteLine(e.Message);
                    continue;
                }
                catch (System.IO.DirectoryNotFoundException e)
                {
                    Console.WriteLine(e.Message);
                    continue;
                }

                string[] files = null;
                try
                {
                    files = System.IO.Directory.GetFiles(currentDir);
                }

                catch (UnauthorizedAccessException e)
                {
                    Console.WriteLine(e.Message);
                    continue;
                }

                catch (System.IO.DirectoryNotFoundException e)
                {
                    Console.WriteLine(e.Message);
                    continue;
                }

                // Perform the required action on each file here.
                // Modify this block to perform your required task.
                foreach (string file in files)
                {
                    try
                    {
                        // Perform whatever action is required in your scenario.
                        System.IO.FileInfo fi = new System.IO.FileInfo(file);

                        //задание №2
                        action?.Invoke(fi);

                        //задание №3
                        FileFound?.Invoke(this, new FileArgs {
                            FileName = fi.Name
                        });

                        if (HasCancelFlag)
                        {
                            break;
                        }
                    }
                    catch (System.IO.FileNotFoundException e)
                    {
                        // If file was deleted by a separate application
                        //  or thread since the call to TraverseTree()
                        // then just continue.
                        Console.WriteLine(e.Message);
                        continue;
                    }
                }

                // Push the subdirectories onto the stack for traversal.
                // This could also be done before handing the files.
                foreach (string str in subDirs)
                {
                    dirs.Push(str);
                }
            }
        }
Пример #20
0
 protected virtual void OnFileFound(FileEventArgs args)
 {
     FileFound?.Invoke(this, args);
 }
Пример #21
0
        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);
 }
Пример #23
0
 private void OnFileFound(PathEventArgs args)
 {
     FileFound?.Invoke(this, args);
 }
Пример #24
0
 protected void OnFileFound(object sender, FileFoundEventArgs args)
 {
     FileFound?.Invoke(sender, args);
 }
Пример #25
0
 protected virtual void OnFileFound(SystemVisitorEventArgs e) => FileFound?.Invoke(this, e);
Пример #26
0
 /// <summary>
 /// Executed when a file is found.
 /// </summary>
 /// <param name="file">The found file.</param>
 protected virtual void OnFileFound(string file)
 {
     FileFound?.Invoke(file);
 }
 protected virtual void OnFileFound(ItemFoundInfoEventArgs e)
 {
     FileFound?.Invoke(this, e);
 }
Пример #28
0
        public void TraverseFileSystem()
        {
            Started?.Invoke();

            _dirsAndFiles = new List <FileSystemInfo>();
            var dirs = new Stack <string>();

            dirs.Push(_rootPath);

            while (dirs.Count > 0)
            {
                var      currentDir = dirs.Pop();
                string[] subDirs;

                try
                {
                    subDirs = Directory.GetDirectories(currentDir);

                    foreach (var subDir in subDirs)
                    {
                        var directoryInfo = new DirectoryInfo(subDir);
                        _dirsAndFiles.Add(directoryInfo);

                        var args = new ItemFoundEventArgs <DirectoryInfo>(directoryInfo);
                        DirectoryFound?.Invoke(this, args);

                        if (args.CancelRequested)
                        {
                            return;
                        }

                        dirs.Push(subDir);
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                    continue;
                }

                string[] files;

                try
                {
                    files = Directory.GetFiles(currentDir);

                    foreach (var file in files)
                    {
                        var fileInfo = new FileInfo(file);
                        _dirsAndFiles.Add(fileInfo);

                        var args = new ItemFoundEventArgs <FileInfo>(fileInfo);
                        FileFound?.Invoke(this, args);

                        if (args.CancelRequested)
                        {
                            break;
                        }
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                    continue;
                }
            }

            Finished?.Invoke();
        }
Пример #29
0
 protected virtual void OnFileFound(string fileName)
 {
     FileFound?.Invoke(this, fileName);
 }