file-watcher/Helpers/HelperNuget.cs

using File_Watcher.Models;
using System.IO.Compression;

namespace File_Watcher.Helpers;

internal class HelperNuget
{

    private static DateTimeOffset? GetDateTimeOffset(string keyFileExtension, FileInfo fileInfo, FileInfo extractKeyFileInfo)
    {
        DateTimeOffset? dateTimeOffset = null;
        using ZipArchive zip = ZipFile.Open(fileInfo.FullName, ZipArchiveMode.Read);
        foreach (ZipArchiveEntry zipArchiveEntry in zip.Entries)
        {
            if (!zipArchiveEntry.Name.EndsWith(keyFileExtension))
                continue;
            dateTimeOffset = zipArchiveEntry.LastWriteTime;
            if (fileInfo.FullName[0] != '\\')
            {
                zipArchiveEntry.ExtractToFile(extractKeyFileInfo.FullName);
                File.SetCreationTime(extractKeyFileInfo.FullName, fileInfo.CreationTime);
                File.SetLastWriteTime(extractKeyFileInfo.FullName, dateTimeOffset.Value.LocalDateTime);
            }
            break;
        }
        return dateTimeOffset;
    }

    private static bool ExtractKeyFileAndSetDateFromZipEntry(ILogger<Worker> logger, string[] zipFiles, string keyFileExtension, string keyFileExtensionB, string keyFileExtensionC, bool renameToLower)
    {
        bool result = false;
        string[] files;
        string checkFile;
        string? lowerName;
        FileInfo fileInfo;
        FileInfo extractKeyFileInfo;
        DateTimeOffset? dateTimeOffset;
        foreach (string zipFile in zipFiles)
        {
            fileInfo = new(zipFile);
            if (fileInfo.DirectoryName is null)
                throw new NullReferenceException(nameof(fileInfo.DirectoryName));
            lowerName = !renameToLower ? null : Path.Combine(fileInfo.DirectoryName, fileInfo.Name.ToLower());
            if (renameToLower && lowerName is not null && lowerName != fileInfo.FullName)
            {
                files = Directory.GetFiles(fileInfo.DirectoryName, $"{Path.GetFileNameWithoutExtension(fileInfo.Name)}*", SearchOption.TopDirectoryOnly);
                foreach (string file in files)
                    File.Move(file, Path.Combine(fileInfo.DirectoryName, Path.GetFileName(file).ToLower()));
                fileInfo = new(lowerName);
                if (fileInfo.DirectoryName is null)
                    throw new NullReferenceException(nameof(fileInfo.DirectoryName));
            }
            extractKeyFileInfo = new(Path.Combine(fileInfo.DirectoryName, $"{Path.GetFileNameWithoutExtension(fileInfo.Name)}{keyFileExtension}"));
            if (extractKeyFileInfo.Exists)
            {
                if (extractKeyFileInfo.CreationTime.ToString("yyyy-MM-dd") == fileInfo.CreationTime.ToString("yyyy-MM-dd") && extractKeyFileInfo.LastWriteTime.ToString("yyyy-MM-dd") == fileInfo.LastWriteTime.ToString("yyyy-MM-dd"))
                    continue;
                File.Delete(extractKeyFileInfo.FullName);
            }
            try
            {
                dateTimeOffset = GetDateTimeOffset(keyFileExtension, fileInfo, extractKeyFileInfo);
                if (dateTimeOffset is null)
                    continue;
                if (fileInfo.LastWriteTime != dateTimeOffset.Value.LocalDateTime)
                {
                    File.SetLastWriteTime(fileInfo.FullName, dateTimeOffset.Value.LocalDateTime);
                    if (!result)
                        result = true;
                }
                if (string.IsNullOrEmpty(keyFileExtensionB))
                    continue;
                files = Directory.GetFiles(fileInfo.DirectoryName, keyFileExtensionB, SearchOption.TopDirectoryOnly);
                foreach (string file in files)
                {
                    fileInfo = new(file);
                    if (fileInfo.LastWriteTime != dateTimeOffset.Value.LocalDateTime)
                    {
                        File.SetLastWriteTime(fileInfo.FullName, dateTimeOffset.Value.LocalDateTime);
                        if (!result)
                            result = true;
                    }
                }
                if (string.IsNullOrEmpty(keyFileExtensionC))
                    continue;
                if (fileInfo.DirectoryName is null)
                    throw new NullReferenceException(nameof(fileInfo.DirectoryName));
                files = Directory.GetFiles(fileInfo.DirectoryName, keyFileExtensionC, SearchOption.TopDirectoryOnly);
                foreach (string file in files)
                {
                    fileInfo = new(file);
                    if (fileInfo.LastWriteTime != dateTimeOffset.Value.LocalDateTime)
                    {
                        File.SetLastWriteTime(fileInfo.FullName, dateTimeOffset.Value.LocalDateTime);
                        if (!result)
                            result = true;
                    }
                }
            }
            catch (Exception)
            {
                logger.LogInformation("<{zipFile}> is invalid!", zipFile);
                checkFile = string.Concat(zipFile, ".err");
                for (int e = 0; e < short.MaxValue; e++)
                {
                    if (!File.Exists(checkFile))
                        break;
                    checkFile = string.Concat(checkFile, e);
                }
                try
                { File.Move(zipFile, checkFile); }
                catch (Exception) { logger.LogInformation("<{zipFile}> couldn't be moved!", zipFile); }
            }
        }
        return result;
    }

    private static int CopyFiles(NugetConfiguration nugetConfiguration, string[] files)
    {
        int results = 0;
        FileInfo fileInfo;
        FileInfo checkFileInfo;
        foreach (string file in files)
        {
            fileInfo = new(file);
            checkFileInfo = new(Path.Combine(nugetConfiguration.Destination, fileInfo.Name));
            if (!checkFileInfo.Exists || fileInfo.LastWriteTime != checkFileInfo.LastWriteTime || fileInfo.Length != checkFileInfo.Length)
            {
                File.Copy(fileInfo.FullName, checkFileInfo.FullName, overwrite: true);
                results++;
            }
        }
        return results;
    }

    internal static bool Sync(AppSettings appSettings, ILogger<Worker> logger)
    {
        NugetConfiguration nugetConfiguration = appSettings.NugetConfiguration;
        if (!Directory.Exists(nugetConfiguration.Source))
            _ = Directory.CreateDirectory(nugetConfiguration.Source);
        if (!Directory.Exists(nugetConfiguration.Destination))
            _ = Directory.CreateDirectory(nugetConfiguration.Destination);
        string[] files = Directory.GetFiles(nugetConfiguration.Source, nugetConfiguration.SearchPattern, SearchOption.AllDirectories);
        logger.LogInformation("Found {Files} file(s)", files.Length);
        _ = ExtractKeyFileAndSetDateFromZipEntry(logger, files, nugetConfiguration.KeyFileExtension, nugetConfiguration.KeyFileExtensionB, nugetConfiguration.KeyFileExtensionC, nugetConfiguration.RenameToLower);
        logger.LogInformation("{Files} file(s) verified", files.Length);
        int filesCopied = CopyFiles(nugetConfiguration, files);
        logger.LogInformation("Copied {FilesCopied} file(s)", filesCopied);
        return true;
    }

}