tbf/Config/Entities/Procedure.cs

///
/// Copyright (c) 2013-2017 Sensus Metering Systems
///
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;

namespace Config.Entities
{
    /// <summary>
    /// Stores one test procedure, supports revisions and history log
    /// </summary>
	public class Procedure : IHasName, IHasItemNr
    {
        public virtual int Id { get; protected set; }
		public virtual int ItemNr { get; set; }
		public virtual string Name { get; set; }

        public virtual string Description { get; set; }			/// Short description
		public virtual string CreationUser { get; set; }		/// Name of the user who has created or changed this procedure
		public virtual DateTime CreationTime { get; set; }		/// Date and time of the creation or change
		public virtual string LastChgUser { get; set; }			/// Name of the user who has created or changed this procedure
		public virtual DateTime LastChgTime { get; set; }		/// Date and time of the creation or change
		public virtual string LongDescription { get; set; }		/// Long description (notes)

		public virtual ProcedureState ProcedureState { get; set; }
		public virtual int Revision { get; set; }
		public virtual int PredecessorId { get; set; }
		public virtual bool ObtainedByCopy { get; set; }		/// Initial version of this procedure was a copy of another procedure
        /// 
		public virtual MetersKind MetersKind { get; set; }		/// single / compound / heat meters
		public virtual string Watermeters { get; set; }			/// Water meter name or Id
        public virtual bool Protected { get; set; }             /// true = procedure cannot be changed by a testing specialist
		public virtual bool MustBeComplete { get; set; }        /// true = procedure can be finished just when all tests were finished
		public virtual bool ManualCtrlDisabled { get; set; }	/// true = manual control of valves, etc. is disabled

		public virtual string DataEntry { get; set; }			/// Component to use for data entry
		public virtual string ResultsPrinter { get; set; }		/// Component to use for printing the results
		public virtual string ResultsWriter { get; set; }		/// Component to use for saving the results into the file
		public virtual string TransitionStart { get; set; }
		public virtual string TransitionEnd { get; set; }

        public virtual string AltProcName { get; set; }		    /// Alternative procedure name (null or string.Empty = no alt. procedure)
        public virtual int AltProcPeriod { get; set; }			/// Period of alternative procedures (0 = no alt. procedure)

		public virtual IList<ComponentProcedure> MoreParams { get; set; }
		public virtual IList<Test> Tests { get; set; }

        /// ------------- Additional stuff not mapped into the database -------------

        public Procedure()
        {
			MoreParams = new List<ComponentProcedure>();
			Tests = new List<Test>();

			///
			/// Default values
			/// 
			CreationUser = (Users.GlobalData.CurrentUser != null) ? Users.GlobalData.CurrentUser.UserName : null;
			CreationTime = DateTime.Now;
			LastChgUser = CreationUser;
			LastChgTime = CreationTime;
			MetersKind = Entities.MetersKind.Single;
			Watermeters = string.Empty;
			Description = string.Empty;
			LongDescription = string.Empty;
        }

		public Procedure(string name, int itemNr)
			: this()
		{
			Name = name;
			ItemNr = itemNr;
		}

        public virtual Procedure Clone()
        {
            Procedure result = new Procedure();

			result.ItemNr = ItemNr;
			result.Name = Name;
			result.Description = Description;
			result.CreationUser = CreationUser;
			result.CreationTime = CreationTime;
			result.LastChgUser = LastChgUser;
			result.LastChgTime = LastChgTime;
			result.LongDescription = LongDescription;

			result.ProcedureState = ProcedureState;
			result.Revision = Revision;
			result.PredecessorId = Id;
			result.ObtainedByCopy = ObtainedByCopy;

			result.MetersKind = MetersKind;
			result.Watermeters = Watermeters;
            result.Protected = Protected;
            result.MustBeComplete = MustBeComplete;
			result.ManualCtrlDisabled = ManualCtrlDisabled;
			result.DataEntry = DataEntry;
			result.ResultsPrinter = ResultsPrinter;
			result.ResultsWriter = ResultsWriter;
			result.TransitionStart = TransitionStart;
			result.TransitionEnd = TransitionEnd;

			foreach (var prms in MoreParams) { result.MoreParams.Add(prms.Clone(result)); }
			foreach (var test in Tests) { result.Tests.Add(test.Clone()); }

            return result;
        }

        public virtual void Export(StreamWriter output)
        {
			output.WriteLine(ItemNr.ToString(CultureInfo.InvariantCulture));
            output.WriteLine(Name);
            output.WriteLine(Description);
            output.WriteLine(CreationUser);
			output.WriteLine(CreationTime.ToString(CultureInfo.InvariantCulture));
            output.WriteLine(LastChgUser);
			output.WriteLine(LastChgTime.ToString(CultureInfo.InvariantCulture));
			output.WriteLine(MetersKind.ToString());
            output.WriteLine(Watermeters);
            output.WriteLine(Protected.ToString());
            output.WriteLine(MustBeComplete.ToString());
			output.WriteLine(ManualCtrlDisabled.ToString());
            output.WriteLine(DataEntry);
            output.WriteLine(ResultsPrinter);
            output.WriteLine(ResultsWriter);
            output.WriteLine(TransitionStart); 
            output.WriteLine(TransitionEnd);

            foreach (var prms in MoreParams) { prms.Export(output); }
            output.WriteLine();

            foreach (var test in Tests) { test.Export(output); }
            output.WriteLine();

            output.Close();
        }

        public static Procedure Import(StreamReader input)
        {
            Procedure result = new Procedure();

			result.ItemNr = int.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
            result.Name = input.ReadLine();
            result.Description = input.ReadLine();
            result.CreationUser = input.ReadLine();
			result.CreationTime = DateTime.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
            result.LastChgUser = input.ReadLine();
			result.LastChgTime = DateTime.Parse(input.ReadLine(), CultureInfo.InvariantCulture);
            string line = input.ReadLine();
            result.MetersKind = line.Equals(MetersKind.Single.ToString()) ? MetersKind.Single : (line.Equals(MetersKind.Combined.ToString()) ? MetersKind.Combined : MetersKind.HeatMeter);
            result.Watermeters = input.ReadLine();
            result.Protected = bool.Parse(input.ReadLine());
            result.MustBeComplete = bool.Parse(input.ReadLine());
			result.ManualCtrlDisabled = bool.Parse(input.ReadLine());
            result.DataEntry = input.ReadLine();
            result.ResultsPrinter = input.ReadLine();
            result.ResultsWriter = input.ReadLine();
            result.TransitionStart = input.ReadLine();
            result.TransitionEnd = input.ReadLine();

            while(true)
            {
                ComponentProcedure prms = ComponentProcedure.Import(input, result);
                if (prms == null)
                    break;
                else
                    result.MoreParams.Add(prms);
            }

            while (true)
            {
                Test tst = Test.Import(input, result);
                if (tst == null)
                    break;
                else
                    result.Tests.Add(tst);
            }

            return result;
        }

        public virtual string Compare(StreamReader inp)
        {
            System.Text.StringBuilder diff = new System.Text.StringBuilder();
            const string fmt = "{0} = {1}\r\n (in the file {2})\r\n";
            string ln;

            ln = inp.ReadLine();            /// skip ItemNr
            ln = inp.ReadLine(); if (ln != Name)                          { diff.AppendFormat(fmt, "Name", Name, ln); };
            ln = inp.ReadLine(); if (ln != Description)                   { diff.AppendFormat(fmt, "Description", Description, ln); };
            ln = inp.ReadLine();            /// skip CreationUser
            ln = inp.ReadLine();            /// skip CreationTime
            ln = inp.ReadLine();            /// skip LastChgUser
            ln = inp.ReadLine();            /// skip LastChgTime
            ln = inp.ReadLine(); if (ln != MetersKind.ToString())         { diff.AppendFormat(fmt, "MetersKind", MetersKind, ln); };
            ln = inp.ReadLine(); if (ln != Watermeters)                   { diff.AppendFormat(fmt, "Watermeters", Watermeters, ln); };

            ln = inp.ReadLine(); if (ln != Protected.ToString())          { diff.AppendFormat(fmt, "Protected", Protected, ln); };
            ln = inp.ReadLine(); if (ln != MustBeComplete.ToString())     { diff.AppendFormat(fmt, "MustBeComplete", MustBeComplete, ln); };
            ln = inp.ReadLine(); if (ln != ManualCtrlDisabled.ToString()) { diff.AppendFormat(fmt, "ManualCtrlDisabled", ManualCtrlDisabled, ln); };
            ln = inp.ReadLine(); if (ln != DataEntry)                     { diff.AppendFormat(fmt, "DataEntry", DataEntry, ln); };
            ln = inp.ReadLine(); if (ln != ResultsPrinter)                { diff.AppendFormat(fmt, "ResultsPrinter", ResultsPrinter, ln); };
            ln = inp.ReadLine(); if (ln != ResultsWriter)                 { diff.AppendFormat(fmt, "ResultsWriter", ResultsWriter, ln); };
            ln = inp.ReadLine(); if (ln != TransitionStart)               { diff.AppendFormat(fmt, "TransitionStart", TransitionStart, ln); };
            ln = inp.ReadLine(); if (ln != TransitionEnd)                 { diff.AppendFormat(fmt, "TransitionEnd", TransitionEnd, ln); };

            /// TODO Compare componentprocedure-s
            while (ComponentProcedure.Import(inp, null) != null)
            {
            }


            //foreach (var test in Tests)
            //{
            //    string testDiff = test.Compare(inp);
            //    if (testDiff.Contains(
            //}

            //bool extraTestsInFile = true;
            //while (Test.Import(inp, null) != null) { extraTestsInFile = true; }

            return diff.ToString();
        }

        public virtual ComponentProcedure GetProcedureParamsEntity(string cmpntName)
        {
            foreach (var procPrms in MoreParams)
            {
                if (procPrms.CmpntName == cmpntName) return procPrms;
            }
            return null;
        }


        /// <summary>
        /// Processes the selection done by the bench control panel in the main sequence.
        /// </summary>
        /// <param name="selection">Selection.Q1, .Q2, .Q3 or .Test</param>
        /// <returns>The selected test or null</returns>
        public virtual Test GetTest(string expandedTestName, out int testIx, out int repetNr)
        {
            for (int ix = 0; ix < Tests.Count; ix++)
            {
                Test test = Tests[ix];
                if (test.Name.Equals(expandedTestName))
                {
                    /// Name is not expanded => Repeats==1
                    testIx = ix;
                    repetNr = 1;
                    return test;
                }

                for (int r = 1; r <= test.Repeats; r++)
                {
                    if (test.GetExpandedTestName(r).Equals(expandedTestName))
                    {
                        testIx = ix;
                        repetNr = r;
                        return test;
                    }
                }
            }

            testIx = 0;
            repetNr = 1;
            return null;
        }


		public override string ToString()
		{
			return string.Format("{0}, rev.{1}", Name, Revision);
		}
    }
}