using System;
using System.Configuration;
using Microsoft.SqlServer.Dts.Runtime;
using System.Reflection;
using System.Collections;
using System.IO;
using System.Collections.Generic;
 
namespace SSISForcedLogging.Console
{
    class ColumnFilter
    {
        public bool Computer;
        public bool DataBytes;
        public bool ExecutionID;
        public bool MessageText;
        public bool Operator;
        public bool SourceID;
        public bool SourceName;
 
        public DTSEventColumnFilter GetDTSEventColumnFilter()
        {
            DTSEventColumnFilter dtsEventColumnFilter = 
                new DTSEventColumnFilter();
            dtsEventColumnFilter.DataBytes = this.DataBytes;
            dtsEventColumnFilter.Computer = this.Computer;
            dtsEventColumnFilter.ExecutionID = this.ExecutionID;
            dtsEventColumnFilter.MessageText = this.MessageText;
            dtsEventColumnFilter.Operator = this.Operator;
            dtsEventColumnFilter.SourceID = this.SourceID;
            dtsEventColumnFilter.SourceName = this.SourceName;
            return dtsEventColumnFilter;
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length != 1)
            {
                System.Console.WriteLine(
                    "\nPlease specify a package path or directory\n");
                Environment.Exit(-1);
            }
 
            string arg = args[0];
            List<string> packages = new List<string>();
 
            if (File.Exists(arg))
                packages.Add(arg);
            else if (Directory.Exists(arg))
                packages = GetPackagesFromDirectory(arg);
            else
            {
                System.Console.WriteLine(
                    "\nInvalid package path or directory specified\n");
                Environment.Exit(-1);
            }
 
            foreach (string pkgPath in packages)
            {
                System.Console.WriteLine(
                    string.Format("Updating: {0}", pkgPath));
                Application dts = new Application();
                Package pkg = dts.LoadPackage(pkgPath, null);
 
                RemoveOldLogsFromPackage(ref pkg);
                AddLogToPackage(ref pkg);
 
                System.Console.WriteLine(
                    string.Format("Saving: {0}", pkgPath));
                dts.SaveToXml(pkgPath, pkg, null);
            }
        }
 
        public static void AddLogToPackage(ref Package Pkg)
        {
            // Add new provider
            Pkg.LoggingMode = DTSLoggingMode.Enabled;
 
            LogProvider log = Pkg.LogProviders.Add(
                ConfigurationManager.AppSettings["logType"]);
            log.Name = 
                ConfigurationManager.AppSettings["logName"];
            log.Description = 
                ConfigurationManager.AppSettings["logDesc"];
            Pkg.LoggingOptions.SelectedLogProviders.Add(log);
 
            LoggingOptions logOptions = Pkg.LoggingOptions;
            logOptions.EventFilterKind = DTSEventFilterKind.Inclusion;
 
            string[] events = 
                ConfigurationManager
                    .AppSettings["eventsToLog"]
                        .Split(',');
            logOptions.EventFilter = events;
 
            ArrayList columnList = new ArrayList();
            columnList.AddRange(
                ConfigurationManager
                    .AppSettings["columnsToLog"]
                        .Split(','));
 
            ColumnFilter eventColumnFilter = new ColumnFilter();
 
            foreach (FieldInfo field in 
                     eventColumnFilter.GetType().GetFields())
                if (columnList.Contains(field.Name))
                    field.SetValue(eventColumnFilter, true);
 
            logOptions.SetColumnFilter(
                "OnError", 
                eventColumnFilter.GetDTSEventColumnFilter());
 
        }
 
        public static void RemoveOldLogsFromPackage(ref Package Pkg)
        {
            // Remove existing log provider selections
            int count = Pkg.LoggingOptions.SelectedLogProviders.Count;
            for (int i = 0; i < count; i++)
                Pkg.LoggingOptions.SelectedLogProviders.Remove(i);
 
            // Remove existing log providers
            count = Pkg.LogProviders.Count;
            for (int i = 0; i < count; i++)
                Pkg.LogProviders.Remove(i);
 
            RemoveOldLogsFromExecutable(Pkg.Executables);
 
        }
 
        public static void RemoveOldLogsFromExecutable(Executables Execs)
        {
            // reflection ftw
            int count;
            foreach(Executable exec in Execs) 
            {
                foreach (PropertyInfo prop in 
                         exec.GetType().GetProperties())
                {
                    switch(prop.Name) {
                        case "LoggingMode":
                            prop.SetValue(
                                exec, 
                                DTSLoggingMode.UseParentSetting, 
                                null);
                            break;
                        case "LoggingOptions":
                            LoggingOptions opts = 
                                prop.GetValue(
                                    exec, 
                                    null) as LoggingOptions;
 
                            count = opts.SelectedLogProviders.Count;
                            for (int i = 0; i < count; i++)
                                opts.SelectedLogProviders.Remove(i);
                            break;
                        case "Executables":
                            Executables execs = 
                                prop.GetValue(
                                exec, 
                                null) as Executables;
                            RemoveOldLogsFromExecutable(execs);
                            break;
                    }
                }
            }
        }
 
        public static List<string> GetPackagesFromDirectory(string Path)
        {
            List<string> files = new List<string>();
 
            foreach (string d in Directory.GetDirectories(Path))
                foreach (string f in GetPackagesFromDirectory(d))
                    files.Add(f);
 
            foreach (string f in Directory.GetFiles(Path, "*.dtsx"))
                files.Add(f);
 
            return files;
        }
    }
}