FileSqlServerSync/Server/Common/FileDirOp.cs

using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.AccessControl;
using System.Security.Principal;
using ICSharpCode.SharpZipLib.Zip;
using Microsoft.VisualBasic;

namespace Common;

/// <summary>
/// 文件操作策略
/// </summary>
public abstract class FileDirOpStra
{
    public abstract void FileCreate(string absolutePath, DateTime mtime);

    public abstract void DirCreate(Dir dir, bool IsRecursion = true);

    public abstract void FileModify(string absolutePath, DateTime mtime);
    public abstract void FileDel(string absolutePath);
    public abstract void DirDel(Dir dir, bool IsRecursion = true);
}

/// <summary>
/// 文件目录打包
/// </summary>
/// <param name="dstRootPath"></param>
public class FileDirOpForPack(string srcRootPath, string dstRootPath) : FileDirOpStra
{
    /// <summary>
    /// 目标根目录
    /// </summary>
    public readonly string DstRootPath = dstRootPath;

    /// <summary>
    /// 源目录
    /// </summary>
    public readonly string SrcRootPath = srcRootPath;

    /// <summary>
    /// 最终完成时的压缩
    /// </summary>
    public static void FinallyCompress(string dstPath, string Id)
    {
        static List<string> GetFilesResus(string dirPath)
        {
            var files = new List<string>();
            foreach (var file in Directory.GetFiles(dirPath))
            {
                files.Add(file);
            }
            foreach (var dir in Directory.GetDirectories(dirPath))
            {
                foreach (var file in GetFilesResus(dir))
                {
                    files.Add(file);
                }
            }
            return files;
        }
        var fileNames = GetFilesResus(dstPath);
        var OuptPutFile = Path.GetDirectoryName(dstPath) + $"/{Id}.zip";
        using FileStream fsOut = new(OuptPutFile, System.IO.FileMode.Create);
        using ZipOutputStream zipStream = new(fsOut);
        {
            zipStream.SetLevel(9); // 设置压缩级别
            zipStream.Password = "VSXsdf.123d7802zw@#4_"; // 设置密码
            byte[] buffer = new byte[4096];

            foreach (string file in fileNames)
            {
                // Using GetFileName makes the result compatible with XP
                // as the resulting path is not absolute.
                var entry = new ZipEntry(file.Replace(dstPath, ""));

                // Setup the entry data as required.

                // Crc and size are handled by the library for seakable streams
                // so no need to do them here.

                // Could also use the last write time or similar for the file.
                //entry.DateTime = ;
                entry.DateTime = System.IO.File.GetLastWriteTime(file);
                zipStream.PutNextEntry(entry);

                using (FileStream fs = System.IO.File.OpenRead(file))
                {
                    // Using a fixed size buffer here makes no noticeable difference for output
                    // but keeps a lid on memory usage.
                    int sourceBytes;
                    do
                    {
                        sourceBytes = fs.Read(buffer, 0, buffer.Length);
                        zipStream.Write(buffer, 0, sourceBytes);
                    } while (sourceBytes > 0);
                }
            }

            // Finish/Close arent needed strictly as the using statement does this automatically

            // Finish is important to ensure trailing information for a Zip file is appended.  Without this
            // the created file would be invalid.
            zipStream.Finish();

            // Close is important to wrap things up and unlock the file.
            zipStream.Close();
        }
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="absolutePath"></param>
    /// <param name="mtime"></param>
    /// <exception cref="NotImplementedException"></exception>
    public override void FileCreate(string srcPath, DateTime mtime)
    {
        var dstPath = srcPath.Replace(SrcRootPath, DstRootPath);

        var dstDirPath =
            Path.GetDirectoryName(dstPath) ?? throw new NullReferenceException("父路径不存在！");
        if (!Directory.Exists(dstDirPath))
        {
            Directory.CreateDirectory(dstDirPath);
        }

        System.IO.File.Copy(srcPath, dstPath, true);
    }

    public override void DirCreate(Dir dir, bool IsRecursion = true)
    {
        var srcPath = dir.FormatedPath;
        var dstPath = srcPath.Replace(SrcRootPath, DstRootPath);
        var dstDirPath =
            Path.GetDirectoryName(dstPath) ?? throw new NullReferenceException("父路径不存在！");
        if (!Directory.Exists(dstDirPath))
        {
            Directory.CreateDirectory(dstDirPath);
        }
        if (IsRecursion)
        {
            foreach (var c in dir.Children)
            {
                if (c is Dir d)
                {
                    this.DirCreate(d, true);
                }
                else if (c is File f)
                {
                    this.FileCreate(f.FormatedPath, f.MTime);
                }
            }
        }
    }

    public override void FileModify(string absolutePath, DateTime mtime)
    {
        this.FileCreate(absolutePath, mtime);
    }

    public override void FileDel(string absolutePath) { }

    public override void DirDel(Dir dir, bool IsRecursion = true) { }
}

public class FileDirOpForUnpack(string srcRootPath, string dstRootPath) : FileDirOpStra
{
    /// <summary>
    /// 备份文件
    /// </summary>
    /// <param name="absolutePath"> 源文件位置，将要删除的或者替换的</param>
    private void BacklogFile(string absolutePath)
    {
        var dstPath = absolutePath.Replace(DstRootPath, SrcRootPath);

        var dstDirPath =
            Path.GetDirectoryName(dstPath) ?? throw new NullReferenceException("父路径不存在！");
        if (!Directory.Exists(dstDirPath))
        {
            Directory.CreateDirectory(dstDirPath);
        }

        //文件时间不会更改
        System.IO.File.Move(absolutePath, dstPath + ".bak", true);
    }

    private void BacklogDir(string absolutePath)
    {
        var dstPath = absolutePath.Replace(DstRootPath, SrcRootPath);
        var dstDirPath =
            Path.GetDirectoryName(dstPath) ?? throw new NullReferenceException("父路径不存在！");
        if (!Directory.Exists(dstDirPath))
        {
            Directory.CreateDirectory(dstDirPath);
        }
        Directory.Move(absolutePath, dstPath);
    }

    /// <summary>
    /// 解压缩,必须首先调用
    /// </summary>
    public static void FirstUnComparess(string dstPath, string Id)
    {
        string zipFilePath = $"{dstPath}/{Id}.zip";

        using (ZipInputStream s = new ZipInputStream(System.IO.File.OpenRead(zipFilePath)))
        {
            s.Password = "VSXsdf.123d7802zw@#4_";
            ZipEntry theEntry;
            while ((theEntry = s.GetNextEntry()) != null)
            {
                Console.WriteLine(theEntry.Name);

                string directoryName =
                    dstPath + $"/{Id}/" + Path.GetDirectoryName(theEntry.Name)
                    ?? throw new NullReferenceException("无法得到父文件目录！");
                string fileName = Path.GetFileName(theEntry.Name);

                // create directory
                if (directoryName.Length > 0)
                {
                    Directory.CreateDirectory(directoryName);
                }
                if (fileName != String.Empty)
                {
                    string fullFilePath = Path.Combine(directoryName, fileName);
                    using (FileStream streamWriter = System.IO.File.Create(fullFilePath))
                    {
                        int size = 2048;
                        byte[] data = new byte[2048];
                        while (true)
                        {
                            size = s.Read(data, 0, data.Length);
                            if (size > 0)
                            {
                                streamWriter.Write(data, 0, size);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                    System.IO.File.SetLastWriteTime(fullFilePath, theEntry.DateTime);
                }
            }
        }
    }

    /// <summary>
    /// 目标根目录
    /// </summary>
    public readonly string DstRootPath = dstRootPath;

    /// <summary>
    /// 源目录
    /// </summary>
    public readonly string SrcRootPath = srcRootPath;

    /// <summary>
    /// 最终完成时的压缩
    /// </summary>
    public override void FileCreate(string absolutePath, DateTime mtime)
    {
        var srcPath = absolutePath.Replace(DstRootPath, SrcRootPath);

        var dstDirPath =
            Path.GetDirectoryName(absolutePath) ?? throw new NullReferenceException("父路径不存在！");
        if (!Directory.Exists(dstDirPath))
        {
            Directory.CreateDirectory(dstDirPath);
        }

        //文件时间不会更改
        System.IO.File.Copy(srcPath, absolutePath, true);
    }

    public override void DirCreate(Dir dir, bool IsRecursion = true)
    {
        // var srcPath = dir.FormatedPath.Replace(DstRootPath, SrcRootPath);
        var dstDirPath =
            Path.GetDirectoryName(dir.FormatedPath) ?? throw new NullReferenceException("父路径不存在！");
        if (!Directory.Exists(dstDirPath))
        {
            Directory.CreateDirectory(dstDirPath);
        }
        if (IsRecursion)
        {
            foreach (var c in dir.Children)
            {
                if (c is Dir d)
                {
                    this.DirCreate(d, true);
                }
                else if (c is File f)
                {
                    this.FileCreate(f.FormatedPath, f.MTime);
                }
            }
        }
    }

    public override void FileModify(string absolutePath, DateTime mtime)
    {
        BacklogFile(absolutePath);
        this.FileCreate(absolutePath, mtime);
    }

    public override void FileDel(string absolutePath)
    {
        BacklogFile(absolutePath);
        System.IO.File.Delete(absolutePath);
    }

    public override void DirDel(Dir dir, bool IsRecursion = true)
    {
        BacklogDir(dir.FormatedPath);
        //System.IO.Directory.Delete(dir.FormatedPath, IsRecursion);
    }
}

/// <summary>
/// 文件目录权限校验
/// </summary>
public class FileDirOpForAccessCheck : FileDirOpStra
{
    public override void FileCreate(string absolutePath, DateTime mtime)
    {
        throw new NotImplementedException();
    }

    public override void DirCreate(Dir dir, bool IsRecursion = true)
    {
        throw new NotImplementedException();
    }

    public override void FileModify(string absolutePath, DateTime mtime)
    {
        throw new NotImplementedException();
    }

    public override void FileDel(string absolutePath)
    {
        throw new NotImplementedException();
    }

    public override void DirDel(Dir dir, bool IsRecursion = true)
    {
        throw new NotImplementedException();
    }
}

public enum FileAccess
{
    Read,
    Write,
    Delete,
    Execute
}

public enum DirAcess
{
    /// <summary>
    /// 读取权限
    /// </summary>
    Read,

    /// <summary>
    /// 写入权限
    /// </summary>
    Write,

    /// <summary>
    /// 列出文件夹权限
    /// </summary>
    ListDirectory,

    /// <summary>
    /// 创建文件权限
    /// </summary>
    CreateFiles,

    /// <summary>
    /// 创建文件夹权限
    /// </summary>
    CreateDirectories,

    /// <summary>
    /// 删除文件权限
    /// </summary>
    Delete,

    /// <summary>
    /// 删除文件夹及其子文件
    /// </summary>
    DeleteSubdirectoriesAndFiles,
}

/// <summary>
/// 运行此软件的用户与目标软件的用户最好是 一个用户，一个用户组，或者运行此软件的用户具备最高权限。
/// </summary>
public class AccessWrapper
{
    /// <summary>
    ///
    /// </summary>
    /// <param name="absolutePath"></param>
    public static void FreeThisDirAccess(string absolutePath)
    {
        if (
            CheckDirAccess(
                absolutePath,
                [
                    DirAcess.Read,
                    DirAcess.Write,
                    DirAcess.Delete,
                    DirAcess.ListDirectory,
                    DirAcess.CreateFiles,
                    DirAcess.CreateDirectories,
                    DirAcess.DeleteSubdirectoriesAndFiles
                ]
            )
        ) { }
        else
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                DirectoryInfo dirInfo = new(absolutePath);
                //获得该文件的访问权限
                var dirSecurity = dirInfo.GetAccessControl();
                //设定文件ACL继承
                InheritanceFlags inherits =
                    InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit;

                var cUser =
                    (
                        WindowsIdentity.GetCurrent().Groups
                        ?? throw new Exception("GetWindowsIdentity failed. 你需要手动处理发布内容！--检查权限！")
                    ).FirstOrDefault() ?? throw new NullReferenceException("can't be null");
                FileSystemAccessRule MdfRule =
                    new(
                        cUser,
                        FileSystemRights.Modify,
                        inherits,
                        PropagationFlags.InheritOnly,
                        AccessControlType.Allow
                    );
                if (dirSecurity.ModifyAccessRule(AccessControlModification.Set, MdfRule, out _)) { }
                else
                {
                    throw new Exception("AddAccessRule failed. 你需要手动处理发布内容！--检查权限!");
                }
                //设置访问权限
                dirInfo.SetAccessControl(dirSecurity);
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                //TODO  Linux文件权限
            }
            else
            {
                throw new NotSupportedException(
                    $"{RuntimeInformation.OSDescription} is not supported."
                );
            }
        }
    }

    public static void FreeThisFileAccess(string absolutePath)
    {
        if (
            CheckFileAccess(
                absolutePath,
                [FileAccess.Read, FileAccess.Write, FileAccess.Delete, FileAccess.Execute]
            )
        ) { }
        else
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                FileInfo fileInfo = new(absolutePath);
                //获得该文件的访问权限
                FileSecurity fileSecurity = fileInfo.GetAccessControl();

                var cUser =
                    (
                        WindowsIdentity.GetCurrent().Groups
                        ?? throw new NullReferenceException(
                            "GetWindowsIdentity failed. 你需要手动处理发布内容！-- 检查权限"
                        )
                    ).FirstOrDefault() ?? throw new NullReferenceException("can't be null");
                FileSystemAccessRule MdfRule =
                    new(cUser, FileSystemRights.Modify, AccessControlType.Allow);
                if (fileSecurity.ModifyAccessRule(AccessControlModification.Set, MdfRule, out _))
                { }
                else
                {
                    throw new Exception("AddAccessRule failed. 你需要手动处理发布内容！--检查权限");
                }
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                //TODO  Linux文件权限
            }
            else
            {
                throw new NotSupportedException(
                    $"{RuntimeInformation.OSDescription} is not supported."
                );
            }
        }
    }

    public static bool CheckDirAccess(string absolutePath, DirAcess[] access)
    {
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            DirectoryInfo dirInfo = new(absolutePath);
            //获得该文件的访问权限
            var dirSecurity = dirInfo.GetAccessControl();
            var ac = dirSecurity
                .GetAccessRules(true, true, typeof(System.Security.Principal.SecurityIdentifier))
                .Cast<FileSystemAccessRule>();
#pragma warning disable CA1416 // Validate platform compatibility
            var it =
                from i in ac
                where
                    (
                        WindowsIdentity.GetCurrent().Groups
                        ?? throw new NullReferenceException("未能获取当前用户组！")
                    ).Contains(i.IdentityReference)
                select i;
#pragma warning restore CA1416 // Validate platform compatibility
            List<DirAcess> caccess = [];
            foreach (var i in it)
            {
                if (i.FileSystemRights.HasFlag(FileSystemRights.FullControl))
                {
                    return true;
                }
                if (
                    i.FileSystemRights.HasFlag(
                        FileSystemRights.Read
                            | FileSystemRights.Modify
                            | FileSystemRights.ReadAndExecute
                    )
                )
                {
                    caccess.Add(DirAcess.Read);
                }
                if (i.FileSystemRights.HasFlag(FileSystemRights.Write | FileSystemRights.Modify))
                {
                    caccess.Add(DirAcess.Write);
                }
                if (i.FileSystemRights.HasFlag(FileSystemRights.Modify | FileSystemRights.Delete))
                {
                    caccess.Add(DirAcess.Delete);
                }
                if (
                    i.FileSystemRights.HasFlag(
                        FileSystemRights.ListDirectory | FileSystemRights.Modify
                    )
                )
                {
                    caccess.Add(DirAcess.ListDirectory);
                }
                if (
                    i.FileSystemRights.HasFlag(
                        FileSystemRights.CreateFiles | FileSystemRights.Modify
                    )
                )
                {
                    caccess.Add(DirAcess.CreateFiles);
                }
                if (
                    i.FileSystemRights.HasFlag(
                        FileSystemRights.CreateDirectories | FileSystemRights.Modify
                    )
                )
                {
                    caccess.Add(DirAcess.CreateDirectories);
                }
                if (
                    i.FileSystemRights.HasFlag(
                        FileSystemRights.DeleteSubdirectoriesAndFiles | FileSystemRights.Modify
                    )
                )
                {
                    caccess.Add(DirAcess.DeleteSubdirectoriesAndFiles);
                }
            }
            foreach (var i in access)
            {
                if (!caccess.Contains(i))
                {
                    return false;
                }
            }
            return true;
        }
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        {
            //TODO  Linux文件权限
            return true;
        }
        else
        {
            throw new NotSupportedException(
                $"{RuntimeInformation.OSDescription} is not supported."
            );
        }
    }

    public static bool CheckFileAccess(string absolutePath, FileAccess[] access)
    {
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            FileInfo fileInfo = new(absolutePath);
            //获得该文件的访问权限
            FileSecurity fileSecurity = fileInfo.GetAccessControl();

            var ac = fileSecurity
                .GetAccessRules(true, true, typeof(System.Security.Principal.SecurityIdentifier))
                .Cast<FileSystemAccessRule>();
#pragma warning disable CA1416 // 验证平台兼容性
            var it =
                from i in ac
                where
                    (
                        WindowsIdentity.GetCurrent().Groups
                        ?? throw new NullReferenceException("未能获取当前用户组！")
                    ).Contains(i.IdentityReference)
                select i;
#pragma warning restore CA1416 // 验证平台兼容性

            List<FileAccess> caccess = [];
            foreach (var i in it)
            {
                if (i.FileSystemRights.HasFlag(FileSystemRights.FullControl))
                {
                    return true;
                }
                if (i.FileSystemRights.HasFlag(FileSystemRights.Read | FileSystemRights.Modify))
                {
                    caccess.Add(FileAccess.Read);
                }
                if (i.FileSystemRights.HasFlag(FileSystemRights.Write | FileSystemRights.Modify))
                {
                    caccess.Add(FileAccess.Write);
                }
                if (i.FileSystemRights.HasFlag(FileSystemRights.Write | FileSystemRights.Modify))
                {
                    caccess.Add(FileAccess.Delete);
                }
                if (
                    i.FileSystemRights.HasFlag(
                        FileSystemRights.ExecuteFile | FileSystemRights.Modify
                    )
                )
                {
                    caccess.Add(FileAccess.Execute);
                }
            }
            foreach (var i in access)
            {
                if (!caccess.Contains(i))
                {
                    return false;
                }
            }
            return true;
        }
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        {
            //TODO  Linux文件夹权限
            return true;
        }
        else
        {
            throw new NotSupportedException(
                $"{RuntimeInformation.OSDescription} is not supported."
            );
        }
    }

    /// <summary>
    /// 获取当前用户
    /// </summary>
    /// <returns></returns>
    /// <exception cref="NotSupportedException"></exception>

    public static string GetCurrentUser()
    {
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            return System.Security.Principal.WindowsIdentity.GetCurrent().Name;
        }
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        {
            return Environment.UserName;
        }
        else
        {
            throw new NotSupportedException(
                $"{RuntimeInformation.OSDescription} is not supported."
            );
        }
    }
}