tbf/Results/BatchResults.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Results.Entities;

namespace Results
{
	public class BatchResults
	{
		public readonly int WMPositionsCount;

		public IList<Entities.TestData> TestDataList;
		public IList<Entities.Components> ComponentsList;
		public IList<Entities.WaterMeterData> WaterMeterDataList;

		private BatchResults(int wmPositionsCount)
		{
			WMPositionsCount = wmPositionsCount;

			TestDataList = new List<Entities.TestData>();
			ComponentsList = new List<Entities.Components>();
			WaterMeterDataList = new List<Entities.WaterMeterData>();
		}


		public Batch Batch;
		public WaterMeter[] WaterMeters;

		public static BatchResults NewFromProcedure(int batchNr, int benchId, string user, int userNr, string programVer,
													Config.Entities.Procedure procedure,
													WaterMeterData[] waterMeterDatas, int[] waterMeterParts, double densityCorr)
		{
			BatchResults d = new BatchResults(waterMeterDatas.Length);
            int year = DateTime.Now.Year;

			/// Create new batch
			d.Batch = new Batch()
				{
					TestBenchId = benchId,
					BatchNr = batchNr,
					ProgramVersion = programVer,
					UserName = user,
					UserNumber = userNr,
					ProcedureName = procedure.Name,
					ProcedureDescription = procedure.Description,
					WatermetersStr = procedure.Watermeters,
					ProcedureRevision = procedure.Revision,
					ProtocolTitle = procedure.ProtocolTitle,
					StartTime = DateTime.Now,
					DensityCorr = (float)densityCorr,
					Compound = (procedure.MetersKind == Config.Entities.MetersKind.Combined),
#if HEAT_METERS
                    HeatMeter = (procedure.MetersKind == Config.Entities.MetersKind.HeatMeter),
#endif
                };

			///
			/// Add watermeter to an array, array index is WM position.
			/// AddWaterMetersToBatch() has to be used before saving results.
			///
			d.WaterMeters = new WaterMeter[d.WMPositionsCount];
			for (int i = 0; i < d.WMPositionsCount; i++)
			{
				if (waterMeterDatas[i] == null) continue;
				WaterMeterData wmd = WaterMeterData.UpdateList(d.WaterMeterDataList, waterMeterDatas[i]);
                d.WaterMeters[i] = new WaterMeter()
                    {
                        Batch = d.Batch,
                        WaterMeterData = wmd,
                        WMPosition = i + 1,
                        YearOfProduction = year,
                    };
			}


			foreach (var t in procedure.Tests)
			{
				if (t.Publish != (byte)Config.Entities.Publish.Never)
				{
					TestData td = TestData.UpdateList(d.TestDataList, new TestData(t));

					for (int rnr = 1; rnr <= t.Repeats; rnr++)
					{
						/// Create an empty test result and add it to the list
						TestRslt tr = new TestRslt(d.Batch, td, t.Part, rnr);
						d.Batch.TestRslts.Add(tr);

						for (int i = 0; i < d.WMPositionsCount; i++)
						{
							if (d.WaterMeters[i] == null) continue;

							if (t.Part != 0 && waterMeterParts[i] != 0 && t.Part != waterMeterParts[i]) continue;

							///
							/// Create empty watermeter test results and add them to the list and to dictionaries
							///
							IList<MeterTestRslt> wmtrs = d.WaterMeters[i].MeterTestRslts;
							if (d.Batch.Compound)
							{
								/// Compound water meter
								wmtrs.Add(new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.CompoundMain));
								wmtrs.Add(new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.CompoundAux));
								wmtrs.Add(new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.Compound));
							}
							else if (d.Batch.HeatMeter)
							{
								/// Heat meter
								wmtrs.Add(new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.HeatMeterVolume));
								wmtrs.Add(new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.HeatMeterEnergy));
							}
							else
							{
								/// Water meter
								wmtrs.Add(new MeterTestRslt(d.WaterMeters[i], tr, Config.Entities.CompoundMeterId.Single));
							}
						}
					}
				}
			}

			return d;
		}

        public static BatchResults FromBatch(Batch batch)
        {
            int wmCount = batch.WaterMeters.Count;
            if (wmCount == 0) return null;

            BatchResults batchResults = new BatchResults(wmCount);
            batchResults.Batch = batch;
            batchResults.WaterMeters = new WaterMeter[wmCount];
            for (int i = 0; i < wmCount; i++) batchResults.WaterMeters[i] = batch.WaterMeters[i];

            return batchResults;
        }

        public TestRslt GetTestRslt(string name, int part)
		{
			return Batch.GetTestRslt(name, part);
		}

		public MeterTestRslt GetMeterTestRslt(string name, int wmnr0, Config.Entities.CompoundMeterId meterId)
		{
			if (WaterMeters[wmnr0] != null)
			{
				return WaterMeters[wmnr0].GetMeterTestRslt(name, meterId);
			}
			return null;
		}


		/// <summary>
		/// Returns true when all tests were done
		/// </summary>
		/// <returns>true = all tests done</returns>
		public bool AllTestsDone()
		{
			for (int i = 0; i < WMPositionsCount; i++)
			{
				if (WaterMeters[i] != null)
				{
					foreach (var mtr in WaterMeters[i].MeterTestRslts)
					{
						if (!mtr.TestDone) return false;
					}
				}
			}
			return true;
		}


		/// <summary>
		/// Adds non-null water meters from an array to a Batch water meters list.
		/// This method should be used when results are prepared and
		/// all disabled water meters are deleted.
		/// </summary>
		public void AddWaterMetersToBatch()
		{
			for (int i = 0; i < WMPositionsCount; i++)
			{
				if (WaterMeters[i] != null)
                {
                    WaterMeters[i].Passed = WaterMeters[i].PassedFromTests();
					if (!WaterMeters[i].Disabled)
					{
						Batch.WaterMeters.Add(WaterMeters[i]);
					}
                }
			}
		}
	}
}