Example #1
0
        private void ReactOnFileChanges(object sender, FileSystemEventArgs e)
        {
            if (IsVideoAnalyzer.IsVideo(e.Name))
            {
                LOGGER.Info($"Watcher found file '{e.FullPath}'");

                FileAdded?.Invoke(e);
            }
        }
Example #2
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;
                }
            }
        }