tbf/TBF/BenchControl/ComponentCfgBase.cs

///
/// Copyright (c) 2013-2019 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;
using Config.Entities;
using TBF.BenchControl.Generic;

namespace TBF.BenchControl
{
    public class ComponentCfgBase
    {
		[XmlIgnore]
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        string name;

		[XmlIgnore]
		public Generic.IComponentFactory Factory
		{
			get { return factory; }
			set { factory = value; }
		}
		Generic.IComponentFactory factory;

        [XmlIgnore]
        public string ClassName
        {
            get { return Factory.ToString(); }
        }

		[XmlIgnore]
        public string ParentName
        {
            get { return parentName; }
            set { parentName = value; }
        }
        string parentName;

        [XmlIgnore]
        public int ItemNr
        {
            get { return itemNr; }
            set { itemNr = value; }
        }
        int itemNr;

        [XmlIgnore]
        public DebugMode DebugLevel
		{
			get { return debugLevel; }
			set { debugLevel = value; }
		}
        DebugMode debugLevel;

        [XmlIgnore]
        public LogLevel LogLevel
        {
            get { return logLevel; }
            set { logLevel = value; }
        }
        LogLevel logLevel;

		[XmlIgnore]
		public IList<MeasurementCorrection> Corrections
        {
            get { return corrections; }
            set { corrections = value; }
        }
		IList<MeasurementCorrection> corrections;

        [XmlIgnore]
        public IList<Uncertainty> Uncertainties
        {
            get { return uncertainties; }
            set { uncertainties = value; }
        }
        IList<Uncertainty> uncertainties;


        protected ComponentCfgBase()
        {
            itemNr = 0;
            debugLevel = DebugMode.Normal;
            logLevel = LogLevel.Off;
        }

        protected ComponentCfgBase(Generic.IComponentFactory factory)
            : this()
        {
            this.factory = factory;
        }

        protected ComponentCfgBase(Generic.IComponentFactory factory, string name)
            : this(factory)
        {
            this.name = name;
        }

        protected ComponentCfgBase(Generic.IComponentFactory factory, string name, string parentName)
            : this(factory, name)
        {
            this.parentName = parentName;
        }


		public virtual XmlSerializer GetSerializer() { return new XmlSerializer(GetType()); }
		
        public Component CreateDbEntity()
        {
            using (var writer = new StringWriter())
            {
				GetSerializer().Serialize(writer, this);
                return Component.CreateFromCfg(Name, factory.ClassName, ParentName, ItemNr, DebugLevel, LogLevel, writer.ToString());
            }
        }

		public static IComponentCfg CreateFromDbEntity(XmlSerializer s, Component cmpntEntity, IComponentFactory factory)
        {
            using (var reader = new StringReader(cmpntEntity.Parameters))
            {
				IComponentCfg config = s.Deserialize(reader) as IComponentCfg;
				if (config != null)
				{
					config.Name = cmpntEntity.Name;
					config.ParentName = cmpntEntity.ParentName;
					config.ItemNr = cmpntEntity.ItemNr;
					config.DebugLevel = cmpntEntity.Mode;
					config.LogLevel = cmpntEntity.Logging;
					config.Corrections = cmpntEntity.Corrections;
                    config.Uncertainties = cmpntEntity.Uncertainties;
                    config.Factory = factory;
				}
                return config;
            }
        }


		public void LoadTestParamsFromDB(Test test)
		{
			ITestParams tstPrms = (GetRuntimeTestParamsProvider() as ITestParams);
			if (tstPrms != null)
			{
				tstPrms.FromDbEntity(Name, test);
			}
		}


		public void LoadProcedureParamsFromDB(Procedure procedure)
		{
			IProcedureParams procPrms = (GetRuntimeProcParamsProvider() as IProcedureParams);
			if (procPrms != null)
			{
				procPrms.FromDbEntity(Name, procedure);
			}
		}


        /// <summary>
        /// If there are any procedure parameters, this function should be overriden
        /// by one returning a reference to a newly created object
        /// implementing IParamsProvider and IProcedureParams.
        /// 
        /// This default implementation returns null = no procedure parameters.
        /// </summary>
        /// <returns>Procedure parameters provider for this component or null</returns>
        public virtual IParamsProvider CreateProcParamsProvider()
        {
            return null;
        }

        /// <summary>
        /// If there are any procedure parameters, this function should be overriden
        /// by one returning a reference to an object
        /// implementing IParamsProvider and IProcedureParams used in runtime.
        /// 
        /// This default implementation returns null = no procedure parameters.
        /// </summary>
        /// <returns>Procedure parameters provider for this component or null</returns>
        public virtual IParamsProvider GetRuntimeProcParamsProvider()
        {
            return null;
        }

        public virtual IParamsProvider GetUIProcParamsProvider(Procedure procedure)
        {
            if (GetRuntimeProcParamsProvider() == null)
            {
                /// Component has no test parametes
                return null;
            }

            ComponentProcedure procParamsEntity = procedure.GetProcedureParamsEntity(Name);

            if (procParamsEntity != null)
            {
                if (procParamsEntity.GetParamsProvider() != null)
                {
                    /// Parameters provider for this entity already fetched - return it
                    return procParamsEntity.GetParamsProvider();
                }
                else
                {
                    /// Parameters provider for this entity will be created and updated from the entity later on
                    IParamsProvider paramsProvider = CreateProcParamsProvider();
                    (paramsProvider as IProcedureParams).UpdateFromDbEntity(procParamsEntity);
                    procParamsEntity.SetParamsProvider(paramsProvider);
                    return paramsProvider;
                }
            }
            else
            {
                IParamsProvider paramsProvider = CreateProcParamsProvider();
                (paramsProvider as IProcedureParams).FromDbEntity(Name, procedure);
                return paramsProvider;
            }
        }


        /// <summary>
        /// If there are any procedure parameters, this function should be overriden
        /// by one returning a reference to a newly created object
        /// implementing IParamsProvider and ITestParams.
        /// 
        /// This default implementation returns null = no test parameters.
        /// </summary>
        /// <returns>Procedure parameters provider for this component or null</returns>
        public virtual IParamsProvider CreateTestParamsProvider()
        {
            return null;
        }

        /// <summary>
        /// If there are any test parameters, this function should be overriden
        /// by one returning a reference to an object
        /// implementing IParamsProvider and ITestParams used in runtime.
        /// 
        /// This default implementation returns null = no test parameters.
        /// </summary>
        /// <returns>Test parameters provider for this component or null</returns>
        public virtual IParamsProvider GetRuntimeTestParamsProvider()
        {
            return null;
        }

        public virtual IParamsProvider GetUITestParamsProvider(Test test)
        {
            if (GetRuntimeTestParamsProvider() == null)
            {
                /// Component has no test parametes
                return null;
            }

            ComponentTest testParamsEntity = test.GetTestParamsEntity(Name);

            if (testParamsEntity != null)
            {
                if (testParamsEntity.GetParamsProvider() != null)
                {
                    /// Parameters provider for this entity already fetched - return it
                    return testParamsEntity.GetParamsProvider();
                }
                else
                {
                    /// Parameters provider for this entity will be created and updated from the entity later on
                    IParamsProvider paramsProvider = CreateTestParamsProvider();
                    (paramsProvider as ITestParams).UpdateFromDbEntity(testParamsEntity);
                    testParamsEntity.SetParamsProvider(paramsProvider);
                    return paramsProvider;
                }
            }
            else
            {
                IParamsProvider paramsProvider = CreateTestParamsProvider();
                (paramsProvider as ITestParams).FromDbEntity(Name, test);
                return paramsProvider;
            }
        }
	}
}