tbf/TBF/BenchControl/Output/DB/SensusOracle/ProcedureParams.cs

///
/// Copyright (c) 2020 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;
using System.Collections.Generic;

namespace TBF.BenchControl.Output.DB.SensusOracle
{
	public class ProcedureParams : ProcedureParamsBase, IParamsProvider, IProcedureParams
	{
		public static XmlSerializer Serializer = XmlSerializer.FromTypes(new[] { typeof(ProcedureParams) })[0];
		public override XmlSerializer GetSerializer() { return Serializer; }

        public DBUsed DBUsed;                       /// 0
        public WMKind WMKind;                       /// 1
        public int WMTypeId;                        /// 2
        public int YearOfManufacture;               /// 3
        public bool SaveResults;                    /// 4
        public bool ReadStartInfo;                  /// 5
        public bool StartInfoIsRequired;            /// 6

		public override void InitializeAll()
		{
            DBUsed = DBUsed.Production;             /// 0
            WMKind = WMKind.Iperl;                  /// 1
            WMTypeId = 2;                           /// 2
            YearOfManufacture = DateTime.Now.Year;  /// 3
#if TURA_SPECIAL
            SaveResults = false;                    /// 4
#else
            SaveResults = true;                     /// 4
#endif
            ReadStartInfo = true;                   /// 5
            StartInfoIsRequired = false;            /// 6
		}

		string[] paramNames = new string[]
		{
			"Database",                             /// 0
            "Kind of WMs",                          /// 1
            "WM type ID",                           /// 2
            "Year of manufacture",                  /// 3
            "Save results",                         /// 4
            "Read start info",                      /// 5
            "Start info is required",               /// 6
		};
		public override string ParamName(int i) { return paramNames[i]; }
		public override int ParamsCount() { return paramNames.Length; }

        public override IList<string> ParamValues(int i)
        {
            if (i == 0)
            {
                IList<string> retVal = new List<string>();
                for (DBUsed db = 0; db < DBUsed.Count; db++) retVal.Add(db.ToString());
                return retVal;
            }

            if (i == 1)
            {
                IList<string> retVal = new List<string>();
                for (WMKind wm = 0; wm < WMKind.Count; wm++) retVal.Add(wm.ToString());
                return retVal;
            }

            if (i == 3)
            {
                IList<string> retVal = new List<string>();
                int year = DateTime.Now.Year;
                retVal.Add(year.ToString());
                retVal.Add((year + 1).ToString());
                return retVal;
            }

            if (i == 4 || i == 5 || i == 6)
            {
                IList<string> retVal = new List<string>();
                retVal.Add(Strings.yes);
                retVal.Add(Strings.no);
                return retVal;
            }

            return null;
        }

		public override string ToString(int i)
		{
			switch (i)
			{
                case 0: return DBUsed.ToString();
                case 1: return WMKind.ToString();
                case 2: return WMTypeId.ToString();
                case 3: return YearOfManufacture.ToString();
                case 4: return SaveResults ? Strings.yes : Strings.no;
                case 5: return ReadStartInfo ? Strings.yes : Strings.no;
                case 6: return StartInfoIsRequired ? Strings.yes : Strings.no;
                default: return string.Empty;
			}
		}

		/// Retrieves parameters from UI controls
		public CfgUpdateFlags UpdateParam(int i, string strValue)
		{
			switch (i)
			{
                case 0:
                    for (DBUsed db = 0; db < DBUsed.Count; db++)
                    {
                        if (db.ToString() == strValue)
                        {
                            DBUsed = db;
                            return CfgUpdateFlags.None;
                        }
                    }
                    break;

                case 1:
                    for (WMKind wm = 0; wm < WMKind.Count; wm++)
                    {
                        if (wm.ToString() == strValue)
                        {
                            WMKind = wm;
                            return CfgUpdateFlags.None;
                        }
                    }
                    break;

                case 2: WMTypeId = int.Parse(strValue); break;
                case 3: YearOfManufacture = int.Parse(strValue); break;
                case 4: SaveResults = (strValue == Strings.yes); break;
                case 5: ReadStartInfo = (strValue == Strings.yes); break;
                case 6: StartInfoIsRequired = (strValue == Strings.yes); break;
			}

            return CfgUpdateFlags.None;
        }

		/// Verifies whether strings in UI controls represent valid parameters
		public bool ValidateParam(int i, string strValue, out string message)
		{
			message = string.Empty;

            int idummy;
			switch (i)
			{
				case 0:
                    for (DBUsed db = 0; db < DBUsed.Count; db++)
                    {
                        if (db.ToString() == strValue) return true;
                    }
					break;

                case 1:
                    for (WMKind wm = 0; wm < WMKind.Count; wm++)
                    {
                        if (wm.ToString() == strValue) return true;
                    }
                    break;

                case 2:
                    if (int.TryParse(strValue, out idummy) && idummy >= 0)
                        return true;
                    break;

                case 3:
                    if (int.TryParse(strValue, out idummy) && idummy >= DateTime.Now.Year && idummy <= DateTime.Now.Year + 1)
                        return true;
                    break;

                case 4:
                case 5:
                case 6:
                    if (strValue == Strings.yes || strValue == Strings.no)
                        return true;
                    break;

                default:
					message = "Invalid index";
					return false;
			}

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

		void CopyContentTo(ProcedureParams prms)
		{
			prms.DBUsed = this.DBUsed;
            prms.WMKind = this.WMKind;
            prms.WMTypeId = this.WMTypeId;
            prms.YearOfManufacture = this.YearOfManufacture;
            prms.SaveResults = this.SaveResults;
            prms.ReadStartInfo = this.ReadStartInfo;
            prms.StartInfoIsRequired = this.StartInfoIsRequired;
		}

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

		public override void UpdateFromDbEntity(ComponentProcedure dbEntity)
		{
			if (dbEntity == null) return;
			try
			{
				ProcedureParams tmp = Serializer.Deserialize(new StringReader(dbEntity.Parameters)) as ProcedureParams;

				procedureParamsEntity = dbEntity;
				componentName = dbEntity.CmpntName;
				procedure = dbEntity.Procedure;

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

		public ProcedureParams()
		{
		}

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

		public ProcedureParams(ComponentProcedure procedureParamsEntity, string componentName, Procedure procedure)
		{
			this.procedureParamsEntity = procedureParamsEntity;
			this.componentName = componentName;
			this.procedure = procedure;
		}
	}
}