com_wms_zip.cs contains methods supports zip archive manip

using System;
using System.IO;
using System.IO.Compression;
using System.Collections.Generic;
using System.Text;

namespace com.wms.zip{

    /*
        + https://gist.github.com/kyrathasoft/b001c6c07c13180dbdfba44c500d0171
    */

    public class ClassZip{

        public static bool AddTextFileEntryByUpdatingArchive(string txt_content, string txt_filename, string archive_path){
            bool succeeded = false;
            try{
                using (FileStream zipToOpen = new FileStream(archive_path, FileMode.Open)){
                    using (ZipArchive archive = new ZipArchive(zipToOpen, ZipArchiveMode.Update)){
                        ZipArchiveEntry readmeEntry = archive.CreateEntry(txt_filename);
                        using (StreamWriter writer = new StreamWriter(readmeEntry.Open())){
                            writer.Write(txt_content);
                        }
                    }
                }
                succeeded = true;
            }catch{}
            return succeeded;
        }

        public static bool AddingExistingFileByUpdatingArchive(string filepath, string archive_path){
            bool succeeded = false;
            try{
                using (FileStream zipToOpen = new FileStream(archive_path, FileMode.Open)){
                    using (ZipArchive archive = new ZipArchive(zipToOpen, ZipArchiveMode.Update)){
                        ZipArchiveEntry readmeEntry = archive.CreateEntry(Path.GetFileName(filepath));
                    }
                }
                succeeded = true;
            }catch{}
            return succeeded;
        }

        public static bool CreateZipArchiveFromDirectory(string targetDir){
            bool succeeded = false;
            if(IsValidPath(targetDir, false)){
                string fileOut = new DirectoryInfo(targetDir).Name + ".zip";
                try{
                    string _fileout = fileOut;
                    ZipFile.CreateFromDirectory(targetDir, fileOut);
                    Console.WriteLine("\n Zip archive was successfully created.");
                    succeeded = true;
                }catch(Exception exWhileZipping){
                    Console.Write("\n {0} + \n {1}", exWhileZipping.Message, targetDir);
                }
            }else{
                if(targetDir.Length > 0){
                    Console.Write("\n Invalid path: {0}", targetDir);
                }
            }
            return succeeded;
        }

        public static int CountEntriesInArchive(string zipPath){
            int count = 0;
            int cnt = 0;
            try{
                using (ZipArchive archive = ZipFile.OpenRead(zipPath)){
                    foreach (ZipArchiveEntry entry in archive.Entries){cnt++;}
                }
                count = cnt;
            }catch{}
            return count;
        }

        public static bool DeleteFileFromArchive(string zipPath, string fileToDelete){
            bool succeeded = false;
            try{
                using (FileStream zipToOpen = new FileStream(zipPath, FileMode.Open)){
                    using (ZipArchive archive = new ZipArchive(zipToOpen, ZipArchiveMode.Update)){
                        foreach(ZipArchiveEntry entry in archive.Entries){
                            if(entry.FullName.Contains(fileToDelete) || entry.FullName == fileToDelete){
                                entry.Delete();
                                succeeded = true;
                            }
                        }
                    }
                }
            }catch{}
            return succeeded;
        }

        public static bool ExtractArchiveToDirectoryWithSilentOverwrite(string zipPath, string extractPath){
            bool succeeded = false;
            try{
                using (ZipArchive archive = ZipFile.OpenRead(zipPath)){
                    foreach (ZipArchiveEntry entry in archive.Entries){
                        entry.ExtractToFile(Path.Combine(extractPath, entry.FullName), true);
                    }
                }
                succeeded = true;
            }catch{}

            return succeeded;
        }

        public static bool ExtractArchiveToDirectory(string archive, string targetDirectory){
            bool success = false;
            if(File.Exists(archive)){
                if(!Directory.Exists(targetDirectory)){
                    try{
                        Directory.CreateDirectory(targetDirectory);
                    }catch(Exception exAttemptingCreateDir){
                        Console.WriteLine("Error while attempting to create directory for zip extraction...");
                        Console.WriteLine(exAttemptingCreateDir.Message);
                    }
                }
                try{
                    ZipFile.ExtractToDirectory(archive, targetDirectory);
                }catch(Exception exWhileExtracting){
                    Console.WriteLine("Error during zip extraction...");
                    Console.WriteLine(exWhileExtracting.Message);
                }
            }

            return success;
        }

        public static bool ExtractFileFromArchive(string filename, string zipPath, string extractPath){
            bool succeeded = false;
            try{
                using (ZipArchive archive = ZipFile.OpenRead(zipPath)){
                    foreach (ZipArchiveEntry entry in archive.Entries){
                        string fname = entry.FullName;
                        if(fname.Contains(filename)){
                            string destinationPath = Path.GetFullPath(Path.Combine(extractPath, entry.FullName));
                            //Console.WriteLine("\n Dest. path: {0}", destinationPath);
                            entry.ExtractToFile(destinationPath);
                        }
                    }
                }
                succeeded = true;
            }catch{}

            return succeeded;

        }

        public static bool CompressDirectoryToZipArchive(string targetDirectory, string outputDirectory){
            bool success = false;
            if(Directory.Exists(targetDirectory)){
                int subdirs = CountDirectoriesRecursively(targetDirectory);
                int files = GetDirectoryFileCount(targetDirectory);
                if((subdirs >= 0) && (files > 0)){
                    try{
                        string dirName = new DirectoryInfo(targetDirectory).Name;
                        try{
                            if(Directory.Exists(outputDirectory)){
                                dirName = outputDirectory + "\\" + dirName;
                            }
                        }catch{}
                        string fileOut = dirName + ".zip";
                        ZipFile.CreateFromDirectory(targetDirectory, fileOut);
                        success = true;
                    }catch(Exception exWhileTryingToCompressToZip){
                        Console.WriteLine(" Error in CompressDirectoryToZipArchive() method:");
                        Console.WriteLine(" " + exWhileTryingToCompressToZip.Message);
                    }
                }
            }

            return success;
        }

        public static int CountDirectoriesRecursively(string targetDirectory){
            int iDirs = 0; //if targetDirectory exists, returns total # of all subdirectories, even nested ones
            if(Directory.Exists(targetDirectory)){
                iDirs = Directory.GetDirectories(targetDirectory, "*", SearchOption.AllDirectories).Length;
            }
            return iDirs;
        }

        public static int GetDirectoryFileCount(string path){
            int fileCount = 0;
            if(Directory.Exists(path)){
                fileCount = Directory.GetFiles(path, "*.*", SearchOption.AllDirectories).Length;
            }
            return fileCount;
        }

        public static List<string> GetFilesContainedInZipArchive(string zipPath){

            List<string> files = new List<string>();
            using (ZipArchive archive = ZipFile.OpenRead(zipPath)){
               foreach (ZipArchiveEntry entry in archive.Entries){
                   files.Add(entry.FullName);
               }
            }

            return files;
        }

        public static string[] GetTopLevelDirFiles(string path){
            string[] files = Directory.GetFiles(path, "*.*", SearchOption.TopDirectoryOnly);
            return files;
        }

        public static bool ClearDirAndSubdirsOfFiles(string targetDirectory) {
            bool succeeded = false;

            try{
                // Process the list of files found in the directory.
                string [] fileEntries = Directory.GetFiles(targetDirectory);
                foreach(string fileName in fileEntries)
                    ProcessFile(fileName);

                // Recurse into subdirectories of this directory.
                string [] subdirectoryEntries = Directory.GetDirectories(targetDirectory);
                foreach(string subdirectory in subdirectoryEntries){
                    ClearDirAndSubdirsOfFiles(subdirectory);
                }

                succeeded = true;

            }catch{}

            return succeeded;
        }

        public static bool IsValidPath(string path, bool allowRelativePaths = false){
            bool isValid = true;

            try{
                string fullPath = Path.GetFullPath(path);

                if (allowRelativePaths){
                    isValid = Path.IsPathRooted(path);
                }
                else{
                    string root = Path.GetPathRoot(path);
                    isValid = string.IsNullOrEmpty(root.Trim(new char[] { '\\', '/' })) == false;
                }
            }
            catch(Exception ex){
                isValid = false;
                Console.WriteLine("\n " + ex.Message);
            }

            return isValid;
        }

        public static void ProcessDirectory(string targetDirectory)
        {
            // Process the list of files found in the directory.
            string [] fileEntries = Directory.GetFiles(targetDirectory);
            foreach(string fileName in fileEntries)
                ProcessFile(fileName);
            // Recurse into subdirectories of this directory.
            string [] subdirectoryEntries = Directory.GetDirectories(targetDirectory);
            foreach(string subdirectory in subdirectoryEntries)
                ProcessDirectory(subdirectory);
        }

        public static void ProcessFile(string path){
            FileInfo fi = new FileInfo(path);
            File.Delete(fi.FullName);
        }

        public static string SanitizeExtractPath(string p){
            string result = p;

            result = Path.GetFullPath(result);
            if (!result.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal)){
                result += Path.DirectorySeparatorChar;
            }

            return p;
        }

        public static bool ZipArchiveContainsThisFile(string _archive, string _filename_in_question){
                bool result = false;
                if(!File.Exists(_archive)){
                    //control falls through; false is returned...
                }else{
                    using(ZipArchive archive = ZipFile.OpenRead(_archive)){
                        foreach(ZipArchiveEntry entry in archive.Entries){
                            string filename = Path.GetFileName(entry.FullName);
                            if(filename == _filename_in_question){
                                result = true;
                                break;
                            }
                        }
                    }
                }
                return result;
        }

    }

}