tbf/TBF/Rig/ComponentCfgBase.cs

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

namespace TBF.Rig
{
    public class ComponentCfgBase
    {
        [XmlIgnore] public int Id { get; set; }
        [XmlIgnore] public Generic.IComponentFactory Factory { get; set; }
        [XmlIgnore] public string ClassName { get { return Factory.ToString(); } }
        [XmlIgnore] public string Name { get; set; }
        [XmlIgnore] public string ParentName { get; set; }
        [XmlIgnore] public int ItemNr { get; set; }
        [XmlIgnore] public DebugMode DebugLevel { get; set; }
        [XmlIgnore] public LogLevel LogLevel { get; set; }
        [XmlIgnore] public IList<MeasurementCorrection> Corrections { get; set; }
        [XmlIgnore] public IList<Uncertainty> Uncertainties { get; set; }


        protected ComponentCfgBase()
        {
            ItemNr = 0;
            DebugLevel = DebugMode.Normal;
            LogLevel = LogLevel.Off;
        }

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

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

        protected ComponentCfgBase(Generic.IComponentFactory factory, string name, string parentName)
            : this(factory, name)
        {
            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.Id = cmpntEntity.Id;
                    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 procedure parameters
                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 parameters
                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;
            }
        }
	}
}