tbf/TestBenchFramework/BenchControl/TestMethods/FlyingStartFirstRepetWithMassColl/HeatMeters/TestParams.cs

///
/// Copyright (c) 2018 Sensus Slovensko a.s.
///
using System;
using System.IO;
using System.Text;
using System.Xml.Serialization;
using Config.Entities;
using TBF.BenchControl.Generic;
using TBF.Resources;

namespace TBF.BenchControl.TestMethods.FlyingStartFirstRepetWithMassColl.HeatMeters
{
	public class TestParams : TestParamsBase, IParamsProvider, ITestParams
	{
		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(TestParams) })[0];
		protected override XmlSerializer GetSerializer() { return Serializer; }

		public float ErrorLimitLo;				/// [%]
		public float ErrorLimitHi;				/// [%]
		public bool EvaluateVolume;				/// true = evaluate also the volume, false = evaluate only energy
		public float TempWarmLo;				/// Low  limit for warm temperature [°C]
		public float TempWarmHi;				/// High limit for warm temperature [°C]
		public float TempColdLo;				/// Low  limit for cold temperature [°C]
		public float TempColdHi;				/// High limit for cold temperature [°C]
		public bool FlowMeasuredAtHiTempPipe;	/// true = flow measured at high temp. pipe, false = flow measured at low temp. pipe
		public float DeltaTempWarm;
		public float DeltaTempCold;
		public float ChangeInTimeWarm;
		public float ChangeInTimeCold;
		public string Prompt;

		public override void InitializeAll()
		{
			FlowMeasuredAtHiTempPipe = false;
		}
		

		string[] paramNames = new string[]
		{
			Strings.Err_limit_neg_pct_chdr,
			Strings.Err_limit_pos_pct_chdr,
			Strings.Evaluate_volume,
			"T hi min",
			"T hi max",
			"T lo min",
			"T lo max",
			"Flow measured at high temp.pipe",
			"Delta T warm",
			"Delta T cold",
			"Change in time T warm",
			"Change in time T cold",
			Strings.Prompt,
		};
		public override string ParamName(int i) { return paramNames[i]; }
		public override int ParamsCount() { return paramNames.Length; }

		public override string ToString(int i)
		{
			switch (i)
			{
				case 0: return ErrorLimitLo.ToString();
				case 1: return ErrorLimitHi.ToString();
				case 2: return (EvaluateVolume ? Strings.yes : Strings.no);
				case 3: return TempWarmLo.ToString();
				case 4: return TempWarmHi.ToString();
				case 5: return TempColdLo.ToString();
				case 6: return TempColdHi.ToString();
				case 7: return (FlowMeasuredAtHiTempPipe ? Strings.yes : Strings.no);
				case 8: return DeltaTempWarm.ToString();
				case 9: return DeltaTempCold.ToString();
				case 10: return ChangeInTimeWarm.ToString();
				case 11: return ChangeInTimeCold.ToString();
				case 12: return Prompt;
				default: return string.Empty;
			}
		}

		public void UpdateParam(int i, string strValue)
		{
			switch (i)
			{
				case 0: ErrorLimitLo = Utils.ParseSFloat(strValue); return;
				case 1: ErrorLimitHi = Utils.ParseSFloat(strValue); return;
				case 2: EvaluateVolume = strValue.Equals(Strings.yes); return;
				case 3: TempWarmLo = Utils.ParseSFloat(strValue); return;
				case 4: TempWarmHi = Utils.ParseSFloat(strValue); return;
				case 5: TempColdLo = Utils.ParseSFloat(strValue); return;
				case 6: TempColdHi = Utils.ParseSFloat(strValue); return;
				case 7: FlowMeasuredAtHiTempPipe = strValue.Equals(Strings.yes); return;
				case 8: DeltaTempWarm = Utils.ParseUFloat(strValue); return;
				case 9: DeltaTempCold = Utils.ParseUFloat(strValue); return;
				case 10: ChangeInTimeWarm = Utils.ParseUFloat(strValue); return;
				case 11: ChangeInTimeCold = Utils.ParseUFloat(strValue); return;
				case 12: Prompt = strValue; return;
				default: return;
			}
		}

		public bool ValidateParam(int i, string strValue, out string message)
		{
			message = string.Empty;
			float dummy;

			switch (i)
			{
				case 0:
				case 1:
				case 3:
				case 4:
				case 5:
				case 6:
					if (Utils.TryParseSFloat(strValue, out dummy)) return true;
					break;
				case 2:
				case 7:
					if (strValue.Equals(Strings.yes) || strValue.Equals(Strings.no)) return true;
                    break;
				case 8:
				case 9:
				case 10:
				case 11:
					if (Utils.TryParseUFloat(strValue, out dummy)) return true;
					break;
				case 12:
					return true;
				default:
					message = "Invalid index";
					return false;
			}

			message = ParamName(i) + " is invalid";
			return false;
		}

		void CopyContentTo(TestParams prms)
		{
			prms.ErrorLimitLo = ErrorLimitLo;
			prms.ErrorLimitHi = ErrorLimitHi;
			prms.EvaluateVolume = EvaluateVolume;
			prms.TempWarmLo = TempWarmLo;
			prms.TempWarmHi = TempWarmHi;
			prms.TempColdLo = TempColdLo;
			prms.TempColdHi = TempColdHi;
			prms.FlowMeasuredAtHiTempPipe = FlowMeasuredAtHiTempPipe;
			prms.DeltaTempWarm = DeltaTempWarm;
			prms.DeltaTempCold = DeltaTempCold;
			prms.ChangeInTimeWarm = ChangeInTimeWarm;
			prms.ChangeInTimeCold = ChangeInTimeCold;
			prms.Prompt = Prompt;
		}

		public IParamsProvider Clone()
		{
			TestParams pars = new TestParams();
			CopyContentTo(pars);
			return pars;
		}

		public override void UpdateTestParams(ComponentTest dbEntity)
		{
			if (dbEntity == null) return;
			try
			{
				TestParams tmp = Serializer.Deserialize(new StringReader(dbEntity.Parameters)) as TestParams;

				testParamsEntity = dbEntity;
				componentName = dbEntity.CmpntName;
				test = dbEntity.Test;

				if (tmp != null) tmp.CopyContentTo(this);
			}
			catch
			{
			}
		}

		/// <summary>
		/// Parameterless constructor initializes the parameters
		/// </summary>
		public TestParams()
		{
		}

		public TestParams(bool initialize)
		{
			if (initialize) InitializeAll();
		}

		public TestParams(ComponentTest testParamsEntity, string componentName, Test test)
		{
			this.testParamsEntity = testParamsEntity;
			this.componentName = componentName;
			this.test = test;
		}
	}
}