tbf/TBF/BenchControl/Output/DB/ProductionTracing/Tracing.cs

///
/// Copyright (c) 2018-2019 Sensus Slovensko a.s.
///
using System;
using System.Collections.Generic;
using System.Linq;
using log4net;
using NHibernate;
using NHibernate.Criterion;
using Config.Entities;
using TracingDB.Entities;

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

    class DateTimeComparer : IComparer<DateTime>
    {
        public int Compare(DateTime x, DateTime y)
        {
            return DateTime.Compare(x, y);
        }
    }

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

        public const string WorkstepName = "Test_bench";

        MonitoringCfg tracingCfg;
        string workplace { get { return tracingCfg.Workplace; } }


        enum OpState
        {
            None,
            CheckPreviousRecordsScheduled,
            CheckPreviousRecordsRunning,
            SaveTracingRecordsScheduled,
            SaveTracingRecordsRunning,
        }
        /// 
        OpState currentOpState;
        bool opCompleted;
        bool anyError;


        /// <summary>
        /// Watermeters to check at the beginning of the cycle
        /// </summary>
        Results.Entities.WaterMeter[] waterMeters;

		/// <summary>
		/// Data (tracing records) to write at the end of cycle
		/// </summary>
		Results.Entities.Batch batch;


        ISessionFactory sessionFactory;     /// Factory to create database sessions that is initialized in the constructor
        IList<Process> processes;
        Dictionary<int, Process> processDictionary;
        Dictionary<int, IList<Workstep>> workstepsDictionary;

        ///
        /// Previous workstep verification info
        /// 
        Process currentProcess;			        /// Currently used process
        Workstep currentWorkstep;               /// Currently used workstep of this test bench
        Workstep verifiedWorkstep;
        Part verifiedPart;                      /// Applicable when verifyReferencePart == false
        bool verifyReferencePart;
        

		public Tracing() {}

		public Tracing(Generic.IComponentCfg cfg)
            : base(cfg)
		{
			tracingCfg = cfg as MonitoringCfg;
            if (tracingCfg == null) throw new ArgumentException("tracingCfg");
            currentOpState = OpState.None;
			log.Debug(this.ToString());
		}

        ///
        /// IDevice interface implementation
        ///
        public void Initialize()
        {
			if (tracingCfg.DebugLevel == DebugMode.Simulate) return;

            ///
            /// Session factory is used to create database sessions
            ///
            sessionFactory = FluentNHibernate.Cfg.Fluently.Configure()
                                             .Database(FluentNHibernate.Cfg.Db.MySQLConfiguration.Standard.ConnectionString(tracingCfg.ConnStr))
                                             .Mappings(m => m.FluentMappings.AddFromAssemblyOf<TracingDB.Entities.Process>())
                                             .ExposeConfiguration(TracingDB.DB.BuildSchema)
                                             .BuildSessionFactory();
            ///
            /// Register this test bench in the tracing DB for approx. 2 weeks
            ///
            ISession session = sessionFactory.OpenSession();

            TracingDB.DB.RegisterWorkplace(session,
                                           workplace,
                                           Users.GlobalData.GetCurrentUserName(),
                                           "1.2.3.4",
                                           "<multiple>",
                                           WorkstepName,
                                           DateTime.Now + new TimeSpan(15, 0, 0, 0));
            session.Flush();
            session.Close();
            TracingDB.DB.SessionFactory = sessionFactory;
            if (session != null) session.Dispose();

            currentProcess = null;
        }
        ///
        public void RunDeviceBefore() { }
        public void RunDeviceAfter() { }
        ///
        public void StopDevice()
        {
            if (tracingCfg.DebugLevel == DebugMode.Simulate) return;

            using (ISession session = sessionFactory.OpenSession())
            {
                TracingDB.DB.UnregisterWorkplace(session, workplace);
                session.Flush();
            }
        }
        public void StopDevice2() {}


        /// <summary>
        /// Reads information on start of a cycle,  Events:  Event.InfoRead
        /// </summary>
        /// <param name="waterMeters">Results of water meters</param>
        /// <returns>Reference to the operation</returns>
        public IOperation ReadStartInfoOp(Results.Entities.WaterMeter[] waterMeters)
        {
            if (!tracingCfg.CheckPreviousRecords)
            {
                return null;
            }
            else if ((currentOpState == OpState.CheckPreviousRecordsRunning) || (currentOpState == OpState.SaveTracingRecordsRunning))
            {
                throw new Exception("Sequence error");
            }
            else
            {
                this.waterMeters = waterMeters;
                currentOpState = OpState.CheckPreviousRecordsScheduled;
                return this;
            }
        }

		/// <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)
		{
            if (!tracingCfg.SaveTracingRecords)
            {
                return null;
            }
            else if ((currentOpState == OpState.CheckPreviousRecordsRunning) || (currentOpState == OpState.SaveTracingRecordsRunning))
            {
                throw new Exception("Sequence error");
            }
            else
            {
                this.batch = batch;
                currentOpState = OpState.SaveTracingRecordsScheduled;
                return this;
            }
		}


		/// <summary>Start this operation</summary>
		public void Start()
		{
            if (currentOpState == OpState.CheckPreviousRecordsScheduled)
            {
                currentOpState = OpState.CheckPreviousRecordsRunning;
            }
            else if (currentOpState == OpState.SaveTracingRecordsScheduled)
            {
                currentOpState = OpState.SaveTracingRecordsRunning;
            }

            opCompleted = false;
            anyError = false;
        }

		/// <summary>Run this operation</summary>
		/// <returns>Event.ResultsWritten or Event.Error</returns>
		public Event Run()
		{
            if (currentOpState == OpState.CheckPreviousRecordsRunning)
            {
                if (tracingCfg.DebugLevel == DebugMode.Simulate)
                {
                    return Event.InfoRead;
                }
                else if (!opCompleted)
                {
                    log.WarnFormat("{0} : Run() : currentOp = {1}", Name, currentOpState);
                    opCompleted = true;
                    if (CheckPreviousRecords(waterMeters) != Retv.OK) anyError = true;
                    return anyError ? Event.InfoNotRead : Event.InfoRead;
                }
                else
                {
                    return anyError ? Event.InfoNotRead : Event.InfoRead;
                }
            }
            else if (currentOpState == OpState.SaveTracingRecordsRunning)
            {
                if (tracingCfg.DebugLevel == DebugMode.Simulate || batch.WaterMeters.Count == 0)
                {
                    return Event.ResultsWritten;
                }
                else if (!opCompleted)
                {
                    log.WarnFormat("{0} : Run() : currentOp = {1}", Name, currentOpState);
                    opCompleted = true;
                    if (SaveTracingRecords(batch) != Retv.OK) anyError = true;
                    return anyError ? Event.ResultsNotWritten : Event.ResultsWritten;
                }
                else
                {
                    return anyError ? Event.ResultsNotWritten : Event.ResultsWritten;
                }
            }
            else
            {
                return Event.None;
            }
        }

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


        Retv CheckPreviousRecords(Results.Entities.WaterMeter[] waterMeters)
        {
            Retv retVal = Retv.Error;

            using (ISession session = sessionFactory.OpenSession())
            {
                for (int i = 0; i < waterMeters.Length; i++)
                {
                    Results.Entities.WaterMeter wm = waterMeters[i];

                    if ((wm != null) && !wm.Disabled)
                    {
                        CheckPreviousRecordOfSingleWM(session, wm);
                    }
                }

                retVal = Retv.OK;
            }

            return retVal;
        }

        Retv CheckPreviousRecordOfSingleWM(ISession session, Results.Entities.WaterMeter wm)
        {
            if (string.IsNullOrEmpty(wm.SerialNr))
            {
                /// S/N is missing
                wm.ProcessId = 0;
				wm.LastRecordIsNok = false;		/// OK, this is an RFID comm. error, not a production tracing error
                return Retv.OK;
            }


            ///
            /// Get all already existing reference records with Code == wm.SerialNr, refRecords[0] will be the most recent one
            ///
            ReferenceRecord refRecord = null;
            Workstep workstep = null;
                
            ProjectionList projections = Projections.ProjectionList();
            projections.Add(Projections.Property(() => refRecord.Id));              /// rslt[0] = reference record ID
            projections.Add(Projections.Property(() => workstep.Id));               /// rslt[1] = workstep ID
            projections.Add(Projections.Property(() => refRecord.Process.Id));      /// rslt[2] = process ID
            projections.Add(Projections.Property(() => refRecord.TimeStamp));       /// rslt[3] = reference record time stamp

            ///
            /// Get all reference records with Code == SerialNr from all worksteps different from 'Test_bench'
            ///
            IList<object[]> results = session.QueryOver<ReferenceRecord>(() => refRecord)
                                             .Where(rr => (rr.Code == wm.SerialNr))
                                             .JoinQueryOver<Workstep>(rr => rr.Workstep, () => workstep)
                                             .And(ws => (ws.Name != WorkstepName))
                                             .Select(projections)
                                             .List<object[]>();

            if (results.Count == 0)
            {
                /// No records found
                wm.ProcessId = 0;
				wm.LastRecordIsNok = true;		/// NOK
                                                /// 
                return Retv.OK;
            }

            ///
            /// Get processId of the last record
            /// 
            int processId = 0;
            DateTime lastTimeStamp = DateTime.MinValue;
            foreach (var rslt in results)
            {
                if (DateTime.Compare((DateTime)rslt[3], lastTimeStamp) > 0)
                {
                    lastTimeStamp = (DateTime)rslt[3];
                    processId = (int)rslt[2];
                }
            }

            if (processId == 0) return Retv.Error;  /// This should never happen


            if ((currentProcess == null) || (currentProcess.Id != processId))
            {
                ///
                /// Process changed ==> update currentProcess / currentWorkstep / verifiedWorkstep / verifiedPart / verifyReferencePart
                ///
                var processes = session.QueryOver<Process>()
                                       .Where(p => (p.Id == processId))
                                       .List();

                if (processes.Count != 1) return Retv.Error;

                IList<Workstep> worksteps = session.QueryOver<Workstep>()
                                                   .Where(ws => (ws.Process == processes[0]))
                                                   .And( ws => (ws.Name == WorkstepName))
                                                   .List();

                if (worksteps.Count != 1) return Retv.Error;

                Workstep vWS;
                Part vP;
                bool vRP;
                ///
                if (!TracingDB.DB.AnalyzeProcess(session, processes[0], worksteps[0], out vWS, out vRP, out vP))
                {
                    return Retv.Error;      /// Unable to 
                }

                currentProcess = processes[0];
                currentWorkstep = worksteps[0];
                verifiedWorkstep = vWS;
                verifiedPart = vP;
                verifyReferencePart = vRP;
            }


            wm.ProcessId = currentProcess.Id;
			wm.LastRecordIsNok = true;			    /// NOK (=default if no matching record found)
            foreach (var rslt in results)
            {
                if ((verifiedWorkstep.Id == (int)rslt[1]) && (processId == (int)rslt[2]))
                {
                    /// This record fits verification requirements
					wm.LastRecordIsNok = false;     /// OK
                    break;
                }
            }

            return Retv.OK;
        }


        /// <summary>
        /// Write results of a batch of water meters to the DB
        /// </summary>
        /// <param name="session">DB session</param>
        /// <param name="batch">Batch entity</param>
        Retv SaveTracingRecords(Results.Entities.Batch batch)
		{
            ITransaction transaction = null;
            ISession session = null;
            try
            {
                session = sessionFactory.OpenSession();
                transaction = session.BeginTransaction();

                int writtenRecordsCount = 0;
                foreach (var wMtr in batch.WaterMeters)
                {
                    writtenRecordsCount += SaveSingleWM2DB(session, wMtr);
                }
                transaction.Commit();
                session.Flush();

                log.ErrorFormat("Batch {0}: {1} of {2} watermeters written to production tracing DB",
                                batch.BatchNr, writtenRecordsCount, batch.WaterMeters.Count);

                return Retv.OK;
            }
            catch (Exception exc)
            {
                if (transaction != null && !transaction.WasCommitted) transaction.Rollback();

                log.WarnFormat("Failed to write results of batch {0} to production tracing DB: {1}",
                                batch.BatchNr, exc.Message);

                return Retv.Error;
            }
            finally
            {
                if (session != null)
                {
                    session.Close();
                    session.Dispose();
                }
            }
		}


		/// <summary>
        /// Write one meter results to the DB
		/// </summary>
        /// <param name="session">DB session</param>
        /// <param name="wm">Watermeter entity</param>
        /// <returns>Number of written reference record</returns>
		int SaveSingleWM2DB(ISession session, Results.Entities.WaterMeter wm)
		{
            if (string.IsNullOrEmpty(wm.SerialNr) || (wm.ProcessId == 0))
            {
                /// Without PCB number there is no DB activity
                return 0;
            }
            else if ((currentProcess != null) && (wm.ProcessId == currentProcess.Id))
            {
                /// Process is already loaded => save a reference record for this WM
                session.SaveOrUpdate(new ReferenceRecord(currentProcess, currentWorkstep, wm.SerialNr, Users.GlobalData.CurrentUser.UserName, workplace, wm.Passed ? 0 : 1));
                return 1;
            }
            else if (wm.ProcessId != 0)
            {
                /// Process ID is already known, however process and workstep have to be loaded
                IList<Process> processes = session.QueryOver<Process>()
                                                  .Where(x => (x.Id == wm.ProcessId))
                                                  .List();
                if (processes.Count != 1) return 0;

                foreach (var ws in processes[0].Worksteps)
                {
                    if (ws.Name == WorkstepName)
                    {
                        session.SaveOrUpdate(new ReferenceRecord(processes[0], ws, wm.SerialNr, Users.GlobalData.CurrentUser.UserName, workplace, wm.Passed ? 0 : 1));
                        return 1;
                    }
                }

                return 0;   /// No workste with 'WorkstepName' found
            }
            else
            {
                ///
                /// Process ID is unknown => do everything from scratch
                ///

                /// Get all already existing reference records with Code == wm.SerialNr, refRecords[0] will be the most recent one
                IList<ReferenceRecord> refRecords;
                int trialsCount = 0;
                do
                {
                    if (trialsCount > 0) ReadProcessesFromDB(session);

                    refRecords = session.QueryOver<ReferenceRecord>()
                                        .Where(rr => (rr.Code == wm.SerialNr))
                                        .OrderBy(rr => rr.TimeStamp).Desc
                                        .List();
                    trialsCount++;
                }
                while (refRecords.Count == 0 && trialsCount <= 2);

                /// Save a new reference record from this test bench if workstep "Test_bench" is defined in the obtained WM process
                IList<Workstep> worksteps;
                if ((refRecords.Count > 0) && workstepsDictionary.TryGetValue(refRecords[0].Process.Id, out worksteps) && (worksteps.Count == 1))
                {
                    session.SaveOrUpdate(new ReferenceRecord(refRecords[0].Process, worksteps[0], wm.SerialNr, Users.GlobalData.CurrentUser.UserName, workplace, wm.Passed ? 0 : 1));
                    return 1;
                }

                return 0;
            }
		}


        /// <summary>
        /// Updates processes, processDictionary and workstepsDictionary
        /// </summary>
        /// <param name="session">DB session</param>
        void ReadProcessesFromDB(ISession session)
        {
            processes = session.QueryOver<Process>()
                               .List();

            processDictionary = new Dictionary<int, Process>();
            workstepsDictionary = new Dictionary<int, IList<Workstep>>();
            ///
            foreach (var pr in processes)
            {
                IList<Workstep> worksteps = session.QueryOver<Workstep>()
                                                   .Where(ws => ((ws.Process == pr) && (ws.Name == WorkstepName)))
                                                   .List();
                processDictionary.Add(pr.Id, pr);
                workstepsDictionary.Add(pr.Id, worksteps);
            }
        }
    }
}