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;


namespace DirectOutput.GlobalConfiguration
{

    public class GlobalConfig
    {

        #region Led Control 


        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 LedControlIniFileList _LedControlIniFiles = new LedControlIniFileList();

        public LedControlIniFileList LedControlIniFiles
        {
            get { return _LedControlIniFiles; }
            set { _LedControlIniFiles = value; }
        }

        #endregion


        #region Cabinet

        #region Cabinet config file
        private FilePatternList _CabinetConfigFilePatterns = new FilePatternList();


        public FilePatternList CabinetConfigFilePatterns
        {
            get { return _CabinetConfigFilePatterns; }
            set { _CabinetConfigFilePatterns = value; }
        }


        public FileInfo GetCabinetConfigFile()
        {
            if (CabinetConfigFilePatterns != null)
            {
                return CabinetConfigFilePatterns.GetFirstMatchingFile(GetReplaceValuesDictionary());
            }
            return null;
        }


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


        #endregion


        #region Table



        #region Table script files
        private FilePatternList _TableScriptFilePatterns = new FilePatternList();

        public FilePatternList TableScriptFilePatterns
        {
            get { return _TableScriptFilePatterns; }
            set { _TableScriptFilePatterns = value; }
        }

        public List<FileInfo> GetTableScriptFiles(string FullTableFilename)
        {
            if (TableScriptFilePatterns != null)
            {
                return TableScriptFilePatterns.GetMatchingFiles(GetReplaceValuesDictionary(FullTableFilename));
            }
            return new List<FileInfo>();
        }
        #endregion


        #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 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 List<FileInfo> GetGlobalScriptFiles()
        {
            return GlobalScriptFilePatterns.GetMatchingFiles();
        }


        private FilePatternList _GlobalScriptFilePatterns = new FilePatternList();

        public FilePatternList GlobalScriptFilePatterns
        {
            get { return _GlobalScriptFilePatterns; }
            set { _GlobalScriptFilePatterns = value; }
        }

        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()
        {

         

        }

    }
}