GlobalConfig.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using DirectOutput.General;


namespace DirectOutput.GlobalConfiguration
{

    public class GlobalConfig
    {

        

        #region IniFiles


        private int _LedControlMinimumEffectDurationMs = 60;

        public int LedControlMinimumEffectDurationMs
        {
            get { return _LedControlMinimumEffectDurationMs; }
            set { _LedControlMinimumEffectDurationMs = value; }
        }

        private int _LedControlMinimumRGBEffectDurationMs = 120;

        public int LedControlMinimumRGBEffectDurationMs
        {
            get { return _LedControlMinimumRGBEffectDurationMs; }
            set { _LedControlMinimumRGBEffectDurationMs = value; }
        }



        private string _IniFilesPath="";

        public string IniFilesPath
        {
            get { return _IniFilesPath; }
            set { _IniFilesPath = value; }
        }


        public Dictionary<int, FileInfo> GetIniFilesDictionary(string TableFilename = "")
        {
           //Build the array of possible paths for the ini files

            List<string> LookupPaths = new List<string>();

            if (!IniFilesPath.IsNullOrWhiteSpace())
            {
                try
                {
                    DirectoryInfo DI = new DirectoryInfo(IniFilesPath);
                    if (DI.Exists)
                    {
                        LookupPaths.Add(DI.FullName);
                    }
                } catch (Exception E) {
                    Log.Exception("The specified IniFilesPath {0} could not be used due to a exception.".Build(IniFilesPath),E);
                } ;
            }


            if (!TableFilename.IsNullOrWhiteSpace())
            {
                try
                {
                    if (new FileInfo(TableFilename).Directory.Exists)
                    {
                        LookupPaths.Add(new FileInfo(TableFilename).Directory.FullName);
                    }
                }
                catch { }
            }


            LookupPaths.AddRange(new string[] { GetGlobalConfigDirectory().FullName, Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) });

            //Build the dictionary of ini files

            Dictionary<int, FileInfo> IniFiles = new Dictionary<int, FileInfo>();

            bool FoundIt = false;
            string[] LedControlFilenames = { "directoutputconfig", "ledcontrol" };

            foreach (string LedControlFilename in LedControlFilenames)
            {
                foreach (string P in LookupPaths) 
                {
                    DirectoryInfo DI = new DirectoryInfo(P);

                    List<FileInfo> Files = new List<FileInfo>();
                    foreach (FileInfo FI in DI.EnumerateFiles())
                    {
                        if (FI.Name.ToLower().StartsWith(LedControlFilename.ToLower()) && FI.Name.ToLower().EndsWith(".ini"))
                        {
                            Files.Add(FI);
                        }
                    }


                    foreach (FileInfo FI in Files)
                    {
                        if (string.Equals(FI.Name, "{0}.ini".Build(LedControlFilename), StringComparison.OrdinalIgnoreCase))
                        {
                            if (!IniFiles.ContainsKey(1))
                            {
                                IniFiles.Add(1, FI);
                                FoundIt = true;
                            }
                            else
                            {
                                Log.Warning("Found more than one ini file with for number 1. Likely you have a ini file without a number and and a second one with number 1.");
                            }
                        }
                        else
                        {
                            string F = FI.Name.Substring(LedControlFilename.Length, FI.Name.Length - LedControlFilename.Length - 4);
                            if (F.IsInteger())
                            {
                                int LedWizNr = -1;
                                if (int.TryParse(F, out LedWizNr))
                                {
                                    if (!IniFiles.ContainsKey(LedWizNr))
                                    {
                                        IniFiles.Add(LedWizNr, FI);
                                        FoundIt = true;
                                    }
                                    else
                                    {
                                        Log.Warning("Found more than one ini file with number {0}.".Build(LedWizNr));
                                    }
 
                                }

                            }

                        }
                    };
                    if (FoundIt) break;
                }
                if (FoundIt) break;
            }



            return IniFiles;

        }




        #endregion


        #region Cabinet

        #region Cabinet config file


        private FilePattern _CabinetConfigFilePattern=new FilePattern();

        public FilePattern CabinetConfigFilePattern
        {
            get { return _CabinetConfigFilePattern; }
            set { _CabinetConfigFilePattern = value; }
        }
        



        public FileInfo GetCabinetConfigFile()
        {
            if (!CabinetConfigFilePattern.Pattern.IsNullOrWhiteSpace() && CabinetConfigFilePattern.IsValid)
            {
                return CabinetConfigFilePattern.GetFirstMatchingFile(GetReplaceValuesDictionary());
            }
   
            return null;
        }


        public DirectoryInfo GetCabinetConfigDirectory()
        {
            FileInfo CC = GetCabinetConfigFile();
            if (CC != null)
            {
                return CC.Directory;
            }
            return null;
        }
        #endregion


        #endregion


        #region Table






        #region Table Config
        private FilePatternList _TableConfigFilePatterns = new FilePatternList();

        public FilePatternList TableConfigFilePatterns
        {
            get { return _TableConfigFilePatterns; }
            set { _TableConfigFilePatterns = value; }
        }

        public FileInfo GetTableConfigFile(string FullTableFilename)
        {
            return TableConfigFilePatterns.GetFirstMatchingFile(GetReplaceValuesDictionary(FullTableFilename));
        }

        #endregion


        #endregion



        #region Logging
        private bool _EnableLog = false;


        public bool EnableLogging
        {
            get { return _EnableLog; }
            set { _EnableLog = value; }
        }

        private bool _ClearLogOnSessionStart=false;

        public bool ClearLogOnSessionStart
        {
            get { return _ClearLogOnSessionStart; }
            set { _ClearLogOnSessionStart = value; }
        }
        



        private FilePattern _LogFilePattern = new FilePattern(".\\DirectOutput.log");


        public FilePattern LogFilePattern
        {
            get { return _LogFilePattern; }
            set { _LogFilePattern = value; }
        }

        public string GetLogFilename(string TableFilename = "", string RomName = "")
        {
            Dictionary<string, string> R = GetReplaceValuesDictionary(TableFilename, RomName);
            R.Add("DateTime", DateTime.Now.ToString("yyyyMMdd_hhmmss"));
            R.Add("Date", DateTime.Now.ToString("yyyyMMdd"));
            R.Add("Time", DateTime.Now.ToString("hhmmss"));

            return LogFilePattern.ReplacePlaceholders(R);
        }

        #endregion



        private Dictionary<string, string> GetReplaceValuesDictionary(string TableFileName = null, string RomName = "")
        {
            Dictionary<string, string> D = new Dictionary<string, string>();
            if (GetGlobalConfigFile() != null)
            {
                D.Add("GlobalConfigDirectory", GetGlobalConfigDirectory().FullName);
                D.Add("GlobalConfigDir", GetGlobalConfigDirectory().FullName);
            }

            FileInfo FI = new FileInfo(Assembly.GetExecutingAssembly().Location);
            D.Add("DllDirectory", FI.Directory.FullName);
            D.Add("DllDir", FI.Directory.FullName);
            D.Add("AssemblyDirectory", FI.Directory.FullName);
            D.Add("AssemblyDir", FI.Directory.FullName);
            if (!TableFileName.IsNullOrWhiteSpace())
            {
                FI = new FileInfo(TableFileName);
                if (FI.Directory.Exists)
                {
                    D.Add("TableDirectory", FI.Directory.FullName);
                    D.Add("TableDir", FI.Directory.FullName);
                    D.Add("TableDirectoryName", FI.Directory.Name);
                    D.Add("TableDirName", FI.Directory.Name);
                }

                    D.Add("TableName", Path.GetFileNameWithoutExtension(FI.FullName));
            }
            if (!RomName.IsNullOrWhiteSpace())
            {
                D.Add("RomName", RomName);
            }


            return D;

        }



        #region Global config properties


        public string GlobalConfigDirectoryName()
        {
            DirectoryInfo DI = GetGlobalConfigDirectory();
            if (DI == null) return null;
            return DI.FullName;
        }

        public DirectoryInfo GetGlobalConfigDirectory()
        {
            FileInfo FI = GetGlobalConfigFile();
            if (FI == null) return null;
            return FI.Directory;

        }


        private string _GlobalConfigFilename = "";

        [XmlIgnore]
        public string GlobalConfigFilename
        {
            get { return _GlobalConfigFilename; }
            set { _GlobalConfigFilename = value; }
        }


        public FileInfo GetGlobalConfigFile()
        {
            if (GlobalConfigFilename.IsNullOrWhiteSpace()) { return null; }
            return new FileInfo(GlobalConfigFilename);
        }
        #endregion


        #region Serialization




        public string GetGlobalConfigXml()
        {

            XmlSerializerNamespaces Namespaces = new XmlSerializerNamespaces();
            Namespaces.Add(string.Empty, string.Empty);
            XmlSerializer Serializer = new XmlSerializer(typeof(GlobalConfig));
            MemoryStream Stream = new MemoryStream();
            XmlWriterSettings Settings = new XmlWriterSettings();
            Settings.Indent = true;
            Settings.NewLineOnAttributes = true;

            XmlWriter Writer = XmlWriter.Create(Stream, Settings);
            Writer.WriteStartDocument();
            Writer.WriteComment("Global configuration for the DirectOutput framework.");
            Writer.WriteComment("Saved by DirectOutput Version {1}: {0}".Build(DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss"), System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString()));
            Serializer.Serialize(Writer, this, Namespaces);
            Writer.WriteEndDocument();
            Writer.Flush();
            Stream.Position = 0;
            string XML;
            using (StreamReader sr = new StreamReader(Stream, Encoding.Default))
            {
                XML = sr.ReadToEnd();
                sr.Dispose();
            }
            Stream.Dispose();

            return XML;
        }



        public static GlobalConfig GetGlobalConfigFromConfigXmlFile(string GlobalConfigFileName)
        {

            try
            {
                if (File.Exists(GlobalConfigFileName))
                {


                    string Xml = General.FileReader.ReadFileToString(GlobalConfigFileName);

                    GlobalConfig GC = GetGlobalConfigFromGlobalConfigXml(Xml);
                    if (GC != null)
                    {
                        GC.GlobalConfigFilename = GlobalConfigFileName;
                    }
                    return GC;

                }
                else
                {

                    return null;
                }
            }
            catch
            {

                return null;
            }
        }


        public static GlobalConfig GetGlobalConfigFromGlobalConfigXml(string ConfigXml)
        {
            try
            {

                byte[] xmlBytes = Encoding.Default.GetBytes(ConfigXml);
                using (MemoryStream ms = new MemoryStream(xmlBytes))
                {
                    return (GlobalConfig)new XmlSerializer(typeof(GlobalConfig)).Deserialize(ms);
                }
            }
            catch { return null; }

        }

        public void SaveGlobalConfig(string GlobalConfigFilename = "")
        {
            string GCFileName = (GlobalConfigFilename.IsNullOrWhiteSpace() ? this.GlobalConfigFilename : GlobalConfigFilename);
            if (GCFileName.IsNullOrWhiteSpace())
            {
                ArgumentException Ex = new ArgumentException("No filename for GlobalConfig file has been supplied. Looking up the filename from the property GlobalConfigFilename failed as well");
                throw Ex;
            }
            if (File.Exists(GCFileName))
            {
                //Create a backup of the current global config file
                File.Copy(GCFileName, Path.Combine(Path.GetDirectoryName(GCFileName), "{1} old (replaced {0}){2}".Build(DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss"), Path.GetFileNameWithoutExtension(GCFileName), Path.GetExtension(GCFileName))));
            };
            DirectoryInfo GCDirectory = new FileInfo(GCFileName).Directory;

            GCDirectory.CreateDirectoryPath();
            GetGlobalConfigXml().WriteToFile(GCFileName, false);

        }
        #endregion


        public GlobalConfig()
        {

         

        }

    }
}