예제 #1
0
        /// <summary>
        /// Выполняет копирование файла в зависимости от расширения
        /// </summary>
        /// <param name="fileInfo"></param>
        public void Execute(FileInfo fileInfo, string rootFolder)
        {
            _rootFolder = rootFolder;

            string fileName = fileInfo.Path.Split('\\').LastOrDefault();
            string ext      = fileInfo.Path.Split('.').LastOrDefault();

            if (!ext.Equals(string.Empty))
            {
                switch (ext)
                {
                case "txt":
                    СheckDirectory(rootFolder, "txt");
                    СopyFile(fileInfo.Path, $"{rootFolder}\\txt\\{fileName}", "txt");
                    break;

                case "xml":
                    СheckDirectory(rootFolder, "xml");
                    СopyFile(fileInfo.Path, $"{rootFolder}\\xml\\{fileName}", "xml");
                    break;

                default:
                    _log.Error($"Wrong file extension [{ext}]");
                    break;
                }
            }
            else
            {
                _log.Error($"Wrong path [{fileInfo.Path}]");
            }
        }
예제 #2
0
        /// <summary>
        /// Подгрузка актуальных данных из директории
        /// </summary>
        /// <param name="folder">Директория подгрузки</param>
        /// <param name="extension">Расширение файла, указывать без точки</param>
        /// <returns></returns>
        public async Task <FolderInfo> GetActualHistory(string folder)
        {
            if (Directory.Exists(folder))
            {
                FolderInfo folderInfo = new FolderInfo(folder);

                foreach (var pathFile in Directory.GetFiles(folder))
                {
                    _log.Debug($"Work with [{pathFile}]");

                    var fileInfo = new FileInfo(pathFile);

                    fileInfo.Hash = await _check.GetCalcValue(fileInfo);

                    fileInfo.ChangeStatus = FileChangeStatus.Nothing;
                    fileInfo.ChangeTime   = File.GetLastWriteTime(pathFile);

                    _log.Debug($"Add file [{pathFile}] to memory");
                    folderInfo.Files.Add(fileInfo);
                }

                return(folderInfo);
            }
            else
            {
                _log.Error($"Folder {folder} is not found");
                return(FolderInfo.Empty);
            }
        }
예제 #3
0
        /// <summary>
        /// Возвращает MD5 хэш файла
        /// </summary>
        /// <param name="file">Файл с данными</param>
        /// <returns>MD5</returns>
        public async Task <string> GetCalcValue(FileInfo file)
        {
            using (FileStream stream = File.OpenRead(file.Path))
            {
                _lastMD5Hash = await Task.Factory.StartNew(() => CalcMD5Hash(stream));

                return(_lastMD5Hash);
            }
        }
예제 #4
0
 /// <summary>
 /// Проверка изменился ли файл
 /// </summary>
 /// <param name="newFile"></param>
 /// <param name="oldFile"></param>
 /// <returns></returns>
 public bool IsChanged(FileInfo newFile, FileInfo oldFile)
 {
     if (oldFile.Hash == newFile.Hash)
     {
         return(false);
     }
     else
     {
         return(true);
     }
 }
예제 #5
0
        private FileInfo GetFileEqualsFileCache(FileInfo file, ICollection <FileInfo> collection)
        {
            FileInfo info = new FileInfo(file.Path);

            foreach (var fileInfo in collection)
            {
                if (fileInfo.Path == file.Path)
                {
                    info = fileInfo;
                }
            }

            return(info);
        }
예제 #6
0
        /// <summary>
        /// Подгрузка файлов из кэша
        /// </summary>
        /// <param name="folder">Директория подгрузки</param>
        /// <param name="extension">Расширение файла, указывать без точки</param>
        /// <returns></returns>
        public async Task <FolderInfo> GetCachedFilesHistory(string folder)
        {
            if (!Directory.Exists(folder))
            {
                _log.Error($"Folder {folder} is not found");
                return(FolderInfo.Empty);
            }

            FolderInfo folderInfo = new FolderInfo(folder);

            foreach (var cacheDirectory in Directory.GetDirectories(folder)) // Получаем данные
            {
                if (cacheDirectory.EndsWith("txt", StringComparison.OrdinalIgnoreCase) ||
                    cacheDirectory.EndsWith("xml", StringComparison.OrdinalIgnoreCase))    // Игнорирование 'системных' папок
                {
                    _log.Debug("Skip folder");
                    continue;
                }

                _log.Debug($"Get cache from {cacheDirectory}");
                // {file}.* => {file}/[0...x] - паттерн кэша

                IEnumerable <string> extensions = GetExtensions(cacheDirectory);
                foreach (var ext in extensions)                                                        // Поиск файлов по расширению
                {
                    var lastFilePath = Directory.GetFiles(cacheDirectory, $"*.{ext}").LastOrDefault(); // Получаем последний файл
                    if (lastFilePath != null)
                    {
                        var fileExtPath       = lastFilePath.Split('.').LastOrDefault(); // Получаем расширение файла
                        var fileWithExtension = cacheDirectory + '.' + fileExtPath;      // Полный путь до нужного файла

                        _log.Debug($"Add cached file [{cacheDirectory}] to memory");
                        var fileInfo = new FileInfo(fileWithExtension);

                        fileInfo.Hash = await _check.GetCalcValue(fileInfo);

                        fileInfo.ChangeStatus = FileChangeStatus.Nothing;
                        fileInfo.ChangeTime   = File.GetLastWriteTime(fileWithExtension);

                        folderInfo.Files.Add(fileInfo);
                    }
                    else
                    {
                        _log.Error($"Folder {folder} is not contains cache files");
                    }
                }
            }

            return(folderInfo);
        }
예제 #7
0
        /// <summary>
        /// Сохраняет файл в указанную директорию
        /// </summary>
        /// <param name="fileInfo">Информация о файле</param>
        public async Task Save(FileInfo fileInfo)
        {
            string[] pathSplit = fileInfo.Path.Split('.');
            string   clearPath = pathSplit.FirstOrDefault(); // Удаляем расширение файла (.*)
            string   ext       = pathSplit.LastOrDefault();  // Получаем расширение файла (.*);

            if (!Directory.Exists(clearPath))
            {
                _log.Warn($"Directory [{clearPath}] not found, create new directory");
                await Task.Factory.StartNew(() => Directory.CreateDirectory(clearPath));
            }

            string[] files = await Task.Factory.StartNew(() => Directory.GetFiles(clearPath, $"*.{ext}"));

            string newFileName = files.Length.ToString();                                                    // Получаем количество файлов в директории
            await Task.Factory.StartNew(() => File.Copy(fileInfo.Path, $"{clearPath}/{newFileName}.{ext}")); // Копируем новую весию файла
        }
예제 #8
0
        /// <summary>
        /// Запуск отслеживания
        /// </summary>
        /// <returns></returns>
        public async Task StartTraceAsync()
        {
            _log.Info($"Start trace: {_folder}");

            _actualFolderInfo = await _fileService.Read.GetActualHistory(_folder);

            foreach (var cachedFile in _cachedFolderInfo.Files)
            {
                FileInfo actualFile = GetFileEqualsFileCache(cachedFile, _actualFolderInfo.Files); // Получаем из актуальной коллекции эквивалент кэшированного файла

                if (!File.Exists(actualFile.Path))                                                 // Проверяет существует ли файл
                {
                    actualFile.ChangeStatus = FileChangeStatus.Change;
                    _log.Info($"File [{actualFile.Path}] deleted");

                    continue;
                }

                if (_fileService.Check.IsChanged(actualFile, cachedFile))
                {
                    actualFile.ChangeStatus = FileChangeStatus.Change;
                    _log.Info($"File [{actualFile.Path}] changed");

                    _action.Execute(actualFile, _folder);
                    _log.Debug($"Execute action");

                    await _fileService.Save.Save(actualFile);
                }
                else
                {
                    actualFile.ChangeStatus = FileChangeStatus.Nothing;
                }
            }

            _cachedFolderInfo = _actualFolderInfo;
        }