ConfigurationIO.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.Serialization;
using Seci.Definitions;

namespace Seci.Helpers
{
    internal static class ConfigurationIO
    {
        #region Load

        public static Configuration LoadConfig(String fileName)
        {
            try
            {
                //Deserialise the required configuration file
                Configuration temp = DeserialiseConfig(fileName);

                //If any blocks were set not to save run control settings
                //Then they need to be set to run control disabled.
                for (int i = 0; i < temp.Blocks.Count; ++i)
                {

                    //Fix for back compatability
                    if (temp.Blocks[i].ValueFormatting != null && temp.Blocks[i].ValueFormatting.Contains("#"))
                    {
                        temp.Blocks[i].ValueFormatting = temp.Blocks[i].ValueFormatting.Replace('#', '0');
                    }

                    if (!temp.Blocks[i].SaveSettings)
                    {
                        temp.Blocks[i].UnderRunControl = false;
                        temp.Blocks[i].LowerLimit = Double.NegativeInfinity;
                        temp.Blocks[i].UpperLimit = Double.PositiveInfinity;
                        temp.Blocks[i].RunControlValue = "";
                    }
                }

                //Check to see if the configuration contains any components
                //that need to be loaded
                List<String> compNames = new List<String>();
                compNames.AddRange(temp.Components.Components);

                //Now load and add any components
                for (int i = 0; i < compNames.Count; ++i)
                {
                    try
                    {
                        temp.Components[i] = (DeserialiseConfig(Status.ConfigDir + compNames[i]));

                        //Set the owning name of the blocks to that of the component.
                        //Also set run control values based on whether SaveSettings was true
                        for (int j = 0; j < temp.Components[i].Blocks.Count; ++j)
                        {
                            temp.Components[i].Blocks[j].OwningComponent = temp.Components[i].ConfigName;
                            if (!temp.Components[i].Blocks[j].SaveSettings)
                            {
                                temp.Components[i].Blocks[j].UnderRunControl = false;
                                temp.Components[i].Blocks[j].LowerLimit = Double.NegativeInfinity;
                                temp.Components[i].Blocks[j].UpperLimit = Double.PositiveInfinity;
                                temp.Components[i].Blocks[j].RunControlValue = "";
                            }
                        }

                        //then add to the block dictionary
                        temp.Blocks.AddDictionary(temp.Components[i].Blocks);
                        //temp.Components[i].Blocks = null;

                        //Add any alerts
                        Seci.Managers.AlertsMgr.AddComponentBox(temp.Alerts, temp.Components[i].Alerts, compNames[i]);

                        //Set the the owning name of the graphs in the component
                        for (int j = 0; j < temp.Components[i].GraphDefinitions.Count; ++j)
                        {
                            temp.Components[i].GraphDefinitions[j].OwningComponent = temp.Components[i].ConfigName; 
                        }
                        //then add to the configuration
                        temp.GraphDefinitions.AddRange(temp.Components[i].GraphDefinitions);

                    }
                    catch
                    {
                        throw new Exception("Could not load component: " + temp.Components[i].ConfigName);
                    }
                }

                return temp;
            }
            catch (Exception e)
            {
                //throw error up to next level
                throw new ArgumentException(e.Message);
            }
        }

        public static Configuration DeserialiseConfig(String fileName)
        {
            //deserialises a xml config file
            FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
            Configuration conf = null;

            try
            {
                XmlSerializer deserialize = new XmlSerializer(typeof(Configuration));
                conf = (Configuration)deserialize.Deserialize(stream);

            }
            catch (Exception e)
            {
                //throw error up to next level
                throw new ArgumentException(e.Message);
            }
            finally
            {
                stream.Close();
            }
            return conf;
        }

        #endregion

        #region Save

        public static bool OkayToSave(String configName, Boolean manager)
        {
            try
            {
                //Sort out fileName
                String fileName = Status.ConfigDir + configName;

                //Does the config already exist?
                FileInfo fi = new FileInfo(fileName);

                if (fi.Exists)
                {
                    //First read the config
                    XmlDocument conf = createXmlDocFromConfig(fileName);

                    //The check the nodes
                    XmlNodeList nodelist = conf.SelectNodes("/Configuration/SavedAsManager");

                    if (nodelist.Count > 0)
                    {
                        //Was it saved previously by the manager account and is the current user = manager
                        if ((nodelist[0].InnerText == "true") && (manager == false))
                        {
                            //Don't save it
                            return false;
                        }
                    }
                }

                //Okay to save
                return true;
            }
            catch (Exception err)
            {
                //If this throws log it and return false
                ErrorLogger.SeciError("OkayToSave", err);
                return false;
            }
        }

        public static void SaveConfig(Configuration conf, Boolean isAutosave, String fileName)
        {
            FileInfo fi = new FileInfo(fileName);
            if (fi.Exists)
            {
                //make sure it is not read only
                fi.IsReadOnly = false;
                if (!isAutosave)
                {
                    createLocalBackup(conf.ConfigName, fi);
                }
            }

            //Create the stream
            FileStream stream = new FileStream(fileName, FileMode.Create);

            try
            {
                //Serialise the config
                XmlSerializer serialize = new XmlSerializer(typeof(Configuration));
                serialize.Serialize(stream, conf);

            }
            catch (Exception e)
            {
                //throw error up to next level
                throw new ArgumentException(e.Message);
            }
            finally
            {
                stream.Close();
            }

            //Clear the byte array of any associated files as it is just wasting memory once saved.
            for (int i = 0; i < conf.AssociatedFiles.Count; ++i)
            {
                conf.AssociatedFiles[i].FileData = null;
            }
        }

        private static void createLocalBackup(String configName, FileInfo fi)
        {
            //Create a back-up version with name fileName.conf.X 
            //where X is the version number.
            DirectoryInfo di = new DirectoryInfo(Status.ConfigDir);

            List<FileInfo> files = new List<FileInfo>();
            files.AddRange(di.GetFiles());

            string versionMatch = configName.Replace("+", @"\+") + @"\.\d+$";
            Regex r = new Regex(versionMatch, RegexOptions.IgnoreCase);

            int version = 0;

            foreach (FileInfo f in files)
            {
                if (r.Match(f.Name).Success)
                {
                    int tempVer = Convert.ToInt32(f.Name.Substring(f.Name.LastIndexOf('.') + 1));
                    if (tempVer > version)
                    {
                        version = tempVer;
                    }
                }
            }

            fi.MoveTo(fi.FullName + "." + (++version).ToString());
        }

        private static XmlDocument createXmlDocFromConfig(String fileName)
        {
            try
            {
                XmlDocument conf = new XmlDocument();

                conf.Load(fileName);

                return conf;
            }
            catch (Exception e)
            {
                //throw error up to next level
                throw new ArgumentException(e.Message);
            }
        }

        #endregion
    }
}