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

///
/// Copyright (c) 2015-2018 Sensus Metering Systems
///
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using log4net;
using Oracle.DataAccess.Client; // ODP.NET Oracle managed provider
using Config;
using Config.Entities;

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

	public class Database : ComponentBase, IOperation, GenericDevices.IResultsWriter, GenericDevices.IStartInfoReader, 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 DatabaseCfg dbCfg;


        enum CurrentOp
        {
            None,
            CheckBarcodeScanning,
            WriteResults,
            ReadStartInfo,
        }
        CurrentOp currentOp;
        bool opCompleted;
        bool anyError;


        ///
        /// iPerls to verify
        ///
        GenericDevices.IRegisterReader[] iperlHeads;

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

		OracleConnection connection;    /// Oracle database connection


        int id_WZTyp;
        int rev_WZTyp;
        IList<SensusTestInfo> oraDbTestInfos = new List<SensusTestInfo>();  /// Contains only flowId-s ad qBezeichnung-s
        SensusTestInfo[] completeTestInfos;                                 /// Contains also a range (90-100/100-110), a TBF test name and a string form of the flowId


		public Database() {}

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

            currentOp = CurrentOp.None;

			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=STARA01.WORLD;User Id=deltaqual;Password=test;");
                    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();
        }

		public void StopDevice2() { }


        /// <summary>
        /// Reads information on start of a cycle,  Events:  Event.InfoRead
        /// </summary>
        /// <param name="batch">Batch results</param>
        /// <returns>Reference to the operation</returns>
        public IOperation ReadStartInfoOp(Results.Entities.Batch batch)
        {
            if (!dbCfg.ReadStartInfo)
            {
                return null;
            }
            else if (currentOp != CurrentOp.None)
            {
                throw new Exception("Sequence error");
            }
            else
            {
                currentOp = CurrentOp.ReadStartInfo;
                this.batch = batch;
                return this;
            }
        }

		/// <summary>
		/// Writes the test cycle results into a file,  Events:  Event.ResultsWritten
		/// </summary>
		/// <param name="batch">Batch results</param>
		/// <returns>Reference to the operation</returns>
		public IOperation WriteResultsOp(Results.Entities.Batch batch)
		{
            if (!dbCfg.SaveResults)
            {
                return null;
            }
            else if (currentOp != CurrentOp.None)
            {
                throw new Exception("Sequence error");
            }
            else
            {
                currentOp = CurrentOp.WriteResults;
                this.batch = batch;
                return this;
            }
		}


        public IOperation CheckBarcodeScanningOp(GenericDevices.IRegisterReader[] iperlHeads)
        {
            if (currentOp != CurrentOp.None)
            {
                throw new Exception("Sequence error");
            }

            currentOp = CurrentOp.CheckBarcodeScanning;
            this.iperlHeads = iperlHeads;
            return this;
        }

		/// <summary>Start this operation</summary>
		public void Start()
		{
            opCompleted = false;
            anyError = false;
        }

		/// <summary>Run this operation</summary>
		/// <returns>Event.ResultsWritten or Event.Error</returns>
		public Event Run()
		{
            if (currentOp == CurrentOp.ReadStartInfo)
            {
                if (!opCompleted)
                {
                    if (batch.WaterMeters.Count == 0) return Event.ResultsWritten;
#if ORACLE_DB
                    if (dbCfg.DebugLevel != DebugMode.Simulate && connection != null)
                    {
                        if (ReadStartInfoFromDB(connection, batch) == Retv.Error) anyError = true;
                    }
#endif
                    opCompleted = true;
                }

                return anyError ? Event.InfoNotRead : Event.InfoRead;
            }
            else if (currentOp == CurrentOp.WriteResults)
            {
                if (!opCompleted)
                {
                    if (batch.WaterMeters.Count == 0) return Event.ResultsWritten;
#if ORACLE_DB
                    if (dbCfg.DebugLevel != DebugMode.Simulate && connection != null)
                    {
                        if (WriteResultsToDB(connection, batch, false) == Retv.Error) anyError = true;
                    }
#endif
                    opCompleted = true;
                }

                return anyError ? Event.ResultsNotWritten : Event.ResultsWritten;
            }
            else if (currentOp == CurrentOp.CheckBarcodeScanning)
            {
                if (!opCompleted)
                {
#if ORACLE_DB
                    if (dbCfg.DebugLevel != DebugMode.Simulate && connection != null)
                    {
                        if (CheckBarcodeScanning(connection, iperlHeads) == Retv.Error) anyError = true; ;
                    }
#endif
                    opCompleted = true;
                }

                return anyError ? Event.CheckNotDone : Event.CheckDone;
            }
            else
            {
                return Event.None;
            }
		}

		/// <summary>Stop this operation</summary>
		public void Stop()
		{
            currentOp = CurrentOp.None;
		}

#if ORACLE_DB
        public Retv CheckBarcodeScanning(OracleConnection conn, GenericDevices.IRegisterReader[] iPerlHeads)
		{
            try
            {
                conn.Open();	/// Open the Oracle database

                foreach (var rr in iPerlHeads)
                {
                    //WaterMeters.iPerl.WaterMeter iPerlHead = rr as WaterMeters.iPerl.WaterMeter;

                    //if (iPerlHead != null)
                    //{
                    //    OracleCommand cmd = new OracleCommand("select * from IP_ENDTEST_PD where PCBNUMBER = :1 and TESTSTATIONNAME = :2", conn);
                    //    OracleParameter param;
                    //    param = new OracleParameter("PCBNUMBER", OracleDbType.Varchar2); param.Value = iPerlHead.SerialNr; cmd.Parameters.Add(param);
                    //    param = new OracleParameter("TESTSTATIONNAME", OracleDbType.Varchar2); param.Value = "STAWL001"; cmd.Parameters.Add(param);

                    //    bool exists = false;	/// true = RF_Power record exists
                    //    OracleDataReader dr1 = cmd.ExecuteReader();
                    //    if (dr1.Read()) { exists = true; }
                    //    dr1.Close();

                    //    if (!exists)
                    //    {
                    //        iPerlHead.CommFailed = true;
                    //    }
                    //}
                }
			}
			catch (Exception exc)
			{
				log.ErrorFormat("Barcode scanning records were not checked: {1}", exc.Message);

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

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


        public Retv ReadStartInfoFromDB(OracleConnection conn, Results.Entities.Batch batch)
		{
            try
            {
                conn.Open();	/// Open the Oracle database

                foreach (var wMtr in batch.WaterMeters)
                {
                    ReadSingleWMfromDB(conn, wMtr);
                }
            }
            catch (Exception exc)
            {
                log.ErrorFormat("Reading from ORACLE DB failed, batch={0}, error={1}", batch.BatchNr, exc.Message);

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

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

		/// <summary>
		/// Read start info of one water meter from the database
		/// </summary>
		/// <param name="wmNr">0-based water meter number</param>
		/// <param name="results">Sorted list of results to update</param>
        void ReadSingleWMfromDB(OracleConnection conn, Results.Entities.WaterMeter wm)
        {
            if (string.IsNullOrEmpty(wm.SerialNr)) return;		/// No database activity possible w/o PCB number

            wm.Pruefindex = ReadMaxPruefindex(conn, wm);

            // select (Q_Fehler) from VT_PRUEFREIHE_IST_PD where VT_fernum=(1) AND PruefungsNr=(2) AND ANBID=4
        }


        public Retv WriteResultsToDB(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>
		void SaveSingleWM2DB(OracleConnection conn, Results.Entities.WaterMeter wm, bool safeMode)
		{
            if (safeMode && !wm.Passed) return;

            if (string.IsNullOrEmpty(wm.SerialNr)) return;		/// No database activity possible w/o PCB number

            int maxpruefindexLowPart = ReadMaxPruefindex(conn, wm);

            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>
        /// 
        /// </summary>
        /// <param name="conn"></param>
        /// <param name="wm"></param>
        /// <returns></returns>
        int ReadMaxPruefindex(OracleConnection conn, Results.Entities.WaterMeter wm)
        {
            /// Create a list of all prufindexes for a given PCB Number (the list is initially empty)
            IList<int> pruefindexes = new List<int>();
            string purchaseOrder;
            string assignedSerialNr;
            string radioAddress;

            {
                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, Auftragsnummer, Z_Nr_Komplett, VT_Modul_Snr FROM VT_ZAEHLER_PD WHERE VT_Fernum = :1 AND ANBID = 4", conn);
                ///                                                            purchase order  assigned s/n   radio address                         PCB number         Producer ID
                cmd1.Parameters.Add(parm);

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

            /// Determine MAX_Pruefindex
            int maxPrfIndex = 0;
            foreach (var pix in pruefindexes)
            {
                if ((pix % 100) > maxPrfIndex) maxPrfIndex = (pix % 100);
            }

            return maxPrfIndex;
        }

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

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

                ///
                /// Read 'incomplete' TestInfo from the database
                ///
                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

                oraDbTestInfos.Clear();
                OracleDataReader dr = cmd1.ExecuteReader();
                while (dr.Read())
                {
                    int pruefungsNr = dr.GetInt32(0);
                    double errLimHi = dr.GetDouble(1);
                    string qBezeichnung = dr.GetString(2);
                    oraDbTestInfos.Add(new SensusTestInfo(pruefungsNr, string.Empty, qBezeichnung, Range.R100_110, errLimHi.ToString()));
                }
                dr.Close();

                ///
                /// Find a matching complete test info
                /// 
                oraDbTestInfos = oraDbTestInfos.OrderBy(x => x.PruefungsNr).ToList<SensusTestInfo>();
                completeTestInfos = null;
                for (LogType lt = 0; lt < LogType.Count; lt++)
                {
                    SensusTestInfo[] myTinfos = SensusTestInfo.GetTestInfos(lt);
                    if (SensusTestInfo.AreCompatible(oraDbTestInfos, myTinfos))
                    {
                        completeTestInfos = myTinfos;
                        break;
                    }
                }

                foreach (var ti in oraDbTestInfos)
                {
                    log.WarnFormat("VT_PRUEFPUNKT_SOLL_SD info : ID_WZTyp={0} Rev_WZTyp={1} PruefungsNr={2} PosFehlerKalt={3} QBezeichnung={4}",
                                    id_WZTyp, rev_WZTyp, ti.PruefungsNr, ti.TestName, ti.QBezeichnung);
                }

                if (completeTestInfos != null)
                {
                    foreach (var ti in completeTestInfos)
                    {
                        log.WarnFormat("Selected test info : ID_WZTyp={0} Rev_WZTyp={1} PruefungsNr={2} Str={3} QBezeichnung={4} Range={5} Test={6}",
                                        id_WZTyp, rev_WZTyp, ti.PruefungsNr, ti.PruefungsNrStr, ti.QBezeichnung, ti.Range, ti.TestName);
                    }
                }
                else
                {
                    throw new Exception("No matching test infos found");
                }
            }

            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


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

                if (tr == null) tr = b.GetTestRslt(testInfo.TestName, 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);
        }


		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 completeTestInfos)
            {
                Results.Entities.TestData tData = wm.GetTestData(testInfo.TestName);
                Results.Entities.MeterTestRslt mtr;
                if (tData == null)
                {
                    throw new Exception(string.Format("'{0}' test results missing, watermeter {1}", testInfo.TestName, wm.WMPosition));
                }
                else if (tData.Repeats == 1)
                {
                    mtr = wm.GetMeterTestRslt(testInfo.TestName);
                    if (mtr == null) throw new Exception(string.Format("'{0}' test results missing, watermeter {1}", testInfo.TestName, wm.WMPosition));
                }
                else
                {
                    Results.Entities.MeterTestRslt firstMtr = wm.GetMeterTestRslt(Utils.TestTitle(tData, 1));
                    if (firstMtr == null) throw new Exception(string.Format("'{0}' test results missing, watermeter {1}", Utils.TestTitle(tData, 1), wm.WMPosition));

                    mtr = new Results.Entities.MeterTestRslt();
                    mtr.CopyContentFrom(firstMtr);
                    mtr.TestRslt = firstMtr.TestRslt;
                    mtr.WaterMeter = firstMtr.WaterMeter;
                    for (int i = 2; i <= tData.Repeats; i++)
                    {
                        Results.Entities.MeterTestRslt nextMtr = wm.GetMeterTestRslt(Utils.TestTitle(tData, i));
                        if (nextMtr == null) throw new Exception(string.Format("'{0}' test results missing, watermeter {1}", Utils.TestTitle(tData, i), wm.WMPosition));

                        mtr.TestTime += nextMtr.TestTime;
                        mtr.VolumeMeter += nextMtr.VolumeMeter;
                        mtr.VolumeRef += nextMtr.VolumeRef;
                        mtr.VolumeEnd = nextMtr.VolumeEnd;
                        mtr.Passed = (mtr.Passed && nextMtr.Passed);
                    }
                    mtr.Error = Formulas.ErrorFromVolumes(mtr.VolumeMeter, mtr.VolumeRef);
                }

                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, Q2CORRECTIONRIGHT, ERRQ2, Q2CORRECTIONFLOWRIGHT, Q2CORRECTIONLEFT)" +
														" 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("Q2CORRECTIONRIGHT", OracleDbType.Int32);    parm.Value = wm.Q2CorrLR;                                   cmd.Parameters.Add(parm); ///:8
                parm = new OracleParameter("ERRQ2", OracleDbType.Double);               parm.Value = q2ErrWOCorrection;                             cmd.Parameters.Add(parm); ///:9
				parm = new OracleParameter("Q2CORRECTIONFLOWRIGHT", OracleDbType.Int32);parm.Value = wm.Q2CorrFlowRight; /* 1 = R->L */	            cmd.Parameters.Add(parm); ///:10
                parm = new OracleParameter("Q2CORRECTIONLEFT", OracleDbType.Int32);     parm.Value = wm.Q2CorrRL;                                   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>
		int SaveMeterTestResult(OracleConnection conn, Results.Entities.MeterTestRslt mtr, int pruefungsNr, 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, :14, 0, :15, 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 = pruefungsNr;						                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 = mtr.VolumeStart;									cmd.Parameters.Add(parm); ///:12
			parm = new OracleParameter("EndZStand", OracleDbType.Double);       parm.Value = mtr.VolumeEnd;									    cmd.Parameters.Add(parm); ///:13
			/// KorrErrQok bool    true = Q2 within limits,  'passed' in case of Q1, Q3, Q4
            parm = new OracleParameter("KorrErrQ", OracleDbType.Double);        parm.Value = Math.Min(100.0, Math.Max(-100.0, mtr.KorrErrQ));   cmd.Parameters.Add(parm); ///:14
            /// KorrErrQ   double  'Q2 error before correction' when correction done or 'Q2 error' when correction not done
			/// = q2.WaterMeter.Q2CorrectionDone ? q2.WaterMeter.Q2ErrWOCorrection.ToString(Program.AltCulture) : q2.Error.ToString(Program.AltCulture)));
			/// KorrQWz    double
            parm = new OracleParameter("TIZ", OracleDbType.Double);             parm.Value = Math.Min(100000, mtr.TestTime);                    cmd.Parameters.Add(parm); ///:15
			/// Vol_WZ_US
			/// TempMittel_US

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