SSIS Zip Large File

#region Help:  Introduction to the script task
/* The Script Task allows you to perform virtually any operation that can be accomplished in
 * a .Net application within the context of an Integration Services control flow.
 *
 * Expand the other regions which have "Help" prefixes for examples of specific ways to use
 * Integration Services features within this script task. */
#endregion


#region Namespaces
using System;
using System.Data;
using Microsoft.SqlServer.Dts.Runtime;
using System.Windows.Forms;
using System.IO;
using System.IO.Compression;
#endregion

namespace ST_4cb59661fb81431abcf503766697a1db
{
    /// <summary>
    /// ScriptMain is the entry point class of the script.  Do not change the name, attributes,
    /// or parent of this class.
    /// </summary>
    [Microsoft.SqlServer.Dts.Tasks.ScriptTask.SSISScriptTaskEntryPointAttribute]
    public partial class ScriptMain : Microsoft.SqlServer.Dts.Tasks.ScriptTask.VSTARTScriptObjectModelBase
    {
        #region Help:  Using Integration Services variables and parameters in a script
        /* To use a variable in this script, first ensure that the variable has been added to
         * either the list contained in the ReadOnlyVariables property or the list contained in
         * the ReadWriteVariables property of this script task, according to whether or not your
         * code needs to write to the variable.  To add the variable, save this script, close this instance of
         * Visual Studio, and update the ReadOnlyVariables and
         * ReadWriteVariables properties in the Script Transformation Editor window.
         * To use a parameter in this script, follow the same steps. Parameters are always read-only.
         *
         * Example of reading from a variable:
         *  DateTime startTime = (DateTime) Dts.Variables["System::StartTime"].Value;
         *
         * Example of writing to a variable:
         *  Dts.Variables["User::myStringVariable"].Value = "new value";
         *
         * Example of reading from a package parameter:
         *  int batchId = (int) Dts.Variables["$Package::batchId"].Value;
         *
         * Example of reading from a project parameter:
         *  int batchId = (int) Dts.Variables["$Project::batchId"].Value;
         *
         * Example of reading from a sensitive project parameter:
         *  int batchId = (int) Dts.Variables["$Project::batchId"].GetSensitiveValue();
         * */

        #endregion

        #region Help:  Firing Integration Services events from a script
        /* This script task can fire events for logging purposes.
         *
         * Example of firing an error event:
         *  Dts.Events.FireError(18, "Process Values", "Bad value", "", 0);
         *
         * Example of firing an information event:
         *  Dts.Events.FireInformation(3, "Process Values", "Processing has started", "", 0, ref fireAgain)
         *
         * Example of firing a warning event:
         *  Dts.Events.FireWarning(14, "Process Values", "No values received for input", "", 0);
         * */
        #endregion

        #region Help:  Using Integration Services connection managers in a script
        /* Some types of connection managers can be used in this script task.  See the topic
         * "Working with Connection Managers Programatically" for details.
         *
         * Example of using an ADO.Net connection manager:
         *  object rawConnection = Dts.Connections["Sales DB"].AcquireConnection(Dts.Transaction);
         *  SqlConnection myADONETConnection = (SqlConnection)rawConnection;
         *  //Use the connection in some code here, then release the connection
         *  Dts.Connections["Sales DB"].ReleaseConnection(rawConnection);
         *
         * Example of using a File connection manager
         *  object rawConnection = Dts.Connections["Prices.zip"].AcquireConnection(Dts.Transaction);
         *  string filePath = (string)rawConnection;
         *  //Use the connection in some code here, then release the connection
         *  Dts.Connections["Prices.zip"].ReleaseConnection(rawConnection);
         * */
        #endregion


        /// <summary>
        /// This method is called when this script task executes in the control flow.
        /// Before returning from this method, set the value of Dts.TaskResult to indicate success or failure.
        /// To open Help, press F1.
        /// </summary>
        public void Main()
        {
            try
            {
                string strDate = DateTime.Now.ToString("yyyyMMdd");
                string strFolder = DateTime.Now.ToString("yyyyMM");

                string sFileName = String.Format(Dts.Variables["User::sFileName"].Value.ToString(), "CHRGUL", strDate + "_NONCTK");
                string sFilePath = Dts.Variables["User::sFilePath"].Value.ToString() + "DTST" +Path.DirectorySeparatorChar + strFolder + Path.DirectorySeparatorChar + sFileName;
                string sDestinationFolder = Dts.Variables["User::sDestination"].Value.ToString() + String.Format("DTST{0}", Path.DirectorySeparatorChar) + strFolder + Path.DirectorySeparatorChar;
                string sZipFile = sDestinationFolder + String.Format(Dts.Variables["User::sZipFile"].Value.ToString(), "CHRGUL", strDate + "_NONCTK");
                string sBackupFolder = Dts.Variables["User::sBackupFolder"].Value.ToString();

                System.IO.DirectoryInfo di = new DirectoryInfo(sDestinationFolder);

                #region Clean Dir ANST
                bool exists = System.IO.Directory.Exists(sDestinationFolder);
                if (!exists)
                    System.IO.Directory.CreateDirectory(sDestinationFolder);
                foreach (FileInfo file in di.GetFiles())
                {
                    file.Delete();
                }
                foreach (DirectoryInfo dir in di.GetDirectories())
                {
                    dir.Delete(true);
                }
                #endregion

                #region Create Zip File and Move source to Backup
                //CHRGUL
                AddFileToZipUsingStream(sZipFile, sFilePath, sFileName, sBackupFolder, "DTST");

                //ANSTHDR
                sFileName = String.Format(Dts.Variables["User::sFileName"].Value.ToString(), "TRANUL", strDate + "_NONCTK");
                sFilePath = Dts.Variables["User::sFilePath"].Value.ToString() + "DTST" + Path.DirectorySeparatorChar + strFolder + Path.DirectorySeparatorChar + sFileName;
                sDestinationFolder = Dts.Variables["User::sDestination"].Value.ToString() + String.Format("DTST{0}", Path.DirectorySeparatorChar) + strFolder + Path.DirectorySeparatorChar;
                sZipFile = sDestinationFolder + String.Format(Dts.Variables["User::sZipFile"].Value.ToString(), "TRANUL", strDate + "_NONCTK");
                AddFileToZipUsingStream(sZipFile, sFilePath, sFileName, sBackupFolder, "DTST");
                #endregion

                Dts.TaskResult = (int)ScriptResults.Success;
            }
            catch (Exception ex)
            {
                string filePath = String.Format(@"{0}\{1}.log", Dts.Variables["User::sLogFile"].Value.ToString(), DateTime.Now.ToString("yyyyMMddHHmmss"));

                using (StreamWriter writer = new StreamWriter(filePath, true))
                {
                    writer.WriteLine(ex.ToString());
                    writer.WriteLine(Environment.NewLine + "-----------------------------------------------------------------------------" + Environment.NewLine);
                }
                Dts.TaskResult = (int)ScriptResults.Failure;
            }
        }

        #region ScriptResults declaration
        /// <summary>
        /// This enum provides a convenient shorthand within the scope of this class for setting the
        /// result of the script.
        ///
        /// This code was generated automatically.
        /// </summary>
        enum ScriptResults
        {
            Success = Microsoft.SqlServer.Dts.Runtime.DTSExecResult.Success,
            Failure = Microsoft.SqlServer.Dts.Runtime.DTSExecResult.Failure
        };
        #endregion

        #region  Method
        protected bool AddFileToZip(string sZipFile, string sFilePath, string sFileName, string sBackupFolder, string sPrefixFolder)
        {
            bool bIsSuccess = false;
            try
            {
                if (File.Exists(sZipFile))
                {
                    using (ZipArchive addFile = ZipFile.Open(sZipFile, ZipArchiveMode.Update))
                    {
                        addFile.CreateEntryFromFile(sFilePath, sFileName);

                        //Move File after zipping it
                        BackupFile(sFilePath, sBackupFolder, sPrefixFolder);
                    }
                }
                else
                {
                    using (ZipArchive addFile = ZipFile.Open(sZipFile, ZipArchiveMode.Update))
                    {
                        addFile.CreateEntryFromFile(sFilePath, sFileName);
                    }

                    //Move File after zipping it
                    BackupFile(sFilePath, sBackupFolder, sPrefixFolder);
                }
                bIsSuccess = true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return bIsSuccess;
        }
        protected bool BackupFile(string sSourceFile, string sDestination, string sPrefixFolder)
        {
            bool bIsSuccess = false;
            try
            {
                string sDestinationPath = sDestination + sPrefixFolder + Path.DirectorySeparatorChar + DateTime.Now.ToString("yyyy") + Path.DirectorySeparatorChar + DateTime.Now.ToString("MM") + Path.DirectorySeparatorChar + DateTime.Now.ToString("dd");
                bool exists = System.IO.Directory.Exists(sDestinationPath);
                if (!exists)
                    System.IO.Directory.CreateDirectory(sDestinationPath);
                sDestinationPath += Path.DirectorySeparatorChar + Path.GetFileName(sSourceFile);
                exists = File.Exists(sDestinationPath);
                if (!exists)
                    File.Move(sSourceFile, sDestinationPath);
                else
                {
                    File.Delete(sDestinationPath);
                    File.Move(sSourceFile, sDestinationPath);
                }
                bIsSuccess = true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return bIsSuccess;
        }

        protected bool AddFileToZipUsingStream(string sZipFile, string sFilePath, string sFileName, string sBackupFolder, string sPrefixFolder)
        {
            bool bIsSuccess = false;
            try
            {
                if (File.Exists(sZipFile))
                {
                    using (ZipArchive addFile = ZipFile.Open(sZipFile, ZipArchiveMode.Update))
                    {
                        addFile.CreateEntryFromFile(sFilePath, sFileName);

                        //Move File after zipping it
                        BackupFile(sFilePath, sBackupFolder, sPrefixFolder);
                    }
                }
                else
                {
                    //TODO need to optimize Big File
                    //using (var memoryStream = new MemoryStream())
                    //{
                    //    using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Create, true))
                    //    {
                    //        var demoFile = archive.CreateEntry(sFileName);
                    //        using (var entryStream = demoFile.Open())
                    //        using (var streamWriter = new StreamWriter(entryStream))
                    //        {
                    //            streamWriter.Write("Bar!");
                    //        }
                    //    }
                    //    using (var fileStream = new FileStream(sZipFile, FileMode.Create))
                    //    {
                    //        memoryStream.Position = 0;
                    //        memoryStream.WriteTo(fileStream);
                    //    }
                    //}

                    //from http://stackoverflow.com/questions/28360775/adding-large-files-to-io-compression-ziparchiveentry-throws-outofmemoryexception
                    using (var zipFile = ZipFile.Open(sZipFile, ZipArchiveMode.Update))
                    {
                        var zipEntry = zipFile.CreateEntry(sFileName);
                        using (var writer = new BinaryWriter(zipEntry.Open()))
                        {
                            using (FileStream fs = File.Open(sFilePath, FileMode.Open))
                            {
                                var buffer = new byte[16 * 1024];
                                using (var data = new BinaryReader(fs))
                                {
                                    int read;
                                    while ((read = data.Read(buffer, 0, buffer.Length)) > 0)
                                    {
                                        writer.Write(buffer, 0, read);
                                    }
                                }
                            }
                        }
                    }

                    //Move File after zipping it
                    BackupFile(sFilePath, sBackupFolder, sPrefixFolder);
                }
                bIsSuccess = true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return bIsSuccess;
        }
        #endregion
    }
}