tbf/TestBenchFramework/BenchControl/DB/SensusOracle/Database.cs

///
/// Copyright (c) 2015-2017 Sensus Metering Systems
///
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using log4net;
using Oracle.DataAccess.Client; // ODP.NET Oracle managed provider
using Oracle.DataAccess.Types;
using Config;
using Config.Entities;
using TBF.BenchControl;
using TBF.BenchControl.Sequences;
using TBF.Resources;

namespace TBF.BenchControl.DB.SensusOracle
{
	public enum Retv
	{
		OK,
		Error,
	}

	public class Database : ComponentBase, IOperation, GenericDevices.IResultsWriter, Generic.IDevice
	{
		private static readonly ILog log = LogManager.GetLogger(typeof(Database));
		public override string ToString() { return string.Format("Sensus-Oracle-Database({0})", Cfg.ToString(1)); }

        const int Anbid_StaraTura = 4;

		public static DatabaseCfg DBCfg;
		string separatorStr;

        /// <summary>
		/// Result items to print
		/// </summary>
		IList<Results.ItemSpec> rsltItems;

		/// <summary>
		/// Results to print
		/// </summary>
		Results.Entities.Batch batch;

		OracleConnection connection;    /// Oracle database connection
		StreamWriter writer;			/// Results to disk
		StreamWriter logger;			/// Logs specified by LU


        ///
        /// Information extracted from VT_PRUEFPUNKT_SOLL_SD for a given watermeter by query:
        ///    SELECT * FROM VT_PRUEFPUNKT_SOLL_SD WHERE ANBID=4 AND ID_WZTyp=x AND Rev_WZTyp=y
        ///
        class TestInfo
        {
            public int PruefungsNr;
            public string QBezeichnung;
            public TestInfo(int p, string q) { PruefungsNr = p; QBezeichnung = q; }
            public override string ToString() { return string.Format("({0},{1})", PruefungsNr, QBezeichnung); }
        }
        ///
        static int id_WZTyp;
        static int rev_WZTyp;
        static IList<TestInfo> testInfos = new List<TestInfo>();


		public Database() {}

		public Database(Generic.IComponentCfg cfg)
            : base(cfg)
		{
			DBCfg = cfg as DatabaseCfg;

			switch (DBCfg.Separator)
			{
				default:
				case Separator.None:		separatorStr = string.Empty;	break;
				case Separator.Space:		separatorStr = " ";				break;
				case Separator.Tabulator:	separatorStr = "\t";			break;
				case Separator.Comma:		separatorStr = ",";				break;
				case Separator.Semicolon:	separatorStr = ";";				break;
			}

			log.Debug(this.ToString());
		}

        public void Initialize()
        {
            switch (DBCfg.DBUsed)
            {
                case DBUsed.Production:
                    connection = new OracleConnection("Data Source=STARA01.WORLD;User Id=deltachef;Password=deltachef;");
                    break;
                case DBUsed.Quality:
                    connection = new OracleConnection("Data Source=STARA_TEST.WORLD;User Id=deltachef;Password=deltachef;");    /// TODO: Quality database specification
                    break;
                case DBUsed.Test:
                    connection = new OracleConnection("Data Source=STARA_TEST.WORLD;User Id=deltachef;Password=deltachef;");
                    break;
                default:
                    connection = null;
                    break;
            }

			if (DBCfg.DebugLevel == DebugMode.Simulate) return;

            ///
            /// Do something with the database to see if the connection works well
            ///
            if (connection != null)
            {
                connection.Open();

                string rslt = "none";
                OracleCommand cmd = new OracleCommand("select Standort from ANBIETER_SD where ANBID = 4", connection);
                OracleDataReader dr = cmd.ExecuteReader();
                if (dr.Read()) rslt = dr.GetString(0);
                dr.Close();

                connection.Close();
            }
        }

        public void RunDeviceBefore() {}
        public void RunDeviceAfter() {}

        public void StopDevice()
        {
            if (connection != null) connection.Dispose();
        }

		/// <summary>
		/// Eliminate spaces conditionally, depesing on bool WriterCfg.EliminateSpaces
		/// </summary>
		/// <param name="item">Input string</param>
		/// <returns>Output string</returns>
		string ElSpaces(string item)
		{
			if (DBCfg.EliminateSpaces)
				return item.Replace(" ", string.Empty);
			else
				return item;
		}


		/// <summary>
		/// Returns a file name derived from a DateTime structure.
		/// Creates directories on this path as a side effect.
		/// </summary>
		/// <param name="time">Date and time</param>
		/// <returns>File name</returns>
		string GetFileName(DateTime time)
		{
			string directory = DBCfg.DestinationPath;		/// Ends with "\\";
			Directory.CreateDirectory(directory);

			if (DBCfg.YearFolders)
			{
				directory = string.Format("{0}{1}\\", directory, time.Year.ToString());
				Directory.CreateDirectory(directory);
			}

			if (DBCfg.MonthFolders)
			{
				directory = string.Format("{0}{1}\\", directory, time.Month.ToString("D2"));
				Directory.CreateDirectory(directory);
			}

			if (DBCfg.DayFolders)
			{
				directory = string.Format("{0}{1}\\", directory, time.Day.ToString("D2"));
				Directory.CreateDirectory(directory);
			}

			return string.Format("{0}{1}{2}{3}-{4}{5}.txt", directory, (time.Year % 100).ToString("D2"),
				time.Month.ToString("D2"), time.Day.ToString("D2"), time.Hour.ToString("D2"), time.Minute.ToString("D2"));
		}


		/// <summary>
		/// Returns a file name derived from a DateTime structure.
		/// Creates directories on this path as a side effect.
		/// </summary>
		/// <param name="time">Date and time</param>
		/// <returns>File name</returns>
		string GetLogFileName(DateTime time)
		{
			string directory = DBCfg.LogFolderPath;		/// Ends with "\\";
			Directory.CreateDirectory(directory);

			if (DBCfg.YearFolders)
			{
				directory = string.Format("{0}{1}\\", directory, time.Year.ToString());
				Directory.CreateDirectory(directory);
			}

			if (DBCfg.MonthFolders)
			{
				directory = string.Format("{0}{1}\\", directory, time.Month.ToString("D2"));
				Directory.CreateDirectory(directory);
			}

			if (DBCfg.DayFolders)
			{
				directory = string.Format("{0}{1}\\", directory, time.Day.ToString("D2"));
				Directory.CreateDirectory(directory);
			}

			return string.Format("{0}{1}_{2}.log", directory, time.Hour.ToString("D2"), time.Minute.ToString("D2"));
		}

		/// <summary>
		/// Writes the test cycle results into a file,  Events:  Event.ResultsWritten
		/// </summary>
		/// <param name="procedure">Procedure to print the results of</param>
		/// <param name="unsortedResults">Results to write into the file</param>
		/// <returns>Reference to the operation</returns>
		public IOperation WriteResultsOp(Results.Entities.Batch batch)
		{
			this.batch = batch;

			string fname = GetLogFileName(batch.StartTime);

			try
			{
				logger = new StreamWriter(System.IO.File.Create(fname));
			}
			catch
			{
				logger = null;
				log.ErrorFormat("Was not able to open LU log file {0}", fname);
			}

			return this;
		}

		/// <summary>Start this operation</summary>
		public void Start()
		{
		}

		/// <summary>Run this operation</summary>
		/// <returns>Event.ResultsWritten or Event.Error</returns>
		public Event Run()
		{
			if (batch.WaterMeters.Count == 0) return Event.ResultsWritten;

			bool anyError = false;
#if ORACLE_DB
			if (DBCfg.DebugLevel != DebugMode.Simulate && connection != null)
			{
				if (WriteResultsToDatabase(connection, batch, false) == Retv.Error) anyError = true;
			}
#endif

			WriteLogsToDisk(logger, batch);
            
            if (anyError)
			{
				return Event.ResultsNotWritten;
			}
			else
			{
				return Event.ResultsWritten;
			}
		}

		/// <summary>Stop this operation</summary>
		public void Stop()
		{
		}


		public static Retv WriteLogsToDisk(StreamWriter logger, Results.Entities.Batch batch)
        {
#if TURA_IPERL || TURA_SPECIAL
			if (logger == null) return Retv.Error;

			Results.Entities.WaterMeter wm0 = null;
			foreach (var wm in batch.WaterMeters) if (wm != null) { wm0 = wm; break; }
			if (wm0 == null) return Retv.Error;

			Results.Entities.WaterMeterData wmData = wm0.WaterMeterData;

			Results.Entities.MeterTestRslt adj = wm0.GetMeterTestRslt(string.Format("Adjustment"));
			Results.Entities.MeterTestRslt q1  = wm0.GetMeterTestRslt(string.Format("Q1"));
			Results.Entities.MeterTestRslt q2  = wm0.GetMeterTestRslt(string.Format("Q2"));
			Results.Entities.MeterTestRslt q3  = wm0.GetMeterTestRslt(string.Format("Q3"));
			if (adj == null || q1 == null || q2 == null || q3 == null) return Retv.Error;

			try
			{
				logger.WriteLine("[Wasserzähler-Daten]");
				logger.WriteLine(string.Format("PruefPunkte={0}", 3));
				logger.WriteLine(string.Format("Typ={0}", batch.ProcedureName));	/// iP 020 Q3_4 R160 A XXXX       
				logger.WriteLine(string.Format("MetroKlasse={0}", wmData.MetrologicalClass));
				logger.WriteLine(string.Format("Zulassungszeichen={0}", wmData.ApprovalInfo));
                logger.WriteLine(string.Format("Qn={0}", wmData.Q3_Qn.ToString("F1", Program.AltCulture)));
				logger.WriteLine(string.Format("Impulsrate={0}", q3.PulsesPerLiter.ToString(Program.AltCulture)));	/// 50,000
				logger.WriteLine(string.Format("WZid={0}", wmData.WMTypeId));
				logger.WriteLine(string.Format("RevWzTyp={0}", wmData.WMTypeRev));
				logger.WriteLine(string.Format("RevPruefstandWzTyp=2"));			/// 2

				logger.WriteLine(string.Format("Durchfluss-5=0,0"));				/// 0,0
				logger.WriteLine(string.Format("Prüfzeit-5=0"));					/// 0
				logger.WriteLine(string.Format("Prüfbereich100_110-5=0"));			/// 0
				logger.WriteLine(string.Format("PrüfbereichMin-5=0"));				/// 0
				logger.WriteLine(string.Format("PrüfbereichMax-5=0"));				/// 0
				logger.WriteLine(string.Format("QBezeichnung-5="));					///

				logger.WriteLine(string.Format("Durchfluss-4=0,0"));				/// 0,0
				logger.WriteLine(string.Format("Prüfzeit-4=0"));					/// 0
				logger.WriteLine(string.Format("Prüfbereich100_110-4=0"));			/// 0
				logger.WriteLine(string.Format("PrüfbereichMin-4=0"));				/// 0
				logger.WriteLine(string.Format("PrüfbereichMax-4=0"));				/// 0
				logger.WriteLine(string.Format("QBezeichnung-4="));					///

				logger.WriteLine(string.Format("Durchfluss-3=0,0"));				/// 0,0
				logger.WriteLine(string.Format("Prüfzeit-3=0"));					/// 0
				logger.WriteLine(string.Format("Prüfbereich100_110-3=0"));			/// 0
				logger.WriteLine(string.Format("PrüfbereichMin-3=0"));				/// 0
				logger.WriteLine(string.Format("PrüfbereichMax-3=0"));				/// 0
				logger.WriteLine(string.Format("QBezeichnung-3="));					///

				logger.WriteLine(string.Format("Durchfluss-2=0,0"));				/// 0,0
				logger.WriteLine(string.Format("Prüfzeit-2=0"));					/// 0
				logger.WriteLine(string.Format("Prüfbereich100_110-2=0"));			/// 0
				logger.WriteLine(string.Format("PrüfbereichMin-2=0"));				/// 0
				logger.WriteLine(string.Format("PrüfbereichMax-2=0"));				/// 0
				logger.WriteLine(string.Format("QBezeichnung-2="));					///

                logger.WriteLine(string.Format("Durchfluss-1={0}", Units.ConvertTo(Unit.lph, adj.Qto()).ToString("F1", Program.AltCulture)));
				logger.WriteLine(string.Format("Prüfzeit-1={0}", adj.TargetTime().ToString("F0")));
				logger.WriteLine(string.Format("Prüfbereich100_110-1={0}", 0));
				logger.WriteLine(string.Format("PrüfbereichMin-1={0}", 90));
				logger.WriteLine(string.Format("PrüfbereichMax-1={0}", 100));
				logger.WriteLine(string.Format("QBezeichnung-1=Just"));

				logger.WriteLine(string.Format("Durchfluss-0=0,0"));
				logger.WriteLine(string.Format("Prüfzeit-0=0"));
				logger.WriteLine(string.Format("Prüfbereich100_110-0=0"));
				logger.WriteLine(string.Format("PrüfbereichMin-0=0"));
				logger.WriteLine(string.Format("PrüfbereichMax-0=0"));
				logger.WriteLine(string.Format("QBezeichnung-0="));

                logger.WriteLine(string.Format("Durchfluss1={0}", Units.ConvertTo(Unit.lph, q1.Qfrom()).ToString("F1", Program.AltCulture)));
				logger.WriteLine(string.Format("Prüfzeit1={0}", q1.TargetTime().ToString("F0")));
				logger.WriteLine(string.Format("Prüfbereich100_1101={0}", 1));
				logger.WriteLine(string.Format("PrüfbereichMin1={0}", 100));
				logger.WriteLine(string.Format("PrüfbereichMax1={0}", 110));
				logger.WriteLine(string.Format("QBezeichnung1=Q1"));
				logger.WriteLine(string.Format("PosFehlergrenze1={0}", q1.ErrLimHi().ToString("F1", Program.AltCulture)));
				logger.WriteLine(string.Format("NegFehlergrenze1={0}", q1.ErrLimLo().ToString("F1", Program.AltCulture)));
				logger.WriteLine(string.Format("PosFehlergrenzeWarm1=0,0"));
				logger.WriteLine(string.Format("NegFehlergrenzeWarm1=0,0"));

                logger.WriteLine(string.Format("Durchfluss2={0}", Units.ConvertTo(Unit.lph, q2.Qfrom()).ToString("F1", Program.AltCulture)));
				logger.WriteLine(string.Format("Prüfzeit2={0}", q2.TargetTime().ToString("F0")));
				logger.WriteLine(string.Format("Prüfbereich100_1102={0}", 1));
				logger.WriteLine(string.Format("PrüfbereichMin2={0}", 100));
				logger.WriteLine(string.Format("PrüfbereichMax2={0}", 110));
				logger.WriteLine(string.Format("QBezeichnung2=Q2"));
				logger.WriteLine(string.Format("PosFehlergrenze2={0}", q2.ErrLimHi().ToString("F1", Program.AltCulture)));
				logger.WriteLine(string.Format("NegFehlergrenze2={0}", q2.ErrLimLo().ToString("F1", Program.AltCulture)));
				logger.WriteLine(string.Format("PosFehlergrenzeWarm2=0,0"));
				logger.WriteLine(string.Format("NegFehlergrenzeWarm2=0,0"));

                logger.WriteLine(string.Format("Durchfluss3={0}", Units.ConvertTo(Unit.lph, q3.Qto()).ToString("F1", Program.AltCulture)));
				logger.WriteLine(string.Format("Prüfzeit3={0}", q3.TargetTime().ToString("F0")));
				logger.WriteLine(string.Format("Prüfbereich100_1103={0}", 0));
				logger.WriteLine(string.Format("PrüfbereichMin3={0}", 90));
				logger.WriteLine(string.Format("PrüfbereichMax3={0}", 100));
				logger.WriteLine(string.Format("QBezeichnung3=Q3"));
				logger.WriteLine(string.Format("PosFehlergrenze3={0}", q3.ErrLimHi().ToString("F1", Program.AltCulture)));
				logger.WriteLine(string.Format("NegFehlergrenze3={0}", q3.ErrLimLo().ToString("F1", Program.AltCulture)));
				logger.WriteLine(string.Format("PosFehlergrenzeWarm3=0,0"));
				logger.WriteLine(string.Format("NegFehlergrenzeWarm3=0,0"));

				logger.WriteLine(string.Format("Durchfluss4=0,0"));
				logger.WriteLine(string.Format("Prüfzeit4=0"));
				logger.WriteLine(string.Format("Prüfbereich100_1104=0"));
				logger.WriteLine(string.Format("PrüfbereichMin4=0"));
				logger.WriteLine(string.Format("PrüfbereichMax4=0"));
				logger.WriteLine(string.Format("QBezeichnung4="));
				logger.WriteLine(string.Format("PosFehlergrenze4=0,0"));
				logger.WriteLine(string.Format("NegFehlergrenze4=0,0"));
				logger.WriteLine(string.Format("PosFehlergrenzeWarm4=0,0"));
				logger.WriteLine(string.Format("NegFehlergrenzeWarm4=0,0"));

				logger.WriteLine(string.Format("Durchfluss5=0,0"));
				logger.WriteLine(string.Format("Prüfzeit5=0"));
				logger.WriteLine(string.Format("Prüfbereich100_1105=0"));
				logger.WriteLine(string.Format("PrüfbereichMin5=0"));
				logger.WriteLine(string.Format("PrüfbereichMax5=0"));
				logger.WriteLine(string.Format("QBezeichnung5="));
				logger.WriteLine(string.Format("PosFehlergrenze5=0,0"));
				logger.WriteLine(string.Format("NegFehlergrenze5=0,0"));
				logger.WriteLine(string.Format("PosFehlergrenzeWarm5=0,0"));
				logger.WriteLine(string.Format("NegFehlergrenzeWarm5=0,0"));

				logger.WriteLine(string.Format("GetriebeImpulse=2,000"));			/// 2,000
				logger.WriteLine(string.Format("OptikAufsetzen=0"));				/// 0
				logger.WriteLine(string.Format("Warm_Kalt=0"));						/// 0
				logger.WriteLine(string.Format("Füllzeit=0"));						/// 0
				logger.WriteLine(string.Format("EvakVorneZeit=0"));					/// 0
				logger.WriteLine(string.Format("EvakHintenZeit={0}", 0));			/// 90
				logger.WriteLine(string.Format("Spüllzeit={0}", 0));				/// 60
				logger.WriteLine(string.Format("Spüldurchfluss={0}", 0));			/// 5000,0
				logger.WriteLine(string.Format("Abpresszeit={0}", 0));				/// 60
				logger.WriteLine(string.Format("Abpressdruck={0}", 0));				/// 0,0
				logger.WriteLine(string.Format("Entwässerzeit={0}", 0));			/// 10
				logger.WriteLine(string.Format("DinA4_Format={0}", 0));				/// 0
				logger.WriteLine(string.Format("Netzwerk_Format={0}", 0));			/// 0
				logger.WriteLine(string.Format("Zählernr_Format={0}", 0));			/// 1
				logger.WriteLine(string.Format("WZ_Gruppe=24"));					/// 24 - iPerl
				logger.WriteLine(string.Format("MittelwertTiefe={0}", 0));			/// 1
				logger.WriteLine(string.Format("EndKriterium={0}", 0));				/// 0
				logger.WriteLine(string.Format("Justieren={0}", 1));				/// 1
				logger.WriteLine(string.Format("Bemerkung="));						///                     
                logger.WriteLine(string.Format("Gesamtprüfzeit={0}", (adj.TargetTime() + q1.TargetTime() + q2.TargetTime() + q3.TargetTime()).ToString("F0")));
				logger.WriteLine(string.Format("Gegenprüfung={0}", 0));				/// 0
				logger.WriteLine(string.Format("Geändert_von={0}", 6));				/// 4459
				logger.WriteLine(string.Format("Geändert_am={0:dd.MM.yyyy HH:mm:ss}", DateTime.Now));	/// 29.05.2015 13:46:17

				for (int i = 0; i < batch.WaterMeters.Count; i++)
				{
					Results.Entities.WaterMeter wMtr = batch.WaterMeters[i];

					adj = wMtr.GetMeterTestRslt(string.Format("Adjustment"));
					q1 = wMtr.GetMeterTestRslt(string.Format("Q1"));
					q2 = wMtr.GetMeterTestRslt(string.Format("Q2"));
					q3 = wMtr.GetMeterTestRslt(string.Format("Q3"));

					logger.WriteLine(string.Empty);
					logger.WriteLine(string.Format("[Zählerdaten_{0}]", i + 1));

					if (wMtr == null || adj == null || q1 == null || q2 == null || q3 == null)
					{
						logger.WriteLine("geprüft=0");
					}
					else
					{
						logger.WriteLine("geprüft=1");
						logger.WriteLine(string.Format("Zählernummer="));
						logger.WriteLine(string.Format("FertigsNr={0}", wMtr.SerialNr));
						logger.WriteLine(string.Format("bestanden={0}", wMtr.Passed ? 1 : 0));						/// 1
						logger.WriteLine(string.Format("Prüfflag={0}", wMtr.HydrPruefung));	/// 96
						logger.WriteLine(string.Format("FestWertWZ=0"));					/// 0
						logger.WriteLine(string.Format("Dicht={0}", 1));					/// 1
						logger.WriteLine(string.Format("PrüfIndex={0}", wMtr.Pruefindex));	/// 7301
						logger.WriteLine(string.Format("GeprüftIndex=1"));					/// 1

						logger.WriteLine(string.Format("Q-1bestanden=1"));
						logger.WriteLine(string.Format("Durchfluss-1={0}", Utils.DoubleToStr(Units.ConvertTo(Unit.lph, adj.FlowVolume()), 5, true)));
						logger.WriteLine(string.Format("Fehler-1={0}", adj.Error.ToString(Program.AltCulture)));
						logger.WriteLine(string.Format("ZeitImpulse-1={0}", adj.TestTime.ToString(Program.AltCulture)));
						logger.WriteLine(string.Format("Impulse-1=0"));
						logger.WriteLine(string.Format("Volumen-1={0}", adj.VolumeMeter.ToString(Program.AltCulture)));
                        logger.WriteLine(string.Format("KorrFehler-1={0}", adj.Error.ToString(Program.AltCulture)));
						logger.WriteLine(string.Format("KorrDurchfluss-1={0}", 0));
						logger.WriteLine(string.Format("Q-1KorrBestanden={0}", 0));
						logger.WriteLine(string.Format("Anfangsstand-1={0}", 0));		/// TODO
						logger.WriteLine(string.Format("Endstand-1={0}", 0));			/// TODO
                        logger.WriteLine(string.Format("QMittelwert-1={0}", Utils.DoubleToStr(Units.ConvertTo(Unit.lph, adj.FlowVolume()), 5, true)));
						logger.WriteLine(string.Format("QStandardAbweichung-1={0}", 0));
						logger.WriteLine(string.Format("ImpedanzMittelwert-1=0,00000"));
						logger.WriteLine(string.Format("AusfallGrund-1={0}", 0));

						logger.WriteLine(string.Format("Q1bestanden={0}", q1.Passed ? 1 : 0));
                        logger.WriteLine(string.Format("Durchfluss1={0}", Utils.DoubleToStr(Units.ConvertTo(Unit.lph, q1.FlowVolume()), 5, true)));
						logger.WriteLine(string.Format("Fehler1={0}", q1.Error.ToString(Program.AltCulture)));
						logger.WriteLine(string.Format("ZeitImpulse1={0}", q1.TestTime.ToString(Program.AltCulture)));
						logger.WriteLine(string.Format("Impulse1={0}", 0));
						logger.WriteLine(string.Format("Volumen1={0}", q1.VolumeMeter.ToString(Program.AltCulture)));
                        logger.WriteLine(string.Format("KorrFehler1={0}", q1.Error.ToString(Program.AltCulture)));
						logger.WriteLine(string.Format("KorrDurchfluss1={0}", 0));
						logger.WriteLine(string.Format("Q1KorrBestanden={0}", 0));
						logger.WriteLine(string.Format("Anfangsstand1={0}", 0));		/// TODO
						logger.WriteLine(string.Format("Endstand1={0}", 0));			/// TODO
                        logger.WriteLine(string.Format("QMittelwert1={0}", Utils.DoubleToStr(Units.ConvertTo(Unit.lph, q1.FlowVolume()), 5, true)));
						logger.WriteLine(string.Format("QStandardAbweichung1={0}", 0));
						logger.WriteLine(string.Format("ImpedanzMittelwert1=0,00000"));
						logger.WriteLine(string.Format("AusfallGrund1={0}", 0));

						logger.WriteLine(string.Format("Q2bestanden={0}", q2.Passed ? 1 : 0));
                        logger.WriteLine(string.Format("Durchfluss2={0}", Utils.DoubleToStr(Units.ConvertTo(Unit.lph, q2.FlowVolume()), 5, true)));
						logger.WriteLine(string.Format("Fehler2={0}", q2.Error.ToString(Program.AltCulture)));
						logger.WriteLine(string.Format("ZeitImpulse2={0}", q2.TestTime.ToString(Program.AltCulture)));
						logger.WriteLine(string.Format("Impulse2={0}", 0));
						logger.WriteLine(string.Format("Volumen2={0}", q2.VolumeMeter.ToString(Program.AltCulture)));
                        logger.WriteLine(string.Format("KorrFehler2={0}", q2.WaterMeter.Q2CorrectionDone ? q2.WaterMeter.Q2ErrWOCorrection.ToString(Program.AltCulture)
                                                                                                         : q2.Error.ToString(Program.AltCulture)));
						logger.WriteLine(string.Format("KorrDurchfluss2={0}", 0));
						logger.WriteLine(string.Format("Q2KorrBestanden={0}", 0));
						logger.WriteLine(string.Format("Anfangsstand2={0}", 0));		/// TODO
						logger.WriteLine(string.Format("Endstand2={0}", 0));			/// TODO
                        logger.WriteLine(string.Format("QMittelwert2={0}", Utils.DoubleToStr(Units.ConvertTo(Unit.lph, q2.FlowVolume()), 5, true)));
						logger.WriteLine(string.Format("QStandardAbweichung2={0}", 0));
						logger.WriteLine(string.Format("ImpedanzMittelwert2=0,00000"));
						logger.WriteLine(string.Format("AusfallGrund2={0}", 0));

						logger.WriteLine(string.Format("Q3bestanden={0}", q3.Passed ? 1 : 0));
                        logger.WriteLine(string.Format("Durchfluss3={0}", Utils.DoubleToStr(Units.ConvertTo(Unit.lph, q3.FlowVolume()), 5, true)));
						logger.WriteLine(string.Format("Fehler3={0}", q3.Error.ToString(Program.AltCulture)));
						logger.WriteLine(string.Format("ZeitImpulse3={0}", q3.TestTime.ToString(Program.AltCulture)));
						logger.WriteLine(string.Format("Impulse3={0}", 0));
						logger.WriteLine(string.Format("Volumen3={0}", q3.VolumeMeter.ToString(Program.AltCulture)));
                        logger.WriteLine(string.Format("KorrFehler3={0}", q3.Error.ToString(Program.AltCulture)));
						logger.WriteLine(string.Format("KorrDurchfluss3={0}", 0));
						logger.WriteLine(string.Format("Q3KorrBestanden={0}", 0));
						logger.WriteLine(string.Format("Anfangsstand3={0}", 0));		/// TODO
						logger.WriteLine(string.Format("Endstand3={0}", 0));			/// TODO
                        logger.WriteLine(string.Format("QMittelwert3={0}", Utils.DoubleToStr(Units.ConvertTo(Unit.lph, q3.FlowVolume()), 5, true)));
						logger.WriteLine(string.Format("QStandardAbweichung3={0}", 0));
						logger.WriteLine(string.Format("ImpedanzMittelwert3=0,00000"));
						logger.WriteLine(string.Format("AusfallGrund3={0}", 0));

						logger.WriteLine(string.Format("AusfallGrundGesamt={0}", 0));
						logger.WriteLine(string.Format("AuftragNum={0}", wMtr.PurchaseOrder));
						logger.WriteLine(string.Format("MaterialNum={0}", 38140500));
						logger.WriteLine(string.Format("Prefix={0}", "8SEN01"));
						logger.WriteLine(string.Format("Suffix="));
						logger.WriteLine(string.Format("Palette={0}", 0));
						logger.WriteLine(string.Format("Umkarton={0}", 0));
						logger.WriteLine(string.Format("ZNr_komplett="));
						logger.WriteLine(string.Format("OptikBewertung=0,00000"));
						logger.WriteLine(string.Format("IdProduziert={0}", 0));				/// 61
						logger.WriteLine(string.Format("Calibration_alt={0}", wMtr.OrigCalibFactor));
						logger.WriteLine(string.Format("Calibration={0}", wMtr.CalibFactor));
						logger.WriteLine(string.Format("Firmware={0}", "05.66"));			/// 05.66
						logger.WriteLine(string.Format("FlexFlowFehler={0}", 0));			/// 0
						logger.WriteLine(string.Format("FlexFlowAuftrag={0}", 0));			/// 4248189
						logger.WriteLine(string.Format("JustierWert=0,2"));					/// 0,2
						logger.WriteLine(string.Format("Corrected2Hz={0}", wMtr.Hz2CorrectionDone ? 1 : 0));
						logger.WriteLine(string.Format("Q2Corrected={0}", wMtr.Q2CorrectionDone ? 1 : 0));
						logger.WriteLine(string.Format("Q2CorrectionRight={0}", wMtr.Q2CorrRFlow));
						logger.WriteLine(string.Format("Q2CorrectionLeft={0}", wMtr.Q2CorrLFlow));
						logger.WriteLine(string.Format("Q2CorrectionFlowRight={0}", wMtr.Q2CorrFlowRight));
						logger.WriteLine(string.Format("FlowDirectionRight={0}", wMtr.Q2CorrFlowRight));
						logger.WriteLine(string.Format("Position={0}", wMtr.WMPosition));
					}
				}


				logger.WriteLine(string.Empty);
				logger.WriteLine("[Prüfdaten]");
                ///
				logger.WriteLine(string.Format("Startzeit={0}", batch.StartTime.ToString("HH:mm:ss")));
				logger.WriteLine(string.Format("Endezeit={0}", batch.EndTime.ToString("HH:mm:ss")));
				logger.WriteLine(string.Format("Datum={0}", batch.StartTime.ToString("dd.MM.yyyy")));
				logger.WriteLine(string.Format("GesamtDauer={0}", batch.EndTime.Subtract(batch.StartTime).TotalSeconds));
				logger.WriteLine(string.Format("Dichtprüfung={0}", 0));							/// 1
                                                                                                /// 
				logger.WriteLine(string.Format("Q-5_geprüft={0}", 0));							/// 0
                                                                                                /// 
				logger.WriteLine(string.Format("Q-4_geprüft={0}", 0));							/// 0
                                                                                                /// 
				logger.WriteLine(string.Format("Q-3_geprüft={0}", 0));							/// 0
                                                                                                /// 
				logger.WriteLine(string.Format("Q-2_geprüft={0}", 0));							/// 0
                                                                                                /// 
				logger.WriteLine(string.Format("Q-1_geprüft={0}", 1));							/// 1
				logger.WriteLine(string.Format("Prüfvolumen-1={0}", 0));						/// 0,00000
				logger.WriteLine(string.Format("Prüfmasse-1={0}", 0));							/// 0,00000
				logger.WriteLine(string.Format("Temp1_P-1={0}", 0));							/// 19,8
				logger.WriteLine(string.Format("Temp2_P-1={0}", 0));							/// 19,8
				logger.WriteLine(string.Format("Temp3_P-1={0}", 0));							/// 19,8
				logger.WriteLine(string.Format("Temp4_P-1={0}", 0));							/// 19,8
				logger.WriteLine(string.Format("Temp5_P-1={0}", 0));							/// 19,8
				logger.WriteLine(string.Format("Temp6_P-1={0}", 0));							/// 19,8
				logger.WriteLine(string.Format("Temp7_P-1={0}", 0));							/// 0,0
				logger.WriteLine(string.Format("Temp8_P-1={0}", 0));							/// 0,0
                logger.WriteLine(string.Format("Druck1_P-1={0}", adj.TestRslt.PressUpMean.ToString(Program.AltCulture)));
                logger.WriteLine(string.Format("Druck2_P-1={0}", adj.TestRslt.PressDownMean.ToString(Program.AltCulture)));
				logger.WriteLine(string.Format("K-Faktor-1={0}", 0));							/// 0,00000000
				logger.WriteLine(string.Format("Q_Waage-1={0}", 0));							/// 3880,87469
				logger.WriteLine(string.Format("Q_Vergleich-1={0}", 0));						/// 3869,47056
				logger.WriteLine(string.Format("Fehler_Vergleich-1={0}", 0));					/// -0,29472
				logger.WriteLine(string.Format("VZ_ZeitImpulse-1={0}", 0));						/// 500,14362
				logger.WriteLine(string.Format("VZ_Impulse-1={0}", 0));							/// 645097
				logger.WriteLine(string.Format("ZeitImpulse_VZ-1={0}", 0));						/// 976843
				logger.WriteLine(string.Format("VorwahlZähler-1={0}", 0));						/// 0,00000
				logger.WriteLine(string.Format("VZ_Nummer-1={0}", 0));							/// 1
				logger.WriteLine(string.Format("Anfangsgewicht-1={0}", 0));						/// 0,00000
				logger.WriteLine(string.Format("Endgewicht-1={0}", 0));							/// 0,00000
				logger.WriteLine(string.Format("MinDurchfluss-1={0}", 0));						/// 3862,00000
				logger.WriteLine(string.Format("MaxDurchfluss-1={0}", 0));						/// 3876,00000
				logger.WriteLine(string.Format("Q_Einstellzeit-1={0}", 0));						/// 7,28
				logger.WriteLine(string.Format("Pumpennummer-1={0}", 0));						/// 2
				logger.WriteLine(string.Format("Drehzahl-1={0}", 0));							/// 2269
				logger.WriteLine(string.Format("DAW_Wert-1={0}", 0));							/// 1501
				logger.WriteLine(string.Format("Leitfähigkeit-1={0}", 0));						/// 545,05
				logger.WriteLine(string.Format("LuftDruck-1={0}", 0));							/// 0,0
				logger.WriteLine(string.Format("LuftFeuchtigkeit-1={0}", 0));					/// 0,0
				logger.WriteLine(string.Format("HyDruck-1={0}", 0));							/// 6,2
				logger.WriteLine(string.Format("VorratsDruckHy-1={0}", 0));						/// 6,3
				logger.WriteLine(string.Format("Anfangsgewicht2_-1={0}", 0));					/// 0,00000
				logger.WriteLine(string.Format("Endgewicht2_-1={0}", 0));						/// 0,00000
				logger.WriteLine(string.Format("Prüfmasse2_-1={0}", 0));						/// 0,00000
				logger.WriteLine(string.Format("GegenWaage-1={0}", 0));							/// 0
                                                                                                /// 
				logger.WriteLine(string.Format("Q0_geprüft={0}", 0));							/// 0
                                                                                                /// 
				logger.WriteLine(string.Format("Q1_geprüft={0}", 1));							/// 1
				logger.WriteLine(string.Format("Prüfvolumen1={0}", 0));							/// 3,73655
				logger.WriteLine(string.Format("Prüfmasse1={0}", 0));							/// 3,72610
				logger.WriteLine(string.Format("Temp1_P1={0}", 0));							    /// 20,0
				logger.WriteLine(string.Format("Temp2_P1={0}", 0));							    /// 20,0
				logger.WriteLine(string.Format("Temp3_P1={0}", 0));							    /// 20,0
				logger.WriteLine(string.Format("Temp4_P1={0}", 0));	    						/// 20,0
				logger.WriteLine(string.Format("Temp5_P1={0}", 0));		    					/// 20,0
				logger.WriteLine(string.Format("Temp6_P1={0}", 0));			    				/// 20,0
				logger.WriteLine(string.Format("Temp7_P1={0}", 0));				    			/// 0,0
				logger.WriteLine(string.Format("Temp8_P1={0}", 0));					    		/// 0,0
				logger.WriteLine(string.Format("Druck1_P1={0}", q1.TestRslt.PressUpMean.ToString(Program.AltCulture)));
                logger.WriteLine(string.Format("Druck2_P1={0}", q1.TestRslt.PressDownMean.ToString(Program.AltCulture)));
				logger.WriteLine(string.Format("K-Faktor1={0}", 0));							/// 0,99820080
				logger.WriteLine(string.Format("Q_Waage1={0}", 0));						    	/// 26,89887
				logger.WriteLine(string.Format("Q_Vergleich1={0}", 0));							/// 26,83427
				logger.WriteLine(string.Format("Fehler_Vergleich1={0}", 0));					/// -0,24014
				logger.WriteLine(string.Format("VZ_ZeitImpulse1={0}", 0));						/// 500,07962
				logger.WriteLine(string.Format("VZ_Impulse1={0}", 0));						    /// 4473091
				logger.WriteLine(string.Format("ZeitImpulse_VZ1={0}", 0));						/// 976718
				logger.WriteLine(string.Format("VorwahlZähler1={0}", 0));						/// 0,00000
				logger.WriteLine(string.Format("VZ_Nummer1={0}", 0));							/// 3
				logger.WriteLine(string.Format("Anfangsgewicht1={0}", 0));						/// 4,66535
				logger.WriteLine(string.Format("Endgewicht1={0}", 0));							/// 8,39145
				logger.WriteLine(string.Format("MinDurchfluss1={0}", 0));						/// 26,73800
				logger.WriteLine(string.Format("MaxDurchfluss1={0}", 0));						/// 27,04800
				logger.WriteLine(string.Format("Q_Einstellzeit1={0}", 0));						/// 4,17
				logger.WriteLine(string.Format("Pumpennummer1={0}", 0));						/// 3
				logger.WriteLine(string.Format("Drehzahl1={0}", 0));							/// 1743
				logger.WriteLine(string.Format("DAW_Wert1={0}", 0));							/// 2700
				logger.WriteLine(string.Format("Leitfähigkeit1={0}", 0));						/// 543,10
				logger.WriteLine(string.Format("LuftDruck1={0}", 0));							/// 0,0
				logger.WriteLine(string.Format("LuftFeuchtigkeit1={0}", 0));					/// 0,0
				logger.WriteLine(string.Format("HyDruck1={0}", 0));					    		/// 6,2
				logger.WriteLine(string.Format("VorratsDruckHy1={0}", 0));						/// 6,3
				logger.WriteLine(string.Format("Anfangsgewicht2_1={0}", 0));					/// 37,94400
				logger.WriteLine(string.Format("Endgewicht2_1={0}", 0));						/// 37,94200
				logger.WriteLine(string.Format("Prüfmasse2_1={0}", 0));							/// -0,00200
				logger.WriteLine(string.Format("GegenWaage1={0}", 0));							/// 1
                                                                                                /// 
				logger.WriteLine(string.Format("Q2_geprüft={0}", 1));							/// 1
				logger.WriteLine(string.Format("Prüfvolumen2={0}", 0));							/// 4,65370
				logger.WriteLine(string.Format("Prüfmasse2={0}", 0));							/// 4,64078
				logger.WriteLine(string.Format("Temp1_P2={0}", 0));						    	/// 19,9
				logger.WriteLine(string.Format("Temp2_P2={0}", 0));							    /// 19,9
				logger.WriteLine(string.Format("Temp3_P2={0}", 0)); 							/// 19,9
				logger.WriteLine(string.Format("Temp4_P2={0}", 0));	    						/// 19,9
				logger.WriteLine(string.Format("Temp5_P2={0}", 0));		    					/// 19,9
				logger.WriteLine(string.Format("Temp6_P2={0}", 0));			    				/// 19,9
				logger.WriteLine(string.Format("Temp7_P2={0}", 0));				    			/// 0,0
				logger.WriteLine(string.Format("Temp8_P2={0}", 0));					    		/// 0,0
                logger.WriteLine(string.Format("Druck1_P2={0}", q2.TestRslt.PressUpMean.ToString(Program.AltCulture)));
                logger.WriteLine(string.Format("Druck2_P2={0}", q2.TestRslt.PressDownMean.ToString(Program.AltCulture)));
				logger.WriteLine(string.Format("K-Faktor2={0}", 0));							/// 0,99822140
				logger.WriteLine(string.Format("Q_Waage2={0}", 0));						    	/// 41,84627
				logger.WriteLine(string.Format("Q_Vergleich2={0}", 0));							/// 41,68738
				logger.WriteLine(string.Format("Fehler_Vergleich2={0}", 0));				    /// -0,37970
				logger.WriteLine(string.Format("VZ_ZeitImpulse2={0}", 0));						/// 400,35379
				logger.WriteLine(string.Format("VZ_Impulse2={0}", 0));							/// 166897
				logger.WriteLine(string.Format("ZeitImpulse_VZ2={0}", 0));						/// 781941
				logger.WriteLine(string.Format("VorwahlZähler2={0}", 0));						/// 0,00000
				logger.WriteLine(string.Format("VZ_Nummer2={0}", 0));							/// 2
				logger.WriteLine(string.Format("Anfangsgewicht2={0}", 0));						/// 0,02457
				logger.WriteLine(string.Format("Endgewicht2={0}", 0));							/// 4,66535
				logger.WriteLine(string.Format("MinDurchfluss2={0}", 0));						/// 40,43333
				logger.WriteLine(string.Format("MaxDurchfluss2={0}", 0));						/// 42,23333
				logger.WriteLine(string.Format("Q_Einstellzeit2={0}", 0));						/// 3,80
				logger.WriteLine(string.Format("Pumpennummer2={0}", 0));						/// 3
				logger.WriteLine(string.Format("Drehzahl2={0}", 0));							/// 1743
				logger.WriteLine(string.Format("DAW_Wert2={0}", 0));							/// 500
				logger.WriteLine(string.Format("Leitfähigkeit2={0}", 0));						/// 543,10
				logger.WriteLine(string.Format("LuftDruck2={0}", 0));							/// 0,0
				logger.WriteLine(string.Format("LuftFeuchtigkeit2={0}", 0));					/// 0,0
				logger.WriteLine(string.Format("HyDruck2={0}", 0));							    /// 6,2
				logger.WriteLine(string.Format("VorratsDruckHy2={0}", 0));						/// 6,3
				logger.WriteLine(string.Format("Anfangsgewicht2_2={0}", 0));					/// 37,95000
				logger.WriteLine(string.Format("Endgewicht2_2={0}", 0));						/// 37,94400
				logger.WriteLine(string.Format("Prüfmasse2_2={0}", 0));							/// -0,00600
				logger.WriteLine(string.Format("GegenWaage2={0}", 0));							/// 1
                                                                                                /// 
				logger.WriteLine(string.Format("Q3_geprüft={0}", 1));							/// 1
                logger.WriteLine(string.Format("Prüfvolumen3={0}", 0));							/// 107,76493
                logger.WriteLine(string.Format("Prüfmasse3={0}", 0));							/// 107,46800
                logger.WriteLine(string.Format("Temp1_P3={0}", 0)); 							/// 19,8
                logger.WriteLine(string.Format("Temp2_P3={0}", 0));	    						/// 19,8
                logger.WriteLine(string.Format("Temp3_P3={0}", 0));		    					/// 19,8
                logger.WriteLine(string.Format("Temp4_P3={0}", 0));			    				/// 19,8
                logger.WriteLine(string.Format("Temp5_P3={0}", 0));				    			/// 19,8
                logger.WriteLine(string.Format("Temp6_P3={0}", 0));					    		/// 19,8
                logger.WriteLine(string.Format("Temp7_P3={0}", 0));						    	/// 0,0
                logger.WriteLine(string.Format("Temp8_P3={0}", 0));							    /// 0,0
                logger.WriteLine(string.Format("Druck1_P3={0}", q3.TestRslt.PressUpMean.ToString(Program.AltCulture)));
                logger.WriteLine(string.Format("Druck2_P3={0}", q3.TestRslt.PressDownMean.ToString(Program.AltCulture)));
                logger.WriteLine(string.Format("K-Faktor3={0}", 0));							/// 0,99824190
                logger.WriteLine(string.Format("Q_Waage3={0}", 0));							    /// 3874,27093
                logger.WriteLine(string.Format("Q_Vergleich3={0}", 0));							/// 3867,08324
                logger.WriteLine(string.Format("Fehler_Vergleich3={0}", 0));					/// -0,18552
                logger.WriteLine(string.Format("VZ_ZeitImpulse3={0}", 0));						/// 100,13594
                logger.WriteLine(string.Format("VZ_Impulse3={0}", 0));							/// 129078
                logger.WriteLine(string.Format("ZeitImpulse_VZ3={0}", 0));						/// 195578
                logger.WriteLine(string.Format("VorwahlZähler3={0}", 0));						/// 0,00000
                logger.WriteLine(string.Format("VZ_Nummer3={0}", 0));							/// 1
                logger.WriteLine(string.Format("Anfangsgewicht3={0}", 0));						/// 11,20800
                logger.WriteLine(string.Format("Endgewicht3={0}", 0));							/// 118,67600
                logger.WriteLine(string.Format("MinDurchfluss3={0}", 0));						/// 3862,00000
                logger.WriteLine(string.Format("MaxDurchfluss3={0}", 0));						/// 3872,00000
                logger.WriteLine(string.Format("Q_Einstellzeit3={0}", 0));						/// 26,37
                logger.WriteLine(string.Format("Pumpennummer3={0}", 0));						/// 2
                logger.WriteLine(string.Format("Drehzahl3={0}", 0));							/// 2269
                logger.WriteLine(string.Format("DAW_Wert3={0}", 0));							/// 1501
                logger.WriteLine(string.Format("Leitfähigkeit3={0}", 0));						/// 543,10
                logger.WriteLine(string.Format("LuftDruck3={0}", 0));							/// 0,0
                logger.WriteLine(string.Format("LuftFeuchtigkeit3={0}", 0));					/// 0,0
                logger.WriteLine(string.Format("HyDruck3={0}", 0));			    				/// 6,2
                logger.WriteLine(string.Format("VorratsDruckHy3={0}", 0));						/// 6,3
                logger.WriteLine(string.Format("Anfangsgewicht2_3={0}", 0));					/// 0,00818
                logger.WriteLine(string.Format("Endgewicht2_3={0}", 0));						/// 0,00800
                logger.WriteLine(string.Format("Prüfmasse2_3={0}", 0));			    			/// -0,00018
                logger.WriteLine(string.Format("GegenWaage3={0}", 0));							/// 1
                /// 
				logger.WriteLine(string.Format("Q4_geprüft={0}", 0));							/// 0
                                                                                                /// 
				logger.WriteLine(string.Format("Q5_geprüft={0}", 0));							/// 0
                                                                                                /// 
				logger.WriteLine(string.Format("FüllenDruck={0}", 0));							/// 0,00
				logger.WriteLine(string.Format("EvakVorneDruck={0}", 0));						/// 0,00
				logger.WriteLine(string.Format("EvakHintenDruck={0}", 0));						/// -1,00
				logger.WriteLine(string.Format("Spüldurchfluss={0}", 0));						/// 4722,00
				logger.WriteLine(string.Format("AbpressDruck={0}", 0));							/// 20,13
				logger.WriteLine(string.Format("AbpressDruckVorne={0}", 0));					/// 20,16
				logger.WriteLine(string.Format("AbpressDruckBeginn={0}", 0));					/// 0,00
				logger.WriteLine(string.Format("EntwässernDruck={0}", 0));						/// -1,00
				logger.WriteLine(string.Format("ZaehlwerktestAnfang={0}", 0));					/// 0,00000
				logger.WriteLine(string.Format("ZaehlwerktestEnde={0}", 0));					/// 0,00000
				logger.WriteLine(string.Format("ZaehlwerktestImpulse={0}", 0));					/// 0
				logger.WriteLine(string.Format("MeldungZaehler={0}", 0));						/// 0


				logger.WriteLine(string.Empty);
				logger.WriteLine("[allgemein]");
                ///
				logger.WriteLine(string.Format("Prüfer={0}", 6));									/// 1047
				logger.WriteLine(string.Format("PrüferID={0}", 6));									/// 246
				logger.WriteLine(string.Format("AuftragKompakt={0}", 0));							/// 4248189
				logger.WriteLine(string.Format("VariantenCode={0}", "IP"));							/// IPRO04CMECAZDKAMMXB1AA2011201101AEUAA1XX314NM1XXXLX
				logger.WriteLine(string.Format("SollStückzahl={0}", 3));							/// 1000
				logger.WriteLine(string.Format("IstStückzahl={0}", 3));								/// 61
				logger.WriteLine(string.Format("Bemerkung=§"));										/// §
				logger.WriteLine(string.Format("BetriebsArt={0}", 3));								/// C
				logger.WriteLine(string.Format("BuchstabenVorEtikett=8SEN01"));						/// 8SEN01
				logger.WriteLine(string.Format("BuchstabenNachEtikett="));							/// 
				logger.WriteLine(string.Format("StehenderStartStop={0}", 0));						/// 0
				logger.WriteLine(string.Format("ID_WzPruefreihe={0}", batch.BatchNr));				/// 2583
				logger.WriteLine(string.Format("ID_Pruefstand={0}", 18000 + batch.TestBenchId));	/// 18004
				logger.WriteLine(string.Format("DichteKorrektur=0,00000"));							/// 0,00000
				logger.WriteLine(string.Format("LuftauftriebsKorrekturfaktor=1,00000"));			/// 1,00100
				logger.WriteLine(string.Format("ProgrammVersion={0}", Program.Version));
				logger.WriteLine(string.Format("LetzteAenderung={0}", Program.BuildDateTime.ToShortDateString()));
				logger.WriteLine(string.Format("QuarzTakt={0}", 0));								/// 1953,125

				/// Close the file
				logger.Close();
				logger = null;
			}
			catch (Exception exc)
			{
				log.ErrorFormat("Results not saved to disk: {0}", exc.Message);
				return Retv.Error;
			}
#endif
            return Retv.OK;	/// OK
		}


#if ORACLE_DB
		public static Retv WriteResultsToDatabase(OracleConnection conn, Results.Entities.Batch batch, bool safeMode)
		{
            OracleTransaction transaction = null;

            try
            {
                conn.Open();	/// Open the Oracle database
                transaction = conn.BeginTransaction();

                SaveBatchData(conn, batch);

				foreach (var wMtr in batch.WaterMeters)
				{
					SaveSingleWM2DB(conn, wMtr, safeMode);
				}

				transaction.Commit();
			}
			catch (Exception exc)
			{
				if (transaction != null) transaction.Rollback();

				log.ErrorFormat("Results of batch {0} not written to ORACLE database: {1}",
								batch.BatchNr, exc.Message);

				conn.Close();
				return Retv.Error;
			}

			conn.Close();
			return Retv.OK;
		}


		/// <summary>
		/// Write one meter results into the database
		/// </summary>
		/// <param name="wmNr">0-based water meter number</param>
		/// <param name="results">Sorted list of results to save</param>
		static void SaveSingleWM2DB(OracleConnection conn, Results.Entities.WaterMeter wm, bool safeMode)
		{
			if (string.IsNullOrEmpty(wm.SerialNr)) return;		/// No database activity possible w/o PCB number

			if (safeMode && !wm.Passed) return;
            
			///
			/// Read a list of all prufindexes for a given PCB Number
			///
			IList<int> pruefindexes = new List<int>();
			{
				OracleParameter parm = new OracleParameter();
				parm.OracleDbType = OracleDbType.Varchar2;
				parm.Value = wm.SerialNr;

				OracleCommand cmd1 = new OracleCommand("SELECT Pruefindex FROM VT_ZAEHLER_PINDEX_PD WHERE VT_Fernum = :1 AND ANBID = 4", conn);
				cmd1.Parameters.Add(parm);

				OracleDataReader dr = cmd1.ExecuteReader();
                while (dr.Read()) { pruefindexes.Add(dr.GetInt32(0)); }
                dr.Close();
            }
            {
                OracleParameter parm = new OracleParameter();
                parm.OracleDbType = OracleDbType.Varchar2;
                parm.Value = wm.SerialNr;

                OracleCommand cmd1 = new OracleCommand("SELECT Max_Pruefindex FROM VT_ZAEHLER_PD WHERE VT_Fernum = :1 AND ANBID = 4", conn);
                cmd1.Parameters.Add(parm);

                OracleDataReader dr = cmd1.ExecuteReader();
                while (dr.Read()) { pruefindexes.Add(dr.GetInt32(0)); }
                dr.Close();
            }

            ///
			/// Determine MAX_Pruefindex
			///
			int maxpruefindexLowPart = 0;
			foreach (var v in pruefindexes)
			{
				if ((v % 100) > maxpruefindexLowPart) maxpruefindexLowPart = (v % 100);
			}
			int MAX_Pruefindex = 100 * DBCfg.TestBenchId + maxpruefindexLowPart + 1;


			int Hydr_Pruefung;
			if (wm.Passed)
			{
				/// Passed
				if (maxpruefindexLowPart == 0)
					Hydr_Pruefung = 96;
				else
					Hydr_Pruefung = 224;
			}
			else
			{
				/// Failed
				Hydr_Pruefung = 97;     /// Hydr. test failed, Pressure test passed
			}

			wm.Pruefindex = MAX_Pruefindex;
			wm.HydrPruefung = Hydr_Pruefung;
			SaveOrUpdateWM(conn, wm, MAX_Pruefindex, Hydr_Pruefung);
		}


		/// <summary>
		/// Save common batch data
		/// </summary>
		/// <param name="b">Batch</param>
		static void SaveBatchData(OracleConnection conn, Results.Entities.Batch b)
        {
            OracleParameter parm;

            OracleCommand cmd = new OracleCommand("INSERT INTO VT_PRUEFREIHE_PD(" +
                                                    "ANBID, ID_Pruefstand, ID_WzPruefreihe, ID_WZTyp, Rev_WZTyp, Rev_Pruefstand_WZTyp, " +
                                                    "StartDatumZeit, EndDatumZeit, Betriebsart, QVzKontakt, " +
                                                    "FuellenBegDruck, DruckEvakVorne, DruckEvakHinten, DruckBeiAbpressen, " +
                                                    "Druckentwaessern, SpuelDurchflussIst, ProgrammVersion)" +
                                                    " VALUES (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10, :11, :12, :13, :14, :15, :16, :17)", conn);
            parm = new OracleParameter("ANBID", OracleDbType.Int32);                parm.Value = Anbid_StaraTura;                           cmd.Parameters.Add(parm); ///:1
            parm = new OracleParameter("ID_Pruefstand", OracleDbType.Int32);        parm.Value = 18000 + b.TestBenchId;                     cmd.Parameters.Add(parm); ///:2
            parm = new OracleParameter("ID_WzPruefreihe", OracleDbType.Int32);      parm.Value = b.BatchNr;                                 cmd.Parameters.Add(parm); ///:3
            parm = new OracleParameter("ID_WZTyp", OracleDbType.Int32);             parm.Value = b.WaterMeters[0].WaterMeterData.WMTypeId;  cmd.Parameters.Add(parm); ///:4
            parm = new OracleParameter("Rev_WZTyp", OracleDbType.Int32);            parm.Value = b.WaterMeters[0].WaterMeterData.WMTypeRev; cmd.Parameters.Add(parm); ///:5
            parm = new OracleParameter("Rev_Pruefstand_WZTyp", OracleDbType.Int32); parm.Value = 1;                                         cmd.Parameters.Add(parm); ///:6

            parm = new OracleParameter("StartDatumZeit", OracleDbType.TimeStamp);   parm.Value = b.StartTime;                               cmd.Parameters.Add(parm); ///:7
            parm = new OracleParameter("EndDatumZeit", OracleDbType.TimeStamp);     parm.Value = b.EndTime;                                 cmd.Parameters.Add(parm); ///:8
            parm = new OracleParameter("Betriebsart", OracleDbType.Varchar2);       parm.Value = "";                                        cmd.Parameters.Add(parm); ///:9
            parm = new OracleParameter("QVzKontakt", OracleDbType.Double);          parm.Value = 0;                                         cmd.Parameters.Add(parm); ///:10

            parm = new OracleParameter("FuellenBegDruck", OracleDbType.Double);     parm.Value = 0;                                         cmd.Parameters.Add(parm); ///:11
            parm = new OracleParameter("DruckEvakVorne", OracleDbType.Double);      parm.Value = 0;                                         cmd.Parameters.Add(parm); ///:12
            parm = new OracleParameter("DruckEvakHinten", OracleDbType.Double);     parm.Value = 0;                                         cmd.Parameters.Add(parm); ///:13
            parm = new OracleParameter("DruckBeiAbpressen", OracleDbType.Double);   parm.Value = 0; /*TODO*/				            	cmd.Parameters.Add(parm); ///:14

            parm = new OracleParameter("Druckentwaessern", OracleDbType.Double);    parm.Value = 0;                                         cmd.Parameters.Add(parm); ///:15
            parm = new OracleParameter("SpuelDurchflussIst", OracleDbType.Double);  parm.Value = 0; /*TODO*/					            cmd.Parameters.Add(parm); ///:16
            parm = new OracleParameter("ProgrammVersion", OracleDbType.Varchar2);   parm.Value = "TBF v." + b.ProgramVersion;               cmd.Parameters.Add(parm); ///:17

            cmd.ExecuteNonQuery();	    /// Returns nr. of updated rows

            if ((id_WZTyp != b.WaterMeters[0].WaterMeterData.WMTypeId) || (rev_WZTyp != b.WaterMeters[0].WaterMeterData.WMTypeRev) || testInfos.Count == 0)
            {
                testInfos.Clear();
                id_WZTyp = b.WaterMeters[0].WaterMeterData.WMTypeId;
                rev_WZTyp = b.WaterMeters[0].WaterMeterData.WMTypeRev;

                OracleCommand cmd1 = new OracleCommand("SELECT PruefungsNr, PosFehlerKalt, QBezeichnung FROM VT_PRUEFPUNKT_SOLL_SD WHERE ANBID=4 AND ID_WZTyp=:1 AND Rev_WZTyp=:2", conn);
                parm = new OracleParameter("ID_WZTyp", OracleDbType.Int32);     parm.Value = id_WZTyp;      cmd1.Parameters.Add(parm); ///:1
                parm = new OracleParameter("Rev_WZTyp", OracleDbType.Int32);    parm.Value = rev_WZTyp;     cmd1.Parameters.Add(parm); ///:2

                OracleDataReader dr = cmd1.ExecuteReader();
                while (dr.Read())
                {
                    int pruefungsNr = dr.GetInt32(0);
                    double errLimHi = dr.GetDouble(1);
                    string qBezeichnung = dr.GetString(2);
                    if (qBezeichnung == "Q2" && errLimHi > 2.0) qBezeichnung = "Q2adj";
					if (qBezeichnung.ToLower().Contains("just") && pruefungsNr == -1) qBezeichnung = "Adjustment";

					if (qBezeichnung.Contains("Q") || qBezeichnung == "Adjustment")
					{
						testInfos.Add(new TestInfo(pruefungsNr, qBezeichnung));
						log.WarnFormat("VT_PRUEFPUNKT_SOLL_SD info : ID_WZTyp={0} Rev_WZTyp={1} PruefungsNr={2} PosFehlerKalt={3} QBezeichnung={4}",
										id_WZTyp, rev_WZTyp, pruefungsNr, errLimHi, qBezeichnung);
					}
                }
                dr.Close();
            }

            foreach (var testInfo in testInfos)
            {
                Results.Entities.TestRslt tr = b.GetTestRslt(testInfo.QBezeichnung, 0);

                if (tr == null) tr = b.GetTestRslt(testInfo.QBezeichnung, 1);        /// TODO: Remove this workaround for large watermeters with multiple parts at Q3
                
                if (tr == null) continue;

                OracleCommand cmd2 = new OracleCommand("INSERT INTO VT_PRUEFDURCHFLUSS_PD(" +
                                                        "ANBID, ID_Pruefstand, ID_WzPruefreihe, PruefungsNr, " +
                                                        "PVOL, PMasse, MinDurchfluss, MaxDurchfluss, " +
                                                        "Q_ist, KFaktor, Q_VZ, F_VZ, RegelEinstellZeit, Drehzahl, " +
                                                        "BeginnDruck_Vorne, BeginnDruck_Hinten, EndDruck_Vorne, EndDruck_Hinten, " +
                                                        "TVWZ, IVWZ, Verwendeter_VZ, BeginnGewicht, EndGewicht)" +
                                                        " VALUES (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10, :11, :12, :13, :14, :15, " +
                                                        ":16, :17, :18, :19, :20, :21, :22, :23)", conn);

                parm = new OracleParameter("ANBID", OracleDbType.Int32);                parm.Value = Anbid_StaraTura;                                   cmd2.Parameters.Add(parm); ///:1
                parm = new OracleParameter("ID_Pruefstand", OracleDbType.Int32);        parm.Value = 18000 + b.TestBenchId;                             cmd2.Parameters.Add(parm); ///:2
                parm = new OracleParameter("ID_WzPruefreihe", OracleDbType.Int32);      parm.Value = b.BatchNr;                                         cmd2.Parameters.Add(parm); ///:3
                parm = new OracleParameter("PruefungsNr", OracleDbType.Int32);          parm.Value = testInfo.PruefungsNr;                              cmd2.Parameters.Add(parm); ///:4
                ///
                parm = new OracleParameter("PVOL", OracleDbType.Double);                parm.Value = Units.ConvertTo(Unit.l, tr.VolumeCTV);             cmd2.Parameters.Add(parm); ///:5
                parm = new OracleParameter("PMasse", OracleDbType.Double);              parm.Value = Units.ConvertTo(Unit.kg, tr.MassEnd-tr.MassStart); cmd2.Parameters.Add(parm); ///:6
                parm = new OracleParameter("MinDurchfluss", OracleDbType.Double);       parm.Value = Units.ConvertTo(Unit.lph, tr.FlowMin);             cmd2.Parameters.Add(parm); ///:7
                parm = new OracleParameter("MaxDurchfluss", OracleDbType.Double);       parm.Value = Units.ConvertTo(Unit.lph, tr.FlowMax);             cmd2.Parameters.Add(parm); ///:8

                double Q_ist = (tr.VolumeMaster != 0) ? (tr.FlowVolume * tr.VolumeCTV / tr.VolumeMaster) : (double)tr.FlowVolume;
                parm = new OracleParameter("Q_ist", OracleDbType.Double);               parm.Value = Units.ConvertTo(Unit.lph, Q_ist);                  cmd2.Parameters.Add(parm); ///:9
                parm = new OracleParameter("KFaktor", OracleDbType.Double);             parm.Value = tr.ConstMaster;                                    cmd2.Parameters.Add(parm); ///:10
                parm = new OracleParameter("Q_VZ", OracleDbType.Double);                parm.Value = Units.ConvertTo(Unit.lph, tr.FlowVolume);          cmd2.Parameters.Add(parm); ///:11
                parm = new OracleParameter("F_VZ", OracleDbType.Double);                parm.Value = tr.ErrorMaster;                                    cmd2.Parameters.Add(parm); ///:12
                parm = new OracleParameter("RegelEinstellZeit", OracleDbType.Double);   parm.Value = (double)tr.FlowSetTime;                            cmd2.Parameters.Add(parm); ///:13
                parm = new OracleParameter("Drehzahl", OracleDbType.Int32);             parm.Value = 0; /* TODO */                                      cmd2.Parameters.Add(parm); ///:14
                ///
                parm = new OracleParameter("BeginnDruck_Vorne", OracleDbType.Double);   parm.Value = Units.ConvertTo(Unit.bar, tr.PressUpStart);        cmd2.Parameters.Add(parm); ///:15
                parm = new OracleParameter("BeginnDruck_Hinten", OracleDbType.Double);  parm.Value = Units.ConvertTo(Unit.bar, tr.PressDownStart);      cmd2.Parameters.Add(parm); ///:16
                parm = new OracleParameter("EndDruck_Vorne", OracleDbType.Double);      parm.Value = Units.ConvertTo(Unit.bar, tr.PressUpEnd);          cmd2.Parameters.Add(parm); ///:17
                parm = new OracleParameter("EndDruck_Hinten", OracleDbType.Double);     parm.Value = Units.ConvertTo(Unit.bar, tr.PressDownEnd);        cmd2.Parameters.Add(parm); ///:18
                ///
                parm = new OracleParameter("TVWZ", OracleDbType.Double);                parm.Value = tr.TestTime;                                       cmd2.Parameters.Add(parm); ///:19
                parm = new OracleParameter("IVWZ", OracleDbType.Int32);                 parm.Value = tr.PulsesMaster;                                   cmd2.Parameters.Add(parm); ///:20
                parm = new OracleParameter("Verwendeter_VZ", OracleDbType.Int32);       parm.Value = 0; /* TODO */                                      cmd2.Parameters.Add(parm); ///:21
                parm = new OracleParameter("BeginnGewicht", OracleDbType.Double);       parm.Value = Units.ConvertTo(Unit.kg, tr.MassStart);            cmd2.Parameters.Add(parm); ///:22
                parm = new OracleParameter("EndGewicht", OracleDbType.Double);          parm.Value = Units.ConvertTo(Unit.kg, tr.MassEnd);              cmd2.Parameters.Add(parm); ///:23

                cmd2.ExecuteNonQuery();	    /// Returns nr. of updated rows
            }

            log.InfoFormat("Batch data saved, batchNr={0}", b.BatchNr);
        }


		static void SaveOrUpdateWM(OracleConnection conn, Results.Entities.WaterMeter wm, int max_Pruefindex, int hydr_Pruefung)
		{
			int sekundaere_Adr = wm.Passed ? 1 : 0;
			int idBenutzer = 6;     // = wm.Batch.UserNumber;

			if (max_Pruefindex % 100 == 1)
			{
				OracleCommand cmd = new OracleCommand("INSERT INTO VT_ZAEHLER_PD(Auftragsnummer, VT_Identnummer, VT_Fernum, Max_Pruefindex, Zaehlernummer, Sekundaere_Adr, Hydr_Pruefung, ID_Benutzer, ANBID, Baujahr) VALUES (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10)", conn);

				OracleParameter parm;
				parm = new OracleParameter("Auftragsnummer", OracleDbType.Varchar2); parm.Value = wm.PurchaseOrder; cmd.Parameters.Add(parm);
				parm = new OracleParameter("VT_Identnummer", OracleDbType.Varchar2); parm.Value = "IPBATMXX";		cmd.Parameters.Add(parm);
				parm = new OracleParameter("VT_Fernum", OracleDbType.Varchar2);		 parm.Value = wm.SerialNr;		cmd.Parameters.Add(parm);
				parm = new OracleParameter("Max_Pruefindex", OracleDbType.Int32);	 parm.Value = max_Pruefindex;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("Zaehlernummer", OracleDbType.Int32);	 parm.Value = -1;				cmd.Parameters.Add(parm);
				parm = new OracleParameter("Sekundaere_Adr", OracleDbType.Int32);	 parm.Value = sekundaere_Adr;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("Hydr_Pruefung", OracleDbType.Int32);	 parm.Value = hydr_Pruefung;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("ID_Benutzer", OracleDbType.Int32);		 parm.Value = idBenutzer;		cmd.Parameters.Add(parm);
				parm = new OracleParameter("ANBID", OracleDbType.Int32);			 parm.Value = Anbid_StaraTura;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("Baujahr", OracleDbType.Int32);			 parm.Value = DBCfg.Baujahr;	cmd.Parameters.Add(parm);

				cmd.ExecuteNonQuery();
                log.InfoFormat("VT_ZAEHLER_PD inserted, PcbNr={0}, pos={1}, maxPruefix={2}", wm.SerialNr, wm.WMPosition, max_Pruefindex);
            }
			else
			{
				OracleCommand cmd = new OracleCommand("UPDATE VT_ZAEHLER_PD SET Auftragsnummer = :1, VT_Identnummer = :2, Max_Pruefindex = :3, Hydr_Pruefung= :4, ID_Benutzer= :5, Baujahr= :6 WHERE VT_Fernum = :7 and ANBID = :8", conn);

				OracleParameter parm;
				parm = new OracleParameter("Auftragsnummer", OracleDbType.Varchar2); parm.Value = wm.PurchaseOrder; cmd.Parameters.Add(parm);
				parm = new OracleParameter("VT_Identnummer", OracleDbType.Varchar2); parm.Value = "IPBATMXX";		cmd.Parameters.Add(parm);
				parm = new OracleParameter("Max_Pruefindex", OracleDbType.Int32);	 parm.Value = max_Pruefindex;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("Hydr_Pruefung", OracleDbType.Int32);	 parm.Value = hydr_Pruefung;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("ID_Benutzer", OracleDbType.Int32);		 parm.Value = idBenutzer;		cmd.Parameters.Add(parm);
				parm = new OracleParameter("Baujahr", OracleDbType.Int32);			 parm.Value = DBCfg.Baujahr;	cmd.Parameters.Add(parm);
				parm = new OracleParameter("VT_Fernum", OracleDbType.Varchar2);		 parm.Value = wm.SerialNr;		cmd.Parameters.Add(parm);
				parm = new OracleParameter("ANBID", OracleDbType.Int32);			 parm.Value = Anbid_StaraTura;	cmd.Parameters.Add(parm);

				cmd.ExecuteNonQuery();
                log.InfoFormat("VT_ZAEHLER_PD updated, PcbNr={0}, pos={1}, maxPruefix={2}", wm.SerialNr, wm.WMPosition, max_Pruefindex);
            }

			{
				OracleCommand cmd = new OracleCommand("INSERT INTO VT_ZAEHLER_PINDEX_PD(" +
														"VT_Fernum, Pruefindex, ANBID, ID_Pruefstand, ID_WzPruefreihe, Hydr_Pruefung, " +
														"ReedKontakt, ReedKontaktOK, ReedKontaktZeit, KorrImprate, FestWertWZ, PtestOK, " +
														"Zaehlerstand, WT_Platz_NR, WZgut, ID_Benutzer, AnzahlPruefungen)" +
														" VALUES (:1, :2, :3, :4, :5, :6, 0, 0, 0, :7, 0, :8, 0, :9, :10, :11, :12)", conn);
				OracleParameter parm;
				parm = new OracleParameter("VT_Fernum", OracleDbType.Varchar2);		parm.Value = wm.SerialNr;				cmd.Parameters.Add(parm);
				parm = new OracleParameter("Pruefindex", OracleDbType.Int32);		parm.Value = max_Pruefindex;		cmd.Parameters.Add(parm);
				parm = new OracleParameter("ANBID", OracleDbType.Int32);			parm.Value = Anbid_StaraTura;			cmd.Parameters.Add(parm);
				parm = new OracleParameter("ID_Pruefstand", OracleDbType.Int32);	parm.Value = 18000 + wm.Batch.TestBenchId; cmd.Parameters.Add(parm);
				parm = new OracleParameter("ID_WzPruefreihe", OracleDbType.Int32);	parm.Value = wm.Batch.BatchNr;			cmd.Parameters.Add(parm);
				parm = new OracleParameter("Hydr_Pruefung", OracleDbType.Int32);	parm.Value = hydr_Pruefung;				cmd.Parameters.Add(parm);
				// ReedKontakt
				// ReedKontaktOK
				// ReedKontaktZeit
				parm = new OracleParameter("KorrImprate", OracleDbType.Double);		parm.Value = wm.OrigCalibFactor;		cmd.Parameters.Add(parm);
				// FestWertWZ
				parm = new OracleParameter("PtestOK", OracleDbType.Int32);			parm.Value = 0;/*TODO*/					cmd.Parameters.Add(parm);
				// Zaehlerstand
				parm = new OracleParameter("WT_Platz_NR", OracleDbType.Int32);		parm.Value = wm.WMPosition;				cmd.Parameters.Add(parm);
				parm = new OracleParameter("WZgut", OracleDbType.Int32);			parm.Value = wm.Passed ? 1 : 0;			cmd.Parameters.Add(parm);
				parm = new OracleParameter("ID_Benutzer", OracleDbType.Int32);		parm.Value = idBenutzer;				cmd.Parameters.Add(parm);
				parm = new OracleParameter("AnzahlPruefungen", OracleDbType.Int32); parm.Value = 3;							cmd.Parameters.Add(parm);

				cmd.ExecuteNonQuery();
                log.InfoFormat("VT_ZAEHLER_PINDEX_PD inserted, PcbNr={0}, pos={1}, pruefix={2}", wm.SerialNr, wm.WMPosition, max_Pruefindex % 100);
            }



            foreach (var testInfo in testInfos)
            {
                Results.Entities.MeterTestRslt mtr = wm.GetMeterTestRslt(testInfo.QBezeichnung);
                if (mtr == null)
                {
                    throw new Exception(string.Format("'{0}' test results missing, watermeter {1}", testInfo.QBezeichnung, wm.WMPosition));
                }

                SaveMeterTestResult(conn, mtr, testInfo.PruefungsNr, max_Pruefindex);
			}

			{
                double q2ErrWOCorrection = Math.Min(100.0, Math.Max(-100.0, wm.Q2ErrWOCorrection));

				OracleCommand cmd = new OracleCommand("INSERT INTO VT_IP_ZAEHLER_PINDEX_PD(" +
														"VT_Fernum, Pruefindex, ANBID, WITHCORRECTION2HZ, CORRECTION2HZ, DIFF2HZ8HZ, " +
														"WITHQ2CORRECTION, ERRQ2, Q2CORRECTIONFLOWRIGHT, Q2CORRECTIONLEFT, Q2CORRECTIONRIGHT)" +
														" VALUES (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10, :11)", conn);
				OracleParameter parm;
				parm = new OracleParameter("VT_Fernum", OracleDbType.Varchar2);			parm.Value = wm.SerialNr;							cmd.Parameters.Add(parm); ///:1
				parm = new OracleParameter("Pruefindex", OracleDbType.Int32);			parm.Value = max_Pruefindex;	    				cmd.Parameters.Add(parm); ///:2
				parm = new OracleParameter("ANBID", OracleDbType.Int32);				parm.Value = Anbid_StaraTura;						cmd.Parameters.Add(parm); ///:3
				parm = new OracleParameter("WITHCORRECTION2HZ", OracleDbType.Int32);	parm.Value = wm.Hz2CorrectionDone ? 1 : 0;			cmd.Parameters.Add(parm); ///:4
				parm = new OracleParameter("CORRECTION2HZ", OracleDbType.Double);		parm.Value = wm.Hz2Correction;						cmd.Parameters.Add(parm); ///:5
                parm = new OracleParameter("DIFF2HZ8HZ", OracleDbType.Double);          parm.Value = Math.Min(99.0, Math.Max(-99.0, wm.Diff2Hz8Hz)); cmd.Parameters.Add(parm); ///:6
				parm = new OracleParameter("WITHQ2CORRECTION", OracleDbType.Int32);		parm.Value = wm.Q2CorrectionDone ? 1 : 0;			cmd.Parameters.Add(parm); ///:7
                parm = new OracleParameter("ERRQ2", OracleDbType.Double);               parm.Value = q2ErrWOCorrection;                     cmd.Parameters.Add(parm); ///:8
				parm = new OracleParameter("Q2CORRECTIONFLOWRIGHT", OracleDbType.Int32);parm.Value = wm.Q2CorrFlowRight;/*1=right to left*/	cmd.Parameters.Add(parm); ///:9
				parm = new OracleParameter("Q2CORRECTIONLEFT", OracleDbType.Int32);		parm.Value = wm.Q2CorrLFlow;		                cmd.Parameters.Add(parm); ///:10
                parm = new OracleParameter("Q2CORRECTIONRIGHT", OracleDbType.Int32);    parm.Value = wm.Q2CorrRFlow;                        cmd.Parameters.Add(parm); ///:11

				int rowsUpdated = cmd.ExecuteNonQuery();
                log.InfoFormat("VT_IP_ZAEHLER_PINDEX_PD inserted, PcbNr={0}, pruefix={1}", wm.SerialNr, max_Pruefindex);
            }
		}


		/// <summary>
		/// Saves a water meter result of a single test
		/// </summary>
		/// <param name="q">q = 0, 1, 2 or 3 (Adj., Q1, Q2, Q3)</param>
		/// <returns>Nr. of rows updated</returns>
		static int SaveMeterTestResult(OracleConnection conn, Results.Entities.MeterTestRslt mtr, int qq, int max_Pruefindex) /// 
		{
			double Q_wm = 3600.0 * mtr.VolumeMeter / mtr.TestTime;		/// in [l/hour]
            double Q_wm_with_upper_bound = Math.Min(2 * 1000 * mtr.TestRslt.FlowVolume, Math.Max(0.0, Q_wm));

			OracleCommand cmd = new OracleCommand("INSERT INTO VT_PRUEFREIHE_IST_PD(" +
												  "VT_Fernum, Pruefindex, PruefungsNr, ANBID, ID_WZTyp, Rev_WZTyp, Rev_WZPruefpunkt, " +
												  "Q_WZ, Q_Fehler, Q_Best, NIZ, AnfangZStand, EndZStand, " +
												  "KorrErrQok, KorrErrQ, KorrQWz, TIZ, Vol_WZ_US, TempMittel_US)" +
												  " VALUES (:1, :2, :3, :4, :5, :6, :7, :8, :9, :10, :11, :12, :13, 0, 0, 0, :14, 0, 0)", conn);
			OracleParameter parm;
			parm = new OracleParameter("VT_Fernum", OracleDbType.Varchar2);		parm.Value = mtr.WaterMeter.SerialNr;	                        cmd.Parameters.Add(parm); ///:1
			parm = new OracleParameter("Pruefindex", OracleDbType.Int32);		parm.Value = max_Pruefindex;		                            cmd.Parameters.Add(parm); ///:2
			parm = new OracleParameter("PruefungsNr", OracleDbType.Int32);		parm.Value = qq;						                        cmd.Parameters.Add(parm); ///:3
			parm = new OracleParameter("ANBID", OracleDbType.Int32);			parm.Value = Anbid_StaraTura;			                        cmd.Parameters.Add(parm); ///:4
			parm = new OracleParameter("ID_WZTyp", OracleDbType.Int32);			parm.Value = mtr.WaterMeter.WaterMeterData.WMTypeId;            cmd.Parameters.Add(parm); ///:5
			parm = new OracleParameter("Rev_WZTyp", OracleDbType.Int32);		parm.Value = mtr.WaterMeter.WaterMeterData.WMTypeRev;           cmd.Parameters.Add(parm); ///:6
			parm = new OracleParameter("Rev_WZPruefpunkt", OracleDbType.Int32); parm.Value = 1;							                        cmd.Parameters.Add(parm); ///:7
            parm = new OracleParameter("Q_WZ", OracleDbType.Double);            parm.Value = Q_wm_with_upper_bound;                             cmd.Parameters.Add(parm); ///:8
			parm = new OracleParameter("Q_Fehler", OracleDbType.Double);		parm.Value = Math.Min(100.0, Math.Max(-100.0, mtr.Error));      cmd.Parameters.Add(parm); ///:9
			parm = new OracleParameter("Q_Best", OracleDbType.Int32);			parm.Value = mtr.Passed ? 1 : 0;		                        cmd.Parameters.Add(parm); ///:10
			parm = new OracleParameter("NIZ", OracleDbType.Int32);				parm.Value = 0;							                        cmd.Parameters.Add(parm); ///:11
			parm = new OracleParameter("AnfangZStand", OracleDbType.Double);	parm.Value = 0;/*TODO*/					                        cmd.Parameters.Add(parm); ///:12
			parm = new OracleParameter("EndZStand", OracleDbType.Double);		parm.Value = 0;/*TODO*/					                        cmd.Parameters.Add(parm); ///:13
			/// KorrErrQok
			/// KorrErrQ
			/// KorrQWz
			parm = new OracleParameter("TIZ", OracleDbType.Double);		parm.Value = Math.Min(100000, mtr.TestTime);	                cmd.Parameters.Add(parm);
			/// Vol_WZ_US
			/// TempMittel_US

			int retv = cmd.ExecuteNonQuery();
            log.DebugFormat("VT_PRUEFREIHE_IST_PD inserted, PcbNr={0}, q={1}, error={2}", mtr.WaterMeter.SerialNr, qq, mtr.Error);
            return retv;
        }
#endif
	}
}