MonitoringDB project (class library) added.

.gitignore

@@ -6,6 +6,8 @@ Dirichlet.Numerics/bin
 Dirichlet.Numerics/obj
 GraphLib/bin
 GraphLib/obj
+MonitoringDB/bin
+MonitoringDB/obj
 Results/bin/
 Results/obj/
 ResultsBrowser/bin/

MonitoringDB/Entities/Part.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+
+namespace MonitoringDB.Entities
+{
+    public class Part
+    {
+        public virtual int Id { get; protected set; }
+        public virtual string Name { get; set; }
+        public virtual string OraDBType { get; set; }
+        public virtual string Description { get; set; }
+		public virtual CodeType CodeType { get; set; }
+        public virtual CodeForm CodeForm { get; set; }
+		public virtual CodeLocation CodeLocation { get; set; }
+		public virtual LifetimeManagement LifetimeManagement { get; set; }
+		public virtual int StepNumber { get; set; }
+
+		public virtual Process Process { get; set; }
+		public virtual Workstep Workstep { get; set; }
+
+
+		protected Part()
+		{
+            Name = string.Empty;
+            Description = string.Empty;
+        }
+
+		/// <summary>
+		/// Constructor used when the part is added to a process
+		/// </summary>
+		/// <param name="name"></param>
+		/// <param name="codeType"></param>
+		/// <param name="codeForm"></param>
+		/// <param name="process"></param>
+		public Part(string name, Process process, CodeType codeType, CodeForm codeForm, CodeLocation codeLocation)
+		{
+            Name = name;
+            OraDBType = string.Empty;
+			Description = string.Empty;
+			CodeType = codeType;
+			CodeForm = codeForm;
+			CodeLocation = codeLocation;
+			StepNumber = 0;
+
+			Process = process;
+			Workstep = null;
+		}
+
+        /// <summary>
+        /// Create a copy of a part (1) belongig to another process, (2) not assigned to any workstep yet.
+        /// </summary>
+        /// <param name="process">Process owning the cloned part</param>
+        /// <returns>Cloned part</returns>
+		public virtual Part Clone(Process owningProcess)
+		{
+			Part rslt = new Part(Name, owningProcess, CodeType, CodeForm, CodeLocation);
+            rslt.OraDBType = OraDBType;
+            rslt.Description = Description;
+			rslt.LifetimeManagement = LifetimeManagement;
+			return rslt;
+		}
+
+		public override string ToString()
+		{
+            return string.Format("{0} step={1} ({2})", Name, StepNumber, Description);
+		}
+    }
+}

MonitoringDB/Entities/Process.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+
+namespace MonitoringDB.Entities
+{
+    public class Process
+    {
+        public virtual int Id { get; protected set; }
+        public virtual int ItemNr { get; set; }
+        public virtual string Name { get; set; }
+		public virtual string Description { get; set; }
+		public virtual ReleaseStatus ReleaseStatus { get; set; }
+		public virtual DateTime TimeStamp { get; set; }
+		public virtual string UserName { get; set; }
+
+		public virtual IList<Part> Parts { get; set; }
+		public virtual IList<Workstep> Worksteps { get; set; }
+
+		/// <summary>
+		/// Default (private) constructor inicializing lists
+		/// </summary>
+		protected Process()
+		{
+			Parts = new List<Part>();
+			Worksteps = new List<Workstep>();
+		}
+
+		/// <summary>
+		/// Constructor used when this process is created
+		/// </summary>
+		/// <param name="name"></param>
+		public Process(string name)
+			: this()
+		{
+			Name = name;
+			Description = string.Empty;
+			ReleaseStatus = ReleaseStatus.In_preparation;
+			TimeStamp = DateTime.Now;
+			UserName = "admin";
+		}
+
+        /// <summary>
+        /// Create a copy of a process with a new name
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+		public virtual Process Clone(string name)
+		{
+			Process rslt = new Process(name);
+			rslt.Description = Description;
+
+			foreach (var part in Parts) rslt.Parts.Add(part.Clone(rslt));
+			foreach (var workstep in Worksteps) rslt.Worksteps.Add(workstep.Clone(rslt));
+
+			return rslt;
+		}
+
+		public override string ToString()
+		{
+			return string.Format("{0} '{1}' ({2}) {3} {4}",
+								 ItemNr,
+								 Name,
+								 TimeStamp.Date.ToShortDateString(),
+								 (Description == null) ? string.Empty : Description,
+								 ReleaseStatus);
+		}
+    }
+}

MonitoringDB/Entities/Record.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+
+namespace MonitoringDB.Entities
+{
+    public class Record
+    {
+        public virtual int Id { get; protected set; }
+        public virtual string Code { get; set; }
+		public virtual DateTime TimeStamp { get; set; }
+
+		public virtual Part Part { get; set; }
+		public virtual ReferenceRecord ReferenceRecord { get; set; }
+
+
+		protected Record()
+		{
+		}
+
+		/// <summary>
+		/// Constructor used when a part barcode is scanned
+		/// </summary>
+		/// <param name="partId">Part</param>
+		/// <param name="referenceRecordId">Reference record</param>
+		/// <param name="code">Scanned barcode</param>
+		public Record(Part part, ReferenceRecord referenceRecord, string code)
+		{
+			Part = part;
+			ReferenceRecord = referenceRecord;
+			Code = code;
+			TimeStamp = DateTime.Now;
+		}
+
+        /// <summary>
+        /// Create a copy of a process with a new name
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public virtual Record Clone(Process newProcess, ReferenceRecord newRR)
+        {
+            Part newPart = null;
+            foreach (var pt in newProcess.Parts)
+            {
+                if (Part.Name == pt.Name)
+                {
+                    newPart = pt;
+                    break;
+                }
+            }
+            Record rslt = new Record(newPart, newRR, Code);
+            rslt.TimeStamp = TimeStamp;
+
+            return rslt;
+        }
+
+		public override string ToString()
+		{
+            return string.Format("code={0}  part={1}  description='{2}'", Code, Part.Name, Part.Description);
+		}
+	}
+}

MonitoringDB/Entities/ReferenceRecord.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+
+namespace MonitoringDB.Entities
+{
+    public class ReferenceRecord
+    {
+        public virtual int Id { get; protected set; }
+		public virtual string Code { get; set; }
+		public virtual DateTime TimeStamp { get; set; }
+		public virtual string UserName { get; set; }
+		public virtual string Workplace { get; set; }
+		public virtual int Result { get; set; }			/// 0 = No error (OK), >0 = Error code
+
+		public virtual Process Process { get; set; }
+		public virtual Workstep Workstep { get; set; }
+		public virtual IList<Record> Records { get; set; }
+
+
+		/// <summary>
+		/// Default (private) constructor inicializing lists
+		/// </summary>
+		protected ReferenceRecord()
+		{
+			Records = new List<Record>();
+		}
+
+		/// <summary>
+		/// Constructor used when reference barcode is scanned
+		/// </summary>
+		/// <param name="process">Process</param>
+		/// <param name="workstep">Workstep</param>
+		/// <param name="code">Scanned barcode</param>
+		public ReferenceRecord(Process process, Workstep workstep, string code,
+							   string userName, string workplace, int result)
+		{
+			Process = process;
+			Workstep = workstep;
+			Code = code;
+			TimeStamp = DateTime.Now;
+			UserName = userName;
+			Workplace = workplace;
+			Result = result;
+        }
+
+        /// <summary>
+        /// Create a copy of a process with a new name
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public virtual ReferenceRecord Clone(Process newProcess)
+        {
+            Workstep newWorkstep = null;
+            foreach (var ws in newProcess.Worksteps)
+            {
+                if (Workstep.Name == ws.Name)
+                {
+                    newWorkstep = ws;
+                    break;
+                }
+            }
+
+            ReferenceRecord rslt = new ReferenceRecord(newProcess, newWorkstep,
+                                                       Code, UserName, Workplace, Result);
+            rslt.TimeStamp = TimeStamp;
+
+            rslt.Records = new List<Record>();
+            foreach (var record in Records)
+            {
+                rslt.Records.Add(record.Clone(newProcess, rslt));
+            }
+
+            return rslt;
+        }
+
+		public override string ToString()
+		{
+            return string.Format("code={0}  part={1}  description='{2}'  step='{3}'  workplace='{4}'  user={5}  time={6:dd.MM.yyyy HH:mm:ss}",
+                                 (Code != null) ? Code : "<none>",
+                                 Workstep.ReferencePart.Name,
+                                 Workstep.ReferencePart.Description,
+                                 Workstep.Name,
+                                 Workplace,
+                                 UserName,
+                                 TimeStamp);
+		}
+    }
+}

MonitoringDB/Entities/Workstep.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+
+namespace MonitoringDB.Entities
+{
+    public class Workstep
+    {
+        public virtual int Id { get; protected set; }
+        public virtual int WorkstepNr { get; set; }
+        public virtual string Name { get; set; }
+		public virtual string Description { get; set; }
+        public virtual int CheckPartNr { get; set; }
+        public virtual bool AllowRepairs { get; set; }
+
+		public virtual Process Process { get; set; }
+		public virtual Part ReferencePart { get; set; }
+		public virtual IList<Part> Parts { get; set; }
+
+
+		/// <summary>
+		/// Default (private) constructor inicializing a list
+		/// </summary>
+		protected Workstep()
+		{
+			Parts = new List<Part>();
+		}
+
+		/// <summary>
+		/// Constructor used when this workstep is added to a process
+		/// </summary>
+		/// <param name="name">Workstep name</param>
+		/// <param name="process">Process to be referenced</param>
+		public Workstep(int workstepNr, string name, Process process)
+			: this()
+		{
+            WorkstepNr = workstepNr;
+			Name = name;
+			Description = string.Empty;
+            CheckPartNr = 0;
+            AllowRepairs = false;
+			Process = process;
+			ReferencePart = null;
+		}
+
+		public virtual Workstep Clone(Process owningProcess)
+		{
+			Workstep rslt = new Workstep(WorkstepNr, Name, owningProcess);
+			rslt.Description = Description;
+            rslt.CheckPartNr = CheckPartNr;
+            rslt.AllowRepairs = AllowRepairs;
+
+			if (ReferencePart != null)
+			{
+				foreach (var p in owningProcess.Parts)
+				{
+					if (p.Name == ReferencePart.Name) rslt.ReferencePart = p;
+				}
+			}
+
+			foreach (var srcP in Parts)
+			{
+				foreach (var p in owningProcess.Parts)
+				{
+					if (p.Name == srcP.Name)
+					{
+						rslt.Parts.Add(p);
+						p.StepNumber = srcP.StepNumber;
+						p.Workstep = rslt;
+					}
+				}
+			}
+
+			return rslt;
+		}
+
+		public override string ToString()
+		{
+			//return string.Format("{0} {1} ({2}) Ref: {3}", WorkstepNr, Name, Description, (ReferencePart != null) ? ReferencePart.Name : "none");
+            return string.Format("{0}: {1}", WorkstepNr, Name);
+        }
+    }
+}

MonitoringDB/Enums.cs

@@ -0,0 +1,93 @@
+namespace MonitoringDB
+{
+    public enum CodeType
+    {
+        UniqueNr,
+        FlowtubeNr,                 /// prvé 3 znaky sa zhodujú s poslednými 3 znakmi názvu
+        FlowtubeNrLU,               /// začiatok kódu sa zhoduje s názvom
+        BatchNr,
+        BatchNrContainingPartName,
+        DateMMYY,
+		QualityCheck,
+    }
+
+    public enum CodeForm
+    {
+        Barcode,
+        QRCode,
+		Keyboard,
+		OkNok,
+    }
+
+	public enum CodeLocation
+	{
+		OnPart,
+		OnPallet,
+	}
+
+	public enum LifetimeManagement
+	{
+		None,
+		OneYear,
+		Count,
+	}
+
+	public enum ReleaseStatus
+	{
+		In_preparation,
+		Released,
+		ReleasedActive,
+		Deactivated,
+		Count,
+	}
+
+	public enum Mode
+	{
+		Debug,			// Debug mode - no Oracle database used
+		Test,			// Test database used
+		Production,		// Production database used
+		Count,
+	}
+
+    public enum LoginLevel
+    {
+        None,
+        TeamLeader,
+        Administrator,
+        Count,
+    }
+
+    public enum ItemSpecID
+    {
+        RefRecordID = 0,
+
+        TimeStamp,
+        Workstep,
+        Workplace,
+        UserName,
+        Barcode,
+        PartBarcode,
+
+        TimeStamp2,
+        Workstep2,
+        Workplace2,
+        UserName2,
+        Barcode2,
+        PartBarcode2,
+
+        SerialNr,
+        PurchaseOrder,
+        TestResult,
+        MaxPruefindex,
+        
+        Process,
+    }
+
+    public enum ItemSpecCaps
+    {
+        None = 0,
+        ReferenceRecord = 1,
+        AssociatedRecord = 2,
+        OracleQuery = 4,
+    }
+}

MonitoringDB/FluentNH.cs

@@ -0,0 +1,212 @@
+using System;
+using System.Collections.Generic;
+using FluentNHibernate.Cfg;
+using FluentNHibernate.Cfg.Db;
+using NHibernate;
+using NHibernate.Cfg;
+using NHibernate.Tool.hbm2ddl;
+
+namespace MonitoringDB
+{
+    public static class FluentNH
+    {
+		/// <summary>
+		/// Current session factory for the last used connection string or null
+		/// </summary>
+		public static ISessionFactory SessionFactory;
+
+
+        /// <summary> Connection string for all sessions </summary>
+        static string connectionString;
+        /// 
+        public static string ConnectionString
+        {
+            get { return connectionString; }
+            set
+            {
+                if (value != connectionString)
+                {
+                    connectionString = value;
+                    SessionFactory = null;          /// Clear SessionFactory on connection string change
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// NHibernate session factory (to create the database session 'SessionFactory')
+        /// </summary>
+        /// <returns>A database session</returns>
+		static ISessionFactory CreateSessionFactory()
+        {
+			return CreateSessionFactory(false);
+		}
+
+        /// <summary>
+        /// NHibernate session factory (to create the database session 'SessionFactory')
+        /// </summary>
+        /// <returns>A database session</returns>
+		public static ISessionFactory CreateSessionFactory(bool createDB)
+        {
+			FluentConfiguration cfg = Fluently
+				.Configure()
+				.Database(MySQLConfiguration.Standard.ConnectionString(connectionString))
+				.Mappings(m => m.FluentMappings.AddFromAssemblyOf<Entities.Process>());
+
+			if (createDB)
+            {
+                return cfg.ExposeConfiguration(BuildSchemaCreate).BuildSessionFactory();
+            }
+            else
+            {
+                return cfg.ExposeConfiguration(BuildSchema).BuildSessionFactory();
+            }
+        }
+
+        public delegate void BuildSchemaDlgt(Configuration config);
+
+        static void BuildSchema(Configuration config)
+        {
+            /// This NHibernate tool takes a configuration (with mapping info in)
+            /// and exports a database schema from it
+            new SchemaExport(config).SetOutputFile("db_schema");
+        }
+
+        static void BuildSchemaCreate(Configuration config)
+        {
+            /// This NHibernate tool takes a configuration (with mapping info in)
+            /// and exports a database schema from it
+            new SchemaExport(config).Create(true, true);
+        }
+
+		/// Create a NHibernate session for the given database
+		public static ISession CreateSession(string connectionString)
+		{
+            ConnectionString = connectionString;    /// Clears session factory on connction string change
+
+			if (SessionFactory == null)
+                SessionFactory = CreateSessionFactory();
+
+			return SessionFactory.OpenSession();
+		}
+
+
+        /// <summary>
+        /// Create an empty database.
+		/// Database contains only the user 'admin' and the control board component 'CB'.
+        /// </summary>
+        /// <param name="dbType">DBType.SQLite or DBType.MySql</param>
+        /// <param name="connectionString">Connection string</param>
+        /// <returns>true=success, false=error</returns>
+        public static bool CreateEmptyDB(string connectionString)
+        {
+            ConnectionString = connectionString;
+
+			ISessionFactory sessionFactory = CreateSessionFactory(true);
+            if (sessionFactory == null) return false;
+
+            /// Populate the database
+            using (var session = sessionFactory.OpenSession())
+            {
+				//using (var transaction = session.BeginTransaction())
+				//{
+				//    var part1 = new MonitoringDB.Entities.Part("flow tube", CodeType.UniqueNr, CodeForm.QRCode, 0);
+				//    session.SaveOrUpdate(part1);
+				//    transaction.Commit();
+				//}
+            }
+
+            return true;
+        }
+
+
+		public static IList<WMPart> FindWMParts(string pcbNumber, string connString)
+		{
+			IList<WMPart> foundParts = new List<WMPart>();				/// initially empty
+
+			if (string.IsNullOrEmpty(pcbNumber)) return foundParts;		/// return an empty list
+
+			try
+			{
+				ISession session = CreateSession(connString);
+
+				IList<Entities.ReferenceRecord> referenceRecords = session
+					.QueryOver<Entities.ReferenceRecord>()
+					.Where(x => (x.Code == pcbNumber))
+					.OrderBy(x => x.TimeStamp).Desc
+					.List<Entities.ReferenceRecord>();
+
+				if (referenceRecords.Count == 0) return foundParts;
+
+				foundParts.Add(new WMPart(referenceRecords[0]));
+				Entities.Process process = referenceRecords[0].Process;
+				///
+				foreach (var refR in referenceRecords)
+				{
+					if (process != refR.Process)
+					{
+						continue;	/// skip records obtained by another process
+					}
+
+					IList<Entities.Record> relatedRecords = session
+						.QueryOver<Entities.Record>()
+						.Where(x => (x.ReferenceRecord == refR))
+						.List<Entities.Record>();
+
+
+					foreach (var relR in relatedRecords)
+					{
+						foundParts.Add(new WMPart(relR));
+						foreach (var ws in process.Worksteps)
+						{
+							if (ws.ReferencePart == relR.Part)
+							{
+								FindWMPartsRecursively(process, ws.ReferencePart, relR.Code, session, ref foundParts);
+							}
+						}
+					}
+				}
+			}
+			catch
+			{
+			}
+
+			return foundParts;
+		}
+
+
+		static void FindWMPartsRecursively(Entities.Process process, Entities.Part refPart, string code, ISession session, ref IList<WMPart> foundParts)
+		{
+			IList<Entities.ReferenceRecord> referenceRecords = session
+				.QueryOver<Entities.ReferenceRecord>()
+				.Where(x => (x.Workstep.ReferencePart == refPart))
+				.Where(x => (x.Code == code))
+				.OrderBy(x => x.TimeStamp).Desc
+				.List<Entities.ReferenceRecord>();
+
+			if (referenceRecords.Count == 0) return;
+
+			foreach (var refR in referenceRecords)
+			{
+				IList<Entities.Record> relatedRecords = session
+					.QueryOver<Entities.Record>()
+					.Where(x => (x.ReferenceRecord == refR))
+					.List<Entities.Record>();
+
+
+				foreach (var relR in relatedRecords)
+				{
+					foundParts.Add(new WMPart(relR));
+
+					foreach (var ws in process.Worksteps)
+					{
+						if (ws.ReferencePart == relR.Part)
+						{
+							FindWMPartsRecursively(process, ws.ReferencePart, relR.Code, session, ref foundParts);
+						}
+					}
+				}
+			}
+		}
+    }
+}

MonitoringDB/Forms/ListViewEx.cs

@@ -0,0 +1,456 @@
+///
+/// Copyright (c) 2016 Sensus Metering Systems
+///
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+
+namespace MonitoringDB.Forms
+{
+	/// <summary>
+	/// Event Handler for SubItem events
+	/// </summary>
+	public delegate void SubItemEventHandler(object sender, SubItemEventArgs e);
+	/// <summary>
+	/// Event Handler for SubItemEndEditing events
+	/// </summary>
+	public delegate void SubItemEndEditingEventHandler(object sender, SubItemEndEditingEventArgs e);
+
+
+	///	<summary>
+	///	Inherited ListView to allow in-place editing of subitems
+	///	</summary>
+	public class ListViewEx	: System.Windows.Forms.ListView
+	{
+		#region Interop structs, imports and constants
+		/// <summary>
+		/// MessageHeader for WM_NOTIFY
+		/// </summary>
+		private struct NMHDR 
+		{ 
+#pragma warning disable
+			public IntPtr hwndFrom; 
+			public Int32  idFrom; 
+			public Int32  code;
+#pragma warning restore
+        }
+
+
+		[DllImport("user32.dll")]
+		private	static extern IntPtr SendMessage(IntPtr hWnd, int msg,	IntPtr wPar, IntPtr	lPar);
+		[DllImport("user32.dll", CharSet=CharSet.Ansi)]
+		private	static extern IntPtr SendMessage(IntPtr	hWnd, int msg, int len,	ref	int	[] order);
+
+		// ListView messages
+		private const int LVM_FIRST					= 0x1000;
+		private const int LVM_GETCOLUMNORDERARRAY	= (LVM_FIRST + 59);
+
+		// Windows Messages that will abort editing
+		private	const int WM_HSCROLL = 0x114;
+		private	const int WM_VSCROLL = 0x115;
+		private const int WM_SIZE	 = 0x05;
+		private const int WM_NOTIFY	 = 0x4E;
+
+		private const int HDN_FIRST = -300;
+		private const int HDN_BEGINDRAG = (HDN_FIRST-10);
+		private const int HDN_ITEMCHANGINGA = (HDN_FIRST-0);
+		private const int HDN_ITEMCHANGINGW = (HDN_FIRST-20);
+		#endregion
+
+		///	<summary>
+		///	Required designer variable.
+		///	</summary>
+		private	System.ComponentModel.Container	components = null;
+
+		public event SubItemEventHandler SubItemClicked;
+		public event SubItemEventHandler SubItemBeginEditing;
+		public event SubItemEndEditingEventHandler SubItemEndEditing;
+
+		public ListViewEx()
+		{
+			// This	call is	required by	the	Windows.Forms Form Designer.
+			InitializeComponent();
+
+			base.FullRowSelect = true;
+			base.View = View.Details;
+			base.AllowColumnReorder = true;
+		}
+
+		///	<summary>
+		///	Clean up any resources being used.
+		///	</summary>
+		protected override void	Dispose( bool disposing	)
+		{
+			if(	disposing )
+			{
+				if(	components != null )
+					components.Dispose();
+			}
+			base.Dispose( disposing	);
+		}
+
+		#region Component	Designer generated code
+		///	<summary>
+		///	Required method	for	Designer support - do not modify 
+		///	the	contents of	this method	with the code editor.
+		///	</summary>
+		private	void InitializeComponent()
+		{
+			components = new System.ComponentModel.Container();
+		}
+	  #endregion
+
+		private bool _doubleClickActivation = false;
+		/// <summary>
+		/// Is a double click required to start editing a cell?
+		/// </summary>
+		public bool DoubleClickActivation
+		{
+			get {  return _doubleClickActivation; }
+			set { _doubleClickActivation = value; }    
+		}
+
+
+		/// <summary>
+		/// Retrieve the order in which columns appear
+		/// </summary>
+		/// <returns>Current display order of column indices</returns>
+		public int[] GetColumnOrder()
+		{
+			IntPtr lPar	= Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * Columns.Count);
+
+			IntPtr res = SendMessage(Handle, LVM_GETCOLUMNORDERARRAY, new IntPtr(Columns.Count), lPar);
+			if (res.ToInt32() == 0)	// Something went wrong
+			{
+				Marshal.FreeHGlobal(lPar);
+				return null;
+			}
+
+			int	[] order = new int[Columns.Count];
+			Marshal.Copy(lPar, order, 0, Columns.Count);
+
+			Marshal.FreeHGlobal(lPar);
+
+			return order;
+		}
+
+
+		/// <summary>
+		/// Find ListViewItem and SubItem Index at position (x,y)
+		/// </summary>
+		/// <param name="x">relative to ListView</param>
+		/// <param name="y">relative to ListView</param>
+		/// <param name="item">Item at position (x,y)</param>
+		/// <returns>SubItem index</returns>
+		public int GetSubItemAt(int x, int y, out ListViewItem item)
+		{
+			item = this.GetItemAt(x, y);
+		
+			if (item !=	null)
+			{
+				int[] order = GetColumnOrder();
+				Rectangle lviBounds;
+				int	subItemX;
+
+				lviBounds =	item.GetBounds(ItemBoundsPortion.Entire);
+				subItemX = lviBounds.Left;
+				for (int i=0; i<order.Length; i++)
+				{
+					ColumnHeader h = this.Columns[order[i]];
+					if (x <	subItemX+h.Width)
+					{
+						return h.Index;
+					}
+					subItemX += h.Width;
+				}
+			}
+			
+			return -1;
+		}
+
+
+		/// <summary>
+		/// Get bounds for a SubItem
+		/// </summary>
+		/// <param name="Item">Target ListViewItem</param>
+		/// <param name="SubItem">Target SubItem index</param>
+		/// <returns>Bounds of SubItem (relative to ListView)</returns>
+		public Rectangle GetSubItemBounds(ListViewItem Item, int SubItem)
+		{
+			int[] order = GetColumnOrder();
+
+			Rectangle subItemRect = Rectangle.Empty;
+			if (SubItem >= order.Length)
+				throw new IndexOutOfRangeException("SubItem "+SubItem+" out of range");
+
+			if (Item == null)
+				throw new ArgumentNullException("Item");
+			
+			Rectangle lviBounds = Item.GetBounds(ItemBoundsPortion.Entire);
+			int	subItemX = lviBounds.Left;
+
+			ColumnHeader col;
+			int i;
+			for (i=0; i<order.Length; i++)
+			{
+				col = this.Columns[order[i]];
+				if (col.Index == SubItem)
+					break;
+				subItemX += col.Width;
+			} 
+			subItemRect	= new Rectangle(subItemX, lviBounds.Top, this.Columns[order[i]].Width, lviBounds.Height);
+			return subItemRect;
+		}
+
+
+		protected override void	WndProc(ref	Message	msg)
+		{
+			switch (msg.Msg)
+			{
+				// Look	for	WM_VSCROLL,WM_HSCROLL or WM_SIZE messages.
+				case WM_VSCROLL:
+				case WM_HSCROLL:
+				case WM_SIZE:
+					EndEditing(false);
+					break;
+				case WM_NOTIFY:
+					// Look for WM_NOTIFY of events that might also change the
+					// editor's position/size: Column reordering or resizing
+					NMHDR h = (NMHDR)Marshal.PtrToStructure(msg.LParam, typeof(NMHDR));
+					if (h.code == HDN_BEGINDRAG ||
+						h.code == HDN_ITEMCHANGINGA ||
+						h.code == HDN_ITEMCHANGINGW)
+						EndEditing(false);
+					break;
+			}
+
+			base.WndProc(ref msg);
+		}
+
+
+		#region Initialize editing depending of DoubleClickActivation property
+		protected override void OnMouseUp(System.Windows.Forms.MouseEventArgs e)
+		{
+			base.OnMouseUp(e);
+
+			if (DoubleClickActivation)
+			{
+				return;
+			} 
+
+			EditSubitemAt(new Point(e.X, e.Y));
+		}
+		
+		protected override void OnDoubleClick(EventArgs e)
+		{
+			base.OnDoubleClick (e);
+
+			if (!DoubleClickActivation)
+			{
+				return;
+			} 
+
+			Point pt = this.PointToClient(Cursor.Position);
+		
+			EditSubitemAt(pt);
+		}
+
+		///<summary>
+		/// Fire SubItemClicked
+		///</summary>
+		///<param name="p">Point of click/doubleclick</param>
+		private void EditSubitemAt(Point p)
+		{
+			ListViewItem item;
+			int idx = GetSubItemAt(p.X, p.Y, out item);
+			if (idx >= 0)
+			{
+				OnSubItemClicked(new SubItemEventArgs(item, idx));
+			}
+		}
+
+		#endregion
+
+		#region In-place editing functions
+		// The control performing the actual editing
+		private Control _editingControl;
+		// The LVI being edited
+		private ListViewItem _editItem;
+		// The SubItem being edited
+		private int _editSubItem;
+
+		protected void OnSubItemBeginEditing(SubItemEventArgs e)
+		{
+			if (SubItemBeginEditing != null) SubItemBeginEditing(this, e);
+		}
+
+		protected void OnSubItemEndEditing(SubItemEndEditingEventArgs e)
+		{
+			if (SubItemEndEditing != null) SubItemEndEditing(this, e);
+		}
+
+		protected void OnSubItemClicked(SubItemEventArgs e)
+		{
+			if (SubItemClicked != null) SubItemClicked(this, e);
+		}
+
+
+		/// <summary>
+		/// Begin in-place editing of given cell
+		/// </summary>
+		/// <param name="c">Control used as cell editor</param>
+		/// <param name="Item">ListViewItem to edit</param>
+		/// <param name="SubItem">SubItem index to edit</param>
+		public void StartEditing(Control c, ListViewItem Item, int SubItem)
+		{
+			OnSubItemBeginEditing(new SubItemEventArgs(Item, SubItem));
+
+			Rectangle rcSubItem = GetSubItemBounds(Item, SubItem);
+
+			if (rcSubItem.X < 0)
+			{
+				// Left edge of SubItem not visible - adjust rectangle position and width
+				rcSubItem.Width += rcSubItem.X;
+				rcSubItem.X=0;
+			}
+			if (rcSubItem.X+rcSubItem.Width > this.Width)
+			{
+				// Right edge of SubItem not visible - adjust rectangle width
+				rcSubItem.Width = this.Width-rcSubItem.Left;
+			}
+
+			// Subitem bounds are relative to the location of the ListView!
+			rcSubItem.Offset(Left, Top);
+
+			// In case the editing control and the listview are on different parents,
+			// account for different origins
+			Point origin = new Point(0,0);
+			Point lvOrigin  = this.Parent.PointToScreen(origin);
+			Point ctlOrigin  = c.Parent.PointToScreen(origin);
+
+			rcSubItem.Offset(lvOrigin.X-ctlOrigin.X, lvOrigin.Y-ctlOrigin.Y);
+
+			// Position and show editor
+			c.Bounds = rcSubItem;
+			c.Text = Item.SubItems[SubItem].Text;
+			c.Visible = true;
+			c.BringToFront();
+			c.Focus();
+
+			_editingControl = c;
+			_editingControl.Leave += new EventHandler(_editControl_Leave);
+			_editingControl.KeyPress += new KeyPressEventHandler(_editControl_KeyPress);
+
+			_editItem = Item;
+			_editSubItem = SubItem;
+		}
+
+
+		private void _editControl_Leave(object sender, EventArgs e)
+		{
+			// cell editor losing focus
+			EndEditing(true);
+		}
+
+		private void _editControl_KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e)
+		{
+			switch (e.KeyChar)
+			{
+				case (char)(int)Keys.Escape:
+				{
+					EndEditing(false);
+					break;
+				}
+
+				case (char)(int)Keys.Enter:
+				{  
+					EndEditing(true);
+					break;
+				}
+			}
+		}
+
+		/// <summary>
+		/// Accept or discard current value of cell editor control
+		/// </summary>
+		/// <param name="AcceptChanges">Use the _editingControl's Text as new SubItem text or discard changes?</param>
+		public void EndEditing(bool AcceptChanges)
+		{
+			if (_editingControl == null)
+				return;
+
+			SubItemEndEditingEventArgs e = new SubItemEndEditingEventArgs(
+				_editItem,		// The item being edited
+				_editSubItem,	// The subitem index being edited
+				AcceptChanges ?
+					_editingControl.Text :	// Use editControl text if changes are accepted
+					_editItem.SubItems[_editSubItem].Text,	// or the original subitem's text, if changes are discarded
+				!AcceptChanges	// Cancel?
+			);
+
+			OnSubItemEndEditing(e);
+
+			_editItem.SubItems[_editSubItem].Text = e.DisplayText;
+
+			_editingControl.Leave -= new EventHandler(_editControl_Leave);
+			_editingControl.KeyPress -= new KeyPressEventHandler(_editControl_KeyPress);
+
+			_editingControl.Visible = false;
+
+			_editingControl = null;
+			_editItem = null;
+			_editSubItem = -1;
+		}
+		#endregion
+	}
+
+	
+	/// <summary>
+	/// Event Args for SubItemClicked event
+	/// </summary>
+	public class SubItemEventArgs : EventArgs
+	{
+        int subItem = -1;     /// Sub-item index
+        ListViewItem item = null;
+
+        public int SubItem { get { return subItem; } }
+        public ListViewItem Item { get { return item; } }
+
+        public SubItemEventArgs(ListViewItem item, int subItem)
+		{
+			this.subItem = subItem;
+			this.item = item;
+		}
+	}
+
+
+	/// <summary>
+	/// Event Args for SubItemEndEditingClicked event
+	/// </summary>
+	public class SubItemEndEditingEventArgs : SubItemEventArgs
+	{
+		string displayText = string.Empty;
+		bool cancel = true;
+
+		public SubItemEndEditingEventArgs(ListViewItem item, int subItem, string displayText, bool cancel) :
+			base(item, subItem)
+		{
+			this.displayText = displayText;
+			this.cancel = cancel;
+		}
+		public string DisplayText
+		{
+			get { return displayText; }
+			set { displayText = value; }
+		}
+		public bool Cancel
+		{
+			get { return cancel; }
+			set { cancel = value; }
+		}
+	}
+}

MonitoringDB/Forms/ListViewEx.resx

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<root>
+	<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+		<xsd:element name="root" msdata:IsDataSet="true">
+			<xsd:complexType>
+				<xsd:choice maxOccurs="unbounded">
+					<xsd:element name="data">
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+								<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+							</xsd:sequence>
+							<xsd:attribute name="name" type="xsd:string" />
+							<xsd:attribute name="type" type="xsd:string" />
+							<xsd:attribute name="mimetype" type="xsd:string" />
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="resheader">
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+							</xsd:sequence>
+							<xsd:attribute name="name" type="xsd:string" use="required" />
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:choice>
+			</xsd:complexType>
+		</xsd:element>
+	</xsd:schema>
+	<resheader name="ResMimeType">
+		<value>text/microsoft-resx</value>
+	</resheader>
+	<resheader name="Version">
+		<value>1.0.0.0</value>
+	</resheader>
+	<resheader name="Reader">
+		<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=1.0.3102.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+	</resheader>
+	<resheader name="Writer">
+		<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=1.0.3102.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+	</resheader>
+</root>

MonitoringDB/Forms/ModelessForm.Designer.cs

@@ -0,0 +1,64 @@
+namespace MonitoringDB.Forms
+{
+    partial class ModelessForm
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.label1 = new System.Windows.Forms.Label();
+            this.SuspendLayout();
+            // 
+            // label1
+            // 
+            this.label1.AutoSize = true;
+            this.label1.Location = new System.Drawing.Point(47, 29);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(35, 13);
+            this.label1.TabIndex = 0;
+            this.label1.Text = "label1";
+            // 
+            // ModelessForm
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(191, 56);
+            this.Controls.Add(this.label1);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
+            this.Name = "ModelessForm";
+            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
+            this.Text = "ModelessForm";
+            this.Load += new System.EventHandler(this.ModelessForm_Load);
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.Label label1;
+    }
+}

MonitoringDB/Forms/ModelessForm.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Drawing;
+using System.Windows.Forms;
+
+namespace MonitoringDB.Forms
+{
+    public partial class ModelessForm : Form
+    {
+        /// <summary>
+        /// Called from the state machine when an operation forces a modeless dialog close.
+        /// </summary>
+        public static void CloseForm()
+        {
+            if (CloseFormHandler == null) return;
+            try { CloseFormHandler(null, null); }
+            catch (Exception) { }
+        }
+        public static event EventHandler<EventArgs> CloseFormHandler;
+
+        void OnCloseForm(object sender, EventArgs args)
+        {
+            DialogResult = DialogResult.Cancel;
+            Close();
+        }
+
+
+        public string Title;
+        public string Message;
+        public Color BackgroundColor;
+        public Color TextColor;
+        public Font TextFont;
+        public string FontFamily;
+        public int FontSize;
+        public FontStyle FontStyle;
+
+
+        /// <summary>
+        /// Constructor to be used by the application
+        /// </summary>
+        /// <param name="title">Window title</param>
+        /// <param name="message">Displayed message</param>
+        public ModelessForm()
+        {
+            InitializeComponent();
+            ControlBox = false;
+
+            CloseFormHandler += delegate(object sender, EventArgs args)
+            {
+                if (InvokeRequired) { Invoke(new EventHandler<EventArgs>(OnCloseForm), sender, args); }
+                else OnCloseForm(sender, args);
+            };
+        }
+
+        private void ModelessForm_Load(object sender, EventArgs e)
+        {
+            if (Title != null) Text = Title;
+            if (Message != null) label1.Text = Message;
+            if (BackgroundColor != null) BackColor = BackgroundColor;
+            if (TextColor != null) ForeColor = TextColor;
+            if (FontFamily != null) label1.Font = new Font(FontFamily, FontSize, FontStyle);
+
+            float textWidth = Graphics.FromImage(new Bitmap(1, 1)).MeasureString(label1.Text, label1.Font).Width;
+            float textHeight = Graphics.FromImage(new Bitmap(1, 1)).MeasureString(label1.Text, label1.Font).Height;
+            Width = (int)textWidth + 120;		/// Form width calculated from the text width
+            Height += (int)textHeight;		    /// Form height calculated from the text height
+        }
+    }
+}

MonitoringDB/Forms/ModelessForm.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

MonitoringDB/Forms/ResultsConfigDlg.cs

@@ -0,0 +1,299 @@
+///
+/// Copyright (c) 2016 Sensus Metering Systems
+///
+using System;
+using System.Collections.Generic;
+using System.Windows.Forms;
+using log4net;
+using MonitoringDB.Entities;
+using MonitoringDB.Resources;
+
+namespace MonitoringDB.Forms
+{
+	public partial class ResultsConfigDlg : Form
+	{
+        /// <summary>
+        /// ListViewEx columns
+        /// </summary>
+        enum Column
+        {
+            Item,
+            Caption,
+            Format,
+            Precision,
+            Width,
+            Count,
+        }
+        Control[] editors;
+        
+
+        public IList<ItemSpec> AvailableItems;
+        public IList<ItemSpec> SelectedItems;
+
+
+		public bool Compound;			/// false = single meter items, true = combined meter items
+
+		public ResultsConfigDlg()
+		{
+			InitializeComponent();
+		}
+
+		void Localize()
+		{
+			Text = Strings.Configuration;
+			availableResultsLabel.Text = Strings.Available_results;
+			selectedResultsLabel.Text = Strings.Selected_results;
+			addButton.Text = Strings.Add;
+			removeButton.Text = Strings.Remove;
+			removeAllButton.Text = Strings.Remove_all;
+			okButton.Text = Strings.OkBtnText;
+			cancelButton.Text = Strings.CancelBtnText;
+            upButton.Text = Strings.UpBtnText;
+            downButton.Text = Strings.DownBtnText;
+		}
+
+		void ResultsConfig_Load(object sender, EventArgs e)
+		{
+			Localize();
+
+            /// Add columns to ListViewEx
+            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Item, Width = 120 });
+            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Caption });
+            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Format });
+            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Precision });
+            selectedResultsListViewEx.Columns.Add(new ColumnHeader { Text = Strings.Width });
+
+            editors = new Control[]
+                {
+                    null,
+                    new TextBox(),
+                    new TextBox(),
+                    new TextBox(),
+                    new TextBox(),
+                };
+            foreach (var edi in editors)
+            {
+                if (edi != null)
+                {
+                    edi.Visible = false;
+                    Controls.Add(edi);
+                }
+            }
+
+            selectedResultsListViewEx.SubItemClicked += new SubItemEventHandler(selectedResultsListViewEx_SubItemClicked);
+            selectedResultsListViewEx.SubItemEndEditing += new SubItemEndEditingEventHandler(selectedResultsListViewEx_SubItemEndEditing);
+			
+            RedrawAvailable();
+			RedrawSelected();
+		}
+
+        void selectedResultsListViewEx_SubItemClicked(object sender, SubItemEventArgs e)
+        {
+            if ((e.SubItem > 0) && (e.SubItem < (int)Column.Count))
+            {
+                selectedResultsListViewEx.StartEditing(editors[e.SubItem], e.Item, e.SubItem);
+            }
+        }
+
+        void selectedResultsListViewEx_SubItemEndEditing(object sender, SubItemEndEditingEventArgs e)
+        {
+            ListViewItem lvi = e.Item;
+            ItemSpec item = lvi.Tag as ItemSpec;
+
+            switch ((Column)e.SubItem)
+            {
+                case Column.Caption:    item.Caption = e.DisplayText;   return;
+                case Column.Format:     item.Format = e.DisplayText;    return;
+                case Column.Precision:  item.Precision = e.DisplayText; return;
+                                    
+                case Column.Width:
+                    {
+                        int width;
+                        if (Int32.TryParse(editors[e.SubItem].Text, out width) && width >= 0)
+                        {
+                            item.Width = width;
+                            return;     /// OK
+                        }
+                        break;          /// Error
+                    }
+                default:
+                    return;             /// OK
+            }
+
+            e.DisplayText = e.Item.SubItems[e.SubItem].Text;
+            e.Cancel = true;
+            return;
+        }
+
+		/// <summary>
+		/// Redraw selected items (right hand side)
+		/// </summary>
+		void RedrawAvailable()
+		{
+			availableResultsListBox.Items.Clear();
+            AvailableItems = new List<ItemSpec>();
+            foreach (var item in ItemSpec.AllItems)
+			{
+				AvailableItems.Add(item);
+				availableResultsListBox.Items.Add(item.Name);
+			}
+		}
+
+		/// <summary>
+		/// Redraw selected items (right hand side)
+		/// </summary>
+		void RedrawSelected()
+		{
+			selectedResultsListViewEx.Items.Clear();
+			foreach (var item in SelectedItems)
+			{
+                ListViewItem lvi = new ListViewItem(item.Name);                                     /// Item
+                lvi.Tag = item;
+                lvi.SubItems.Add(item.Caption);                                                     /// Header
+                lvi.SubItems.Add(item.Format);                                                      /// Format
+                lvi.SubItems.Add(item.Precision);                                                   /// Precision
+                lvi.SubItems.Add(item.Width.ToString());                                            /// Width
+
+				selectedResultsListViewEx.Items.Add(lvi);
+			}
+		}
+
+        void UpdateSelectedFromView()
+        {
+        }
+
+		void availableResultsListBox_DoubleClick(object sender, EventArgs e)
+		{
+			/// Double click works when just one item is selected
+			if (availableResultsListBox.SelectedIndices.Count == 1)
+			{
+				var oriItem = AvailableItems[availableResultsListBox.SelectedIndices[0]];
+                SelectedItems.Add(oriItem.Clone());
+				RedrawAvailable();
+				RedrawSelected();
+
+                /// Select the last item
+                selectedResultsListViewEx.Focus();
+                selectedResultsListViewEx.Items[SelectedItems.Count - 1].Selected = true;
+                selectedResultsListViewEx.Items[SelectedItems.Count - 1].EnsureVisible();
+            }
+		}
+
+		void addButton_Click(object sender, EventArgs e)
+		{
+			/// Append at the end, this code supports multiple selected items,
+			/// although ListBox control settings may limit the max.number of selected items to one.
+
+			for (int i = availableResultsListBox.SelectedIndices.Count - 1; i >= 0; i--)
+			{
+                var oriItem = AvailableItems[availableResultsListBox.SelectedIndices[i]];
+                SelectedItems.Add(oriItem.Clone());
+			}
+			RedrawAvailable();
+			RedrawSelected();
+
+            /// Select the last item
+            selectedResultsListViewEx.Focus();
+            selectedResultsListViewEx.Items[SelectedItems.Count - 1].Selected = true;
+            selectedResultsListViewEx.Items[SelectedItems.Count - 1].EnsureVisible();
+        }
+
+		private void selectedResultsListBox_DoubleClick(object sender, EventArgs e)
+		{
+			/// Double click works when just one item is selected
+
+			if (selectedResultsListViewEx.SelectedIndices.Count == 1)
+			{
+				SelectedItems.RemoveAt(selectedResultsListViewEx.SelectedIndices[0]);
+				RedrawAvailable();
+				RedrawSelected();
+			}
+		}
+
+		void removeButton_Click(object sender, EventArgs e)
+		{
+			/// Remove from the list (the last selected item first so that the indexes are not affected)
+
+			for (int i = selectedResultsListViewEx.SelectedIndices.Count - 1; i >= 0; i--)
+			{
+				SelectedItems.RemoveAt(selectedResultsListViewEx.SelectedIndices[i]);
+			}
+			RedrawAvailable();
+			RedrawSelected();
+		}
+
+		void removeAllButton_Click(object sender, EventArgs e)
+		{
+			/// Remove all items from 'Selected' list
+
+			SelectedItems.Clear();
+			RedrawAvailable();
+			RedrawSelected();
+		}
+
+		void okButton_Click(object sender, EventArgs e)
+		{
+            DialogResult = DialogResult.OK;
+			Close();
+		}
+
+        private void ResultsConfigDlg_KeyPress(object sender, KeyPressEventArgs e)
+        {
+            e.Handled = true;
+        }
+
+        private void upButton_Click(object sender, EventArgs e)
+        {
+            if (selectedResultsListViewEx.SelectedIndices.Count != 1) return;
+
+            int selIdx = selectedResultsListViewEx.SelectedIndices[0];
+            if (selIdx == 0)
+            {
+                /// Cannot move up
+                selectedResultsListViewEx.Focus();
+                selectedResultsListViewEx.Items[0].Selected = true;
+                return;
+            }
+
+            ItemSpec tmp = SelectedItems[selIdx - 1];
+            SelectedItems[selIdx - 1] = SelectedItems[selIdx];
+            SelectedItems[selIdx] = tmp;
+
+            RedrawSelected();
+
+            selectedResultsListViewEx.Focus();
+            selectedResultsListViewEx.Items[selIdx - 1].Selected = true;
+            selectedResultsListViewEx.Items[selIdx - 1].EnsureVisible();
+        }
+
+        private void downButton_Click(object sender, EventArgs e)
+        {
+            if (selectedResultsListViewEx.SelectedIndices.Count != 1) return;
+
+            int selIdx = selectedResultsListViewEx.SelectedIndices[0];
+            if (selIdx == SelectedItems.Count - 1)
+            {
+                /// Cannot move down
+                selectedResultsListViewEx.Focus();
+                selectedResultsListViewEx.Items[SelectedItems.Count - 1].Selected = true;
+                return;
+            }
+
+            ItemSpec tmp = SelectedItems[selIdx + 1];
+            SelectedItems[selIdx + 1] = SelectedItems[selIdx];
+            SelectedItems[selIdx] = tmp;
+            
+            RedrawSelected();
+
+            selectedResultsListViewEx.Focus();
+            selectedResultsListViewEx.Items[selIdx + 1].Selected = true;
+            selectedResultsListViewEx.Items[selIdx + 1].EnsureVisible();
+        }
+
+        private void cancelButton_Click(object sender, EventArgs e)
+        {
+            DialogResult = DialogResult.Cancel;
+            Close();
+        }
+	}
+}

MonitoringDB/Forms/ResultsConfigDlg.designer.cs

@@ -0,0 +1,201 @@
+///
+/// Copyright (c) 2016 Sensus Metering Systems
+///
+namespace MonitoringDB.Forms
+{
+	partial class ResultsConfigDlg
+	{
+		/// <summary>
+		/// Required designer variable.
+		/// </summary>
+		private System.ComponentModel.IContainer components = null;
+
+		/// <summary>
+		/// Clean up any resources being used.
+		/// </summary>
+		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing && (components != null))
+			{
+				components.Dispose();
+			}
+			base.Dispose(disposing);
+		}
+
+		#region Windows Form Designer generated code
+
+		/// <summary>
+		/// Required method for Designer support - do not modify
+		/// the contents of this method with the code editor.
+		/// </summary>
+		private void InitializeComponent()
+		{
+            this.okButton = new System.Windows.Forms.Button();
+            this.cancelButton = new System.Windows.Forms.Button();
+            this.availableResultsListBox = new System.Windows.Forms.ListBox();
+            this.availableResultsLabel = new System.Windows.Forms.Label();
+            this.selectedResultsLabel = new System.Windows.Forms.Label();
+            this.removeAllButton = new System.Windows.Forms.Button();
+            this.removeButton = new System.Windows.Forms.Button();
+            this.addButton = new System.Windows.Forms.Button();
+            this.selectedResultsListViewEx = new MonitoringDB.Forms.ListViewEx();
+            this.upButton = new System.Windows.Forms.Button();
+            this.downButton = new System.Windows.Forms.Button();
+            this.SuspendLayout();
+            // 
+            // okButton
+            // 
+            this.okButton.Location = new System.Drawing.Point(344, 401);
+            this.okButton.Name = "okButton";
+            this.okButton.Size = new System.Drawing.Size(104, 30);
+            this.okButton.TabIndex = 4;
+            this.okButton.Text = "OK";
+            this.okButton.UseVisualStyleBackColor = true;
+            this.okButton.Click += new System.EventHandler(this.okButton_Click);
+            // 
+            // cancelButton
+            // 
+            this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
+            this.cancelButton.Location = new System.Drawing.Point(465, 401);
+            this.cancelButton.Name = "cancelButton";
+            this.cancelButton.Size = new System.Drawing.Size(104, 30);
+            this.cancelButton.TabIndex = 5;
+            this.cancelButton.Text = "Cancel";
+            this.cancelButton.UseVisualStyleBackColor = true;
+            this.cancelButton.Click += new System.EventHandler(this.cancelButton_Click);
+            // 
+            // availableResultsListBox
+            // 
+            this.availableResultsListBox.FormattingEnabled = true;
+            this.availableResultsListBox.Location = new System.Drawing.Point(12, 31);
+            this.availableResultsListBox.Name = "availableResultsListBox";
+            this.availableResultsListBox.Size = new System.Drawing.Size(162, 355);
+            this.availableResultsListBox.TabIndex = 6;
+            this.availableResultsListBox.DoubleClick += new System.EventHandler(this.availableResultsListBox_DoubleClick);
+            // 
+            // availableResultsLabel
+            // 
+            this.availableResultsLabel.AutoSize = true;
+            this.availableResultsLabel.Location = new System.Drawing.Point(12, 9);
+            this.availableResultsLabel.Name = "availableResultsLabel";
+            this.availableResultsLabel.Size = new System.Drawing.Size(86, 13);
+            this.availableResultsLabel.TabIndex = 8;
+            this.availableResultsLabel.Text = "Available results:";
+            // 
+            // selectedResultsLabel
+            // 
+            this.selectedResultsLabel.AutoSize = true;
+            this.selectedResultsLabel.Location = new System.Drawing.Point(284, 9);
+            this.selectedResultsLabel.Name = "selectedResultsLabel";
+            this.selectedResultsLabel.Size = new System.Drawing.Size(85, 13);
+            this.selectedResultsLabel.TabIndex = 9;
+            this.selectedResultsLabel.Text = "Selected results:";
+            // 
+            // removeAllButton
+            // 
+            this.removeAllButton.Location = new System.Drawing.Point(184, 144);
+            this.removeAllButton.Name = "removeAllButton";
+            this.removeAllButton.Size = new System.Drawing.Size(94, 30);
+            this.removeAllButton.TabIndex = 46;
+            this.removeAllButton.Text = "<< R&emove all";
+            this.removeAllButton.UseVisualStyleBackColor = true;
+            this.removeAllButton.Click += new System.EventHandler(this.removeAllButton_Click);
+            // 
+            // removeButton
+            // 
+            this.removeButton.Location = new System.Drawing.Point(184, 109);
+            this.removeButton.Name = "removeButton";
+            this.removeButton.Size = new System.Drawing.Size(93, 30);
+            this.removeButton.TabIndex = 45;
+            this.removeButton.Text = "< &Remove";
+            this.removeButton.UseVisualStyleBackColor = true;
+            this.removeButton.Click += new System.EventHandler(this.removeButton_Click);
+            // 
+            // addButton
+            // 
+            this.addButton.Location = new System.Drawing.Point(184, 74);
+            this.addButton.Name = "addButton";
+            this.addButton.Size = new System.Drawing.Size(93, 30);
+            this.addButton.TabIndex = 44;
+            this.addButton.Text = "&Add >";
+            this.addButton.UseVisualStyleBackColor = true;
+            this.addButton.Click += new System.EventHandler(this.addButton_Click);
+            // 
+            // selectedResultsListViewEx
+            // 
+            this.selectedResultsListViewEx.AllowColumnReorder = true;
+            this.selectedResultsListViewEx.DoubleClickActivation = false;
+            this.selectedResultsListViewEx.FullRowSelect = true;
+            this.selectedResultsListViewEx.Location = new System.Drawing.Point(287, 31);
+            this.selectedResultsListViewEx.Name = "selectedResultsListViewEx";
+            this.selectedResultsListViewEx.Size = new System.Drawing.Size(594, 355);
+            this.selectedResultsListViewEx.TabIndex = 47;
+            this.selectedResultsListViewEx.UseCompatibleStateImageBehavior = false;
+            this.selectedResultsListViewEx.View = System.Windows.Forms.View.Details;
+            this.selectedResultsListViewEx.SubItemClicked += new MonitoringDB.Forms.SubItemEventHandler(this.selectedResultsListViewEx_SubItemClicked);
+            this.selectedResultsListViewEx.SubItemEndEditing += new MonitoringDB.Forms.SubItemEndEditingEventHandler(this.selectedResultsListViewEx_SubItemEndEditing);
+            // 
+            // upButton
+            // 
+            this.upButton.Location = new System.Drawing.Point(184, 236);
+            this.upButton.Name = "upButton";
+            this.upButton.Size = new System.Drawing.Size(93, 30);
+            this.upButton.TabIndex = 48;
+            this.upButton.Text = "Up";
+            this.upButton.UseVisualStyleBackColor = true;
+            this.upButton.Click += new System.EventHandler(this.upButton_Click);
+            // 
+            // downButton
+            // 
+            this.downButton.Location = new System.Drawing.Point(184, 272);
+            this.downButton.Name = "downButton";
+            this.downButton.Size = new System.Drawing.Size(93, 30);
+            this.downButton.TabIndex = 49;
+            this.downButton.Text = "Down";
+            this.downButton.UseVisualStyleBackColor = true;
+            this.downButton.Click += new System.EventHandler(this.downButton_Click);
+            // 
+            // ResultsConfigDlg
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(893, 445);
+            this.Controls.Add(this.downButton);
+            this.Controls.Add(this.upButton);
+            this.Controls.Add(this.selectedResultsListViewEx);
+            this.Controls.Add(this.removeAllButton);
+            this.Controls.Add(this.removeButton);
+            this.Controls.Add(this.addButton);
+            this.Controls.Add(this.selectedResultsLabel);
+            this.Controls.Add(this.availableResultsLabel);
+            this.Controls.Add(this.availableResultsListBox);
+            this.Controls.Add(this.cancelButton);
+            this.Controls.Add(this.okButton);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
+            this.Name = "ResultsConfigDlg";
+            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
+            this.Text = "ResultsConfig";
+            this.Load += new System.EventHandler(this.ResultsConfig_Load);
+            this.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.ResultsConfigDlg_KeyPress);
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+		}
+
+		#endregion
+
+		private System.Windows.Forms.Button okButton;
+		private System.Windows.Forms.Button cancelButton;
+        private System.Windows.Forms.ListBox availableResultsListBox;
+		private System.Windows.Forms.Label availableResultsLabel;
+		private System.Windows.Forms.Label selectedResultsLabel;
+		private System.Windows.Forms.Button removeAllButton;
+		private System.Windows.Forms.Button removeButton;
+		private System.Windows.Forms.Button addButton;
+        private ListViewEx selectedResultsListViewEx;
+        private System.Windows.Forms.Button upButton;
+        private System.Windows.Forms.Button downButton;
+	}
+}

MonitoringDB/Forms/ResultsConfigDlg.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

MonitoringDB/Forms/SettingsDlg.Designer.cs

@@ -0,0 +1,263 @@
+namespace MonitoringDB.Forms
+{
+	partial class SettingsDlg
+	{
+		/// <summary>
+		/// Required designer variable.
+		/// </summary>
+		private System.ComponentModel.IContainer components = null;
+
+		/// <summary>
+		/// Clean up any resources being used.
+		/// </summary>
+		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing && (components != null))
+			{
+				components.Dispose();
+			}
+			base.Dispose(disposing);
+		}
+
+		#region Windows Form Designer generated code
+
+		/// <summary>
+		/// Required method for Designer support - do not modify
+		/// the contents of this method with the code editor.
+		/// </summary>
+		private void InitializeComponent()
+		{
+            this.groupBox1 = new System.Windows.Forms.GroupBox();
+            this.connectionStringTextBox = new System.Windows.Forms.TextBox();
+            this.groupBox2 = new System.Windows.Forms.GroupBox();
+            this.radioButton2 = new System.Windows.Forms.RadioButton();
+            this.radioButton1 = new System.Windows.Forms.RadioButton();
+            this.groupBox3 = new System.Windows.Forms.GroupBox();
+            this.workplaceNameTextBox = new System.Windows.Forms.TextBox();
+            this.saveButton = new System.Windows.Forms.Button();
+            this.cancelButton = new System.Windows.Forms.Button();
+            this.groupBox4 = new System.Windows.Forms.GroupBox();
+            this.extraBatteryLifetimeTextBox = new System.Windows.Forms.TextBox();
+            this.oracleGroupBox = new System.Windows.Forms.GroupBox();
+            this.checkPcbIsInOracleCheckBox = new System.Windows.Forms.CheckBox();
+            this.oracleBatteryCheckBox = new System.Windows.Forms.CheckBox();
+            this.groupBox5 = new System.Windows.Forms.GroupBox();
+            this.usersDBConnStringTextBox = new System.Windows.Forms.TextBox();
+            this.groupBox1.SuspendLayout();
+            this.groupBox2.SuspendLayout();
+            this.groupBox3.SuspendLayout();
+            this.groupBox4.SuspendLayout();
+            this.oracleGroupBox.SuspendLayout();
+            this.groupBox5.SuspendLayout();
+            this.SuspendLayout();
+            // 
+            // groupBox1
+            // 
+            this.groupBox1.Controls.Add(this.connectionStringTextBox);
+            this.groupBox1.Location = new System.Drawing.Point(12, 69);
+            this.groupBox1.Name = "groupBox1";
+            this.groupBox1.Size = new System.Drawing.Size(622, 50);
+            this.groupBox1.TabIndex = 1;
+            this.groupBox1.TabStop = false;
+            this.groupBox1.Text = "Connection string pre záznamy z výroby";
+            // 
+            // connectionStringTextBox
+            // 
+            this.connectionStringTextBox.Location = new System.Drawing.Point(17, 18);
+            this.connectionStringTextBox.Name = "connectionStringTextBox";
+            this.connectionStringTextBox.Size = new System.Drawing.Size(586, 20);
+            this.connectionStringTextBox.TabIndex = 0;
+            // 
+            // groupBox2
+            // 
+            this.groupBox2.Controls.Add(this.radioButton2);
+            this.groupBox2.Controls.Add(this.radioButton1);
+            this.groupBox2.Location = new System.Drawing.Point(12, 250);
+            this.groupBox2.Name = "groupBox2";
+            this.groupBox2.Size = new System.Drawing.Size(268, 70);
+            this.groupBox2.TabIndex = 4;
+            this.groupBox2.TabStop = false;
+            this.groupBox2.Text = "Režim činnosti";
+            // 
+            // radioButton2
+            // 
+            this.radioButton2.AutoSize = true;
+            this.radioButton2.Location = new System.Drawing.Point(101, 41);
+            this.radioButton2.Name = "radioButton2";
+            this.radioButton2.Size = new System.Drawing.Size(58, 17);
+            this.radioButton2.TabIndex = 1;
+            this.radioButton2.TabStop = true;
+            this.radioButton2.Text = "Výroba";
+            this.radioButton2.UseVisualStyleBackColor = true;
+            // 
+            // radioButton1
+            // 
+            this.radioButton1.AutoSize = true;
+            this.radioButton1.Location = new System.Drawing.Point(101, 20);
+            this.radioButton1.Name = "radioButton1";
+            this.radioButton1.Size = new System.Drawing.Size(46, 17);
+            this.radioButton1.TabIndex = 0;
+            this.radioButton1.TabStop = true;
+            this.radioButton1.Text = "Test";
+            this.radioButton1.UseVisualStyleBackColor = true;
+            // 
+            // groupBox3
+            // 
+            this.groupBox3.Controls.Add(this.workplaceNameTextBox);
+            this.groupBox3.Location = new System.Drawing.Point(12, 12);
+            this.groupBox3.Name = "groupBox3";
+            this.groupBox3.Size = new System.Drawing.Size(622, 50);
+            this.groupBox3.TabIndex = 0;
+            this.groupBox3.TabStop = false;
+            this.groupBox3.Text = "Meno pracoviska";
+            // 
+            // workplaceNameTextBox
+            // 
+            this.workplaceNameTextBox.Location = new System.Drawing.Point(17, 18);
+            this.workplaceNameTextBox.Name = "workplaceNameTextBox";
+            this.workplaceNameTextBox.Size = new System.Drawing.Size(586, 20);
+            this.workplaceNameTextBox.TabIndex = 0;
+            // 
+            // saveButton
+            // 
+            this.saveButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.saveButton.Location = new System.Drawing.Point(348, 270);
+            this.saveButton.Name = "saveButton";
+            this.saveButton.Size = new System.Drawing.Size(104, 42);
+            this.saveButton.TabIndex = 6;
+            this.saveButton.Text = "Uložiť";
+            this.saveButton.UseVisualStyleBackColor = true;
+            this.saveButton.Click += new System.EventHandler(this.saveButton_Click);
+            // 
+            // cancelButton
+            // 
+            this.cancelButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.cancelButton.Location = new System.Drawing.Point(488, 270);
+            this.cancelButton.Name = "cancelButton";
+            this.cancelButton.Size = new System.Drawing.Size(104, 42);
+            this.cancelButton.TabIndex = 7;
+            this.cancelButton.Text = "Zrušiť";
+            this.cancelButton.UseVisualStyleBackColor = true;
+            this.cancelButton.Click += new System.EventHandler(this.cancelButton_Click);
+            // 
+            // groupBox4
+            // 
+            this.groupBox4.Controls.Add(this.extraBatteryLifetimeTextBox);
+            this.groupBox4.Location = new System.Drawing.Point(12, 182);
+            this.groupBox4.Name = "groupBox4";
+            this.groupBox4.Size = new System.Drawing.Size(268, 62);
+            this.groupBox4.TabIndex = 3;
+            this.groupBox4.TabStop = false;
+            this.groupBox4.Text = "Predĺženie životnosti baterky v mesiacoch";
+            // 
+            // extraBatteryLifetimeTextBox
+            // 
+            this.extraBatteryLifetimeTextBox.Location = new System.Drawing.Point(17, 25);
+            this.extraBatteryLifetimeTextBox.Name = "extraBatteryLifetimeTextBox";
+            this.extraBatteryLifetimeTextBox.Size = new System.Drawing.Size(230, 20);
+            this.extraBatteryLifetimeTextBox.TabIndex = 0;
+            // 
+            // oracleGroupBox
+            // 
+            this.oracleGroupBox.Controls.Add(this.checkPcbIsInOracleCheckBox);
+            this.oracleGroupBox.Controls.Add(this.oracleBatteryCheckBox);
+            this.oracleGroupBox.Location = new System.Drawing.Point(297, 182);
+            this.oracleGroupBox.Name = "oracleGroupBox";
+            this.oracleGroupBox.Size = new System.Drawing.Size(337, 74);
+            this.oracleGroupBox.TabIndex = 5;
+            this.oracleGroupBox.TabStop = false;
+            this.oracleGroupBox.Text = "Oracle";
+            this.oracleGroupBox.Visible = false;
+            // 
+            // checkPcbIsInOracleCheckBox
+            // 
+            this.checkPcbIsInOracleCheckBox.AutoSize = true;
+            this.checkPcbIsInOracleCheckBox.Location = new System.Drawing.Point(18, 45);
+            this.checkPcbIsInOracleCheckBox.Name = "checkPcbIsInOracleCheckBox";
+            this.checkPcbIsInOracleCheckBox.Size = new System.Drawing.Size(213, 17);
+            this.checkPcbIsInOracleCheckBox.TabIndex = 0;
+            this.checkPcbIsInOracleCheckBox.Text = "Skontrolovať či PCB už bola overovaná";
+            this.checkPcbIsInOracleCheckBox.UseVisualStyleBackColor = true;
+            // 
+            // oracleBatteryCheckBox
+            // 
+            this.oracleBatteryCheckBox.AutoSize = true;
+            this.oracleBatteryCheckBox.Location = new System.Drawing.Point(18, 19);
+            this.oracleBatteryCheckBox.Name = "oracleBatteryCheckBox";
+            this.oracleBatteryCheckBox.Size = new System.Drawing.Size(193, 17);
+            this.oracleBatteryCheckBox.TabIndex = 0;
+            this.oracleBatteryCheckBox.Text = "Uložiť informácie o batérii do Oracle";
+            this.oracleBatteryCheckBox.UseVisualStyleBackColor = true;
+            // 
+            // groupBox5
+            // 
+            this.groupBox5.Controls.Add(this.usersDBConnStringTextBox);
+            this.groupBox5.Location = new System.Drawing.Point(12, 125);
+            this.groupBox5.Name = "groupBox5";
+            this.groupBox5.Size = new System.Drawing.Size(622, 50);
+            this.groupBox5.TabIndex = 2;
+            this.groupBox5.TabStop = false;
+            this.groupBox5.Text = "Connection string pre centrálnu databázu používateľov";
+            // 
+            // usersDBConnStringTextBox
+            // 
+            this.usersDBConnStringTextBox.Location = new System.Drawing.Point(17, 18);
+            this.usersDBConnStringTextBox.Name = "usersDBConnStringTextBox";
+            this.usersDBConnStringTextBox.Size = new System.Drawing.Size(586, 20);
+            this.usersDBConnStringTextBox.TabIndex = 0;
+            // 
+            // SettingsDlg
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(648, 333);
+            this.Controls.Add(this.groupBox5);
+            this.Controls.Add(this.oracleGroupBox);
+            this.Controls.Add(this.groupBox4);
+            this.Controls.Add(this.cancelButton);
+            this.Controls.Add(this.saveButton);
+            this.Controls.Add(this.groupBox3);
+            this.Controls.Add(this.groupBox2);
+            this.Controls.Add(this.groupBox1);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
+            this.MaximizeBox = false;
+            this.Name = "SettingsDlg";
+            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
+            this.Text = "SettingsDlg";
+            this.groupBox1.ResumeLayout(false);
+            this.groupBox1.PerformLayout();
+            this.groupBox2.ResumeLayout(false);
+            this.groupBox2.PerformLayout();
+            this.groupBox3.ResumeLayout(false);
+            this.groupBox3.PerformLayout();
+            this.groupBox4.ResumeLayout(false);
+            this.groupBox4.PerformLayout();
+            this.oracleGroupBox.ResumeLayout(false);
+            this.oracleGroupBox.PerformLayout();
+            this.groupBox5.ResumeLayout(false);
+            this.groupBox5.PerformLayout();
+            this.ResumeLayout(false);
+
+		}
+
+		#endregion
+
+		private System.Windows.Forms.GroupBox groupBox1;
+		private System.Windows.Forms.TextBox connectionStringTextBox;
+		private System.Windows.Forms.GroupBox groupBox2;
+		private System.Windows.Forms.GroupBox groupBox3;
+		private System.Windows.Forms.TextBox workplaceNameTextBox;
+		private System.Windows.Forms.Button saveButton;
+		private System.Windows.Forms.Button cancelButton;
+		private System.Windows.Forms.RadioButton radioButton2;
+		private System.Windows.Forms.RadioButton radioButton1;
+        private System.Windows.Forms.GroupBox groupBox4;
+        private System.Windows.Forms.TextBox extraBatteryLifetimeTextBox;
+        private System.Windows.Forms.GroupBox oracleGroupBox;
+        private System.Windows.Forms.CheckBox oracleBatteryCheckBox;
+        private System.Windows.Forms.CheckBox checkPcbIsInOracleCheckBox;
+        private System.Windows.Forms.GroupBox groupBox5;
+        private System.Windows.Forms.TextBox usersDBConnStringTextBox;
+	}
+}

MonitoringDB/Forms/SettingsDlg.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Windows.Forms;
+
+namespace MonitoringDB.Forms
+{
+	public partial class SettingsDlg : Form
+	{
+		public string WorkplaceName
+		{
+			set { workplaceNameTextBox.Text = value; }
+			get { return workplaceNameTextBox.Text; }
+		}
+
+		public string ConnectionString
+		{
+			set { connectionStringTextBox.Text = value; }
+			get { return connectionStringTextBox.Text; }
+		}
+
+        public string UsersDBConnString
+        {
+            set { usersDBConnStringTextBox.Text = value; }
+            get { return usersDBConnStringTextBox.Text; }
+        }
+
+        public bool OracleBattery
+        {
+            set { oracleBatteryCheckBox.Checked = value; }
+            get { return oracleBatteryCheckBox.Checked; }
+        }
+
+        public bool CheckPcbIsInOracle
+        {
+            set { checkPcbIsInOracleCheckBox.Checked = value; }
+            get { return checkPcbIsInOracleCheckBox.Checked; }
+        }
+
+        public int ExtraBatterLifetime
+        {
+            get
+            {
+                int extraLifetime;
+                if (int.TryParse(extraBatteryLifetimeTextBox.Text, out extraLifetime) && extraLifetime >= 0) return extraLifetime;
+                return 0;
+            }
+        }
+
+        public MonitoringDB.Mode Mode
+		{
+			set
+			{
+                radioButton1.Checked = (value == MonitoringDB.Mode.Test);
+                radioButton2.Checked = (value == MonitoringDB.Mode.Production);
+			}
+			get
+			{
+                return radioButton1.Checked ? MonitoringDB.Mode.Test : MonitoringDB.Mode.Production;
+			}
+		}
+
+        /// <summary>
+        /// Basic configuration dialog
+        /// </summary>
+        /// <param name="isWorkplace">false = Konfiguracia pracovisk, true = Pracovisko</param>
+		public SettingsDlg(bool isWorkplace)
+		{
+			InitializeComponent();
+            if (isWorkplace)
+            {
+                oracleGroupBox.Visible = true;
+            }
+            extraBatteryLifetimeTextBox.Text = "0";
+		}
+
+		private void saveButton_Click(object sender, EventArgs e)
+		{
+			DialogResult = DialogResult.OK;
+			Close();
+		}
+
+		private void cancelButton_Click(object sender, EventArgs e)
+		{
+			DialogResult = DialogResult.Cancel;
+			Close();
+		}
+	}
+}

MonitoringDB/Forms/SettingsDlg.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

MonitoringDB/Forms/TrivialLoginDlg.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Windows.Forms;
+
+namespace MonitoringDB.Forms
+{
+	public partial class TrivialLoginDlg : Form
+	{
+        public LoginLevel LoginLevel;
+
+        public TrivialLoginDlg()
+		{
+			InitializeComponent();
+            LoginLevel = LoginLevel.None;
+		}
+
+		private void okButton_Click(object sender, EventArgs e)
+		{
+			if (passwordTextBox.Text.ToLower().Equals("barcode"))
+			{
+                LoginLevel = LoginLevel.Administrator;
+				DialogResult = DialogResult.OK;
+				Close();
+			}
+            else if (passwordTextBox.Text.ToLower().Equals("teamleader"))
+            {
+                LoginLevel = LoginLevel.TeamLeader;
+                DialogResult = DialogResult.OK;
+                Close();
+            }
+            else
+			{
+				DialogResult = DialogResult.Cancel;
+				Close();
+			}
+		}
+
+		private void cancelButton_Click(object sender, EventArgs e)
+		{
+			DialogResult = DialogResult.Cancel;
+			Close();
+		}
+	}
+}

MonitoringDB/Forms/TrivialLoginDlg.designer.cs

@@ -0,0 +1,105 @@
+namespace MonitoringDB.Forms
+{
+	partial class TrivialLoginDlg
+	{
+		/// <summary>
+		/// Required designer variable.
+		/// </summary>
+		private System.ComponentModel.IContainer components = null;
+
+		/// <summary>
+		/// Clean up any resources being used.
+		/// </summary>
+		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing && (components != null))
+			{
+				components.Dispose();
+			}
+			base.Dispose(disposing);
+		}
+
+		#region Windows Form Designer generated code
+
+		/// <summary>
+		/// Required method for Designer support - do not modify
+		/// the contents of this method with the code editor.
+		/// </summary>
+		private void InitializeComponent()
+		{
+			this.passwordGroupBox = new System.Windows.Forms.GroupBox();
+			this.passwordTextBox = new System.Windows.Forms.TextBox();
+			this.okButton = new System.Windows.Forms.Button();
+			this.cancelButton = new System.Windows.Forms.Button();
+			this.passwordGroupBox.SuspendLayout();
+			this.SuspendLayout();
+			// 
+			// passwordGroupBox
+			// 
+			this.passwordGroupBox.Controls.Add(this.passwordTextBox);
+			this.passwordGroupBox.Location = new System.Drawing.Point(12, 10);
+			this.passwordGroupBox.Name = "passwordGroupBox";
+			this.passwordGroupBox.Size = new System.Drawing.Size(200, 49);
+			this.passwordGroupBox.TabIndex = 0;
+			this.passwordGroupBox.TabStop = false;
+			this.passwordGroupBox.Text = "Heslo";
+			// 
+			// passwordTextBox
+			// 
+			this.passwordTextBox.Location = new System.Drawing.Point(51, 18);
+			this.passwordTextBox.Name = "passwordTextBox";
+			this.passwordTextBox.PasswordChar = '*';
+			this.passwordTextBox.Size = new System.Drawing.Size(100, 20);
+			this.passwordTextBox.TabIndex = 0;
+			// 
+			// okButton
+			// 
+			this.okButton.Location = new System.Drawing.Point(237, 18);
+			this.okButton.Name = "okButton";
+			this.okButton.Size = new System.Drawing.Size(75, 39);
+			this.okButton.TabIndex = 1;
+			this.okButton.Text = "OK";
+			this.okButton.UseVisualStyleBackColor = true;
+			this.okButton.Click += new System.EventHandler(this.okButton_Click);
+			// 
+			// cancelButton
+			// 
+			this.cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
+			this.cancelButton.Location = new System.Drawing.Point(330, 18);
+			this.cancelButton.Name = "cancelButton";
+			this.cancelButton.Size = new System.Drawing.Size(75, 39);
+			this.cancelButton.TabIndex = 2;
+			this.cancelButton.Text = "Cancel";
+			this.cancelButton.UseVisualStyleBackColor = true;
+			this.cancelButton.Click += new System.EventHandler(this.cancelButton_Click);
+			// 
+			// LoginDlg
+			// 
+			this.AcceptButton = this.okButton;
+			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+			this.CancelButton = this.cancelButton;
+			this.ClientSize = new System.Drawing.Size(426, 73);
+			this.Controls.Add(this.cancelButton);
+			this.Controls.Add(this.okButton);
+			this.Controls.Add(this.passwordGroupBox);
+			this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
+			this.MaximizeBox = false;
+			this.MinimizeBox = false;
+			this.Name = "LoginDlg";
+			this.Text = "LoginDlg";
+			this.passwordGroupBox.ResumeLayout(false);
+			this.passwordGroupBox.PerformLayout();
+			this.ResumeLayout(false);
+
+		}
+
+		#endregion
+
+		private System.Windows.Forms.GroupBox passwordGroupBox;
+		private System.Windows.Forms.TextBox passwordTextBox;
+		private System.Windows.Forms.Button okButton;
+		private System.Windows.Forms.Button cancelButton;
+	}
+}

MonitoringDB/Forms/TrivialLoginDlg.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

MonitoringDB/ItemSpec.cs

@@ -0,0 +1,306 @@
+///
+/// Copyright (c) 2016-2017 Sensus Slovensko a.s.
+///
+using System;
+using System.Collections.Generic;
+using MonitoringDB.Entities;
+using MonitoringDB.Resources;
+using NHibernate;
+using NHibernate.Criterion;
+
+namespace MonitoringDB
+{
+	public class ItemSpec
+	{
+        ///
+        /// Function delegate to pick a reference record and convert it to a string
+        /// 
+        public delegate string PrintDlgt(object x, string format, string precision, int width);
+
+        ///
+		/// Public fields
+		///
+        public readonly ItemSpecID Uid;         /// Unique Uid used to distinguish items
+        public readonly string Name;	        /// Name that can be localized to identify the item in a list
+        public readonly PrintDlgt PrintFn;      /// Function used to convert the result to a text
+                                                
+        public string Caption;	                /// User defined text printed in the column header
+        public string Format;                   /// Specifies the text generation
+        public string Precision;                /// Specifies the text generation
+        public int Width;                       /// Specifies the text generation
+
+        readonly ItemSpecCaps itemSpecCaps;
+
+        /// <summary> Public parameterless constructor </summary>
+        public ItemSpec()
+        {
+        }
+
+        /// <summary> Constructor to specify all items </summary>
+        public ItemSpec(ItemSpecID uid, string name, PrintDlgt printFn, ItemSpecCaps itemSpecCaps)
+		{
+            Uid = uid;
+            Name = name;
+            PrintFn = printFn;
+            this.itemSpecCaps = itemSpecCaps;
+            ///
+            Caption = name;
+            Format = "{0}";
+            Precision = string.Empty;
+            Width = 0;
+		}
+
+        /// <summary> Copy constructor </summary>
+        public ItemSpec Clone()
+        {
+            ItemSpec newItem = new ItemSpec(Uid, Name, PrintFn, itemSpecCaps);
+            newItem.Caption = Caption;
+            newItem.Format = Format;
+            newItem.Precision = Precision;
+            newItem.Width = Width;
+            return newItem;
+        }
+
+
+        /// <summary> Safe wrapper which replaces null-s by empty strings </summary>
+        public string Print(object x)
+        {
+            string str = PrintFn(x, Format, Precision, Width);
+            return (str == null) ? string.Empty : str;
+        }
+
+
+        /// <summary> Similar to Print(), in addition embeds text into "" </summary>
+        public string Export(object x)
+        {
+            string str = PrintFn(x, Format, Precision, Width);
+            if (str == null) str = string.Empty;
+
+            if (Uid == ItemSpecID.Barcode || Uid == ItemSpecID.PartBarcode || Uid == ItemSpecID.SerialNr || Uid == ItemSpecID.PurchaseOrder)
+            {
+                return string.Format("=\"{0}\"", str);
+            }
+            return str;
+        }
+
+
+		/// Static list of all available items
+		public static readonly IList<ItemSpec> AllItems;
+
+        ///
+		/// Static constructor that initializes the list of all items
+        ///
+		static ItemSpec()
+		{
+			AllItems = new List<ItemSpec>();
+
+            AllItems.Add(new ItemSpec(ItemSpecID.RefRecordID,   Strings.RefRecordID,    (x, f, p, w) => ((int)x).ToString(), ItemSpecCaps.ReferenceRecord));
+            
+            AllItems.Add(new ItemSpec(ItemSpecID.TimeStamp,     Strings.Time_stamp,     (x, f, p, w) => string.IsNullOrEmpty(f) ? ((DateTime)x).ToString() : string.Format(f, (DateTime)x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.Workstep,      Strings.Workstep,       (x, f, p, w) => string.IsNullOrEmpty(f) ? ((Workstep)x).Name : string.Format(f, ((Workstep)x).Name), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.Workplace,     Strings.Workplace,      (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.UserName,      Strings.User_name,      (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.Barcode,       Strings.Barcode,        (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.PartBarcode,   Strings.Part_barcode,   (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord | ItemSpecCaps.AssociatedRecord));
+            
+            AllItems.Add(new ItemSpec(ItemSpecID.TimeStamp2,    Strings.Time_stamp+"2", (x, f, p, w) => string.IsNullOrEmpty(f) ? ((DateTime)x).ToString() : string.Format(f, (DateTime)x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.Workstep2,     Strings.Workstep+"2",   (x, f, p, w) => string.IsNullOrEmpty(f) ? ((Workstep)x).Name : string.Format(f, ((Workstep)x).Name), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.Workplace2,    Strings.Workplace+"2",  (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.UserName2,     Strings.User_name+"2",  (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.Barcode2,      Strings.Barcode+"2",    (x, f, p, w) => string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord));
+            AllItems.Add(new ItemSpec(ItemSpecID.PartBarcode2,  Strings.Part_barcode+"2",(x, f, p, w)=> string.IsNullOrEmpty(f) ? (string)x : string.Format(f, x), ItemSpecCaps.ReferenceRecord | ItemSpecCaps.AssociatedRecord));
+            
+            AllItems.Add(new ItemSpec(ItemSpecID.SerialNr,      Strings.Serial_nr,      (x, f, p, w) => x as string, ItemSpecCaps.ReferenceRecord | ItemSpecCaps.OracleQuery));
+            AllItems.Add(new ItemSpec(ItemSpecID.PurchaseOrder, Strings.Purchase_order, (x, f, p, w) => x as string, ItemSpecCaps.ReferenceRecord | ItemSpecCaps.OracleQuery));
+			AllItems.Add(new ItemSpec(ItemSpecID.TestResult,	Strings.Test_result,	(x, f, p, w) => x as string, ItemSpecCaps.ReferenceRecord | ItemSpecCaps.OracleQuery));
+            AllItems.Add(new ItemSpec(ItemSpecID.MaxPruefindex, Strings.Max_pruefindex, (x, f, p, w) => x as string, ItemSpecCaps.ReferenceRecord | ItemSpecCaps.OracleQuery));
+            
+            AllItems.Add(new ItemSpec(ItemSpecID.Process,       Strings.Process,        (x, f, p, w) => string.IsNullOrEmpty(f) ? ((Process)x).Name : string.Format(f, ((Process)x).Name), ItemSpecCaps.ReferenceRecord));
+        }
+
+        public PropertyProjection GetProperty(ReferenceRecord refRecord, Record record)
+        {
+            switch (Uid)
+            {
+                case ItemSpecID.RefRecordID:    return Projections.Property(() => refRecord.Id);
+                
+                case ItemSpecID.TimeStamp:      return Projections.Property(() => refRecord.TimeStamp);
+                case ItemSpecID.Workstep:       return Projections.Property(() => refRecord.Workstep);
+                case ItemSpecID.Workplace:      return Projections.Property(() => refRecord.Workplace);
+                case ItemSpecID.UserName:       return Projections.Property(() => refRecord.UserName);
+                case ItemSpecID.Barcode:        return Projections.Property(() => refRecord.Code);
+                case ItemSpecID.PartBarcode:    return Projections.Property(() => record.Code);
+
+                case ItemSpecID.TimeStamp2:     return null;
+                case ItemSpecID.Workstep2:      return null;
+                case ItemSpecID.Workplace2:     return null;
+                case ItemSpecID.UserName2:      return null;
+                case ItemSpecID.Barcode2:       return null;
+                case ItemSpecID.PartBarcode2:   return null;
+
+                case ItemSpecID.SerialNr:       return null;
+                case ItemSpecID.PurchaseOrder:  return null;
+				case ItemSpecID.TestResult:     return null;
+                case ItemSpecID.MaxPruefindex:  return null;
+                
+                case ItemSpecID.Process:        return Projections.Property(() => refRecord.Process);
+                
+                default: return null;
+            }
+        }
+
+        public PropertyProjection GetProperty2(ReferenceRecord refRecord2, Record record2)
+        {
+            switch (Uid)
+            {
+                case ItemSpecID.RefRecordID:    return null;
+
+                case ItemSpecID.TimeStamp:      return null;
+                case ItemSpecID.Workstep:       return null;
+                case ItemSpecID.Workplace:      return null;
+                case ItemSpecID.UserName:       return null;
+                case ItemSpecID.Barcode:        return null;
+                case ItemSpecID.PartBarcode:    return null;
+
+                case ItemSpecID.TimeStamp2:     return Projections.Property(() => refRecord2.TimeStamp);
+                case ItemSpecID.Workstep2:      return Projections.Property(() => refRecord2.Workstep);
+                case ItemSpecID.Workplace2:     return Projections.Property(() => refRecord2.Workplace);
+                case ItemSpecID.UserName2:      return Projections.Property(() => refRecord2.UserName);
+                case ItemSpecID.Barcode2:       return Projections.Property(() => refRecord2.Code);
+                case ItemSpecID.PartBarcode2:   return Projections.Property(() => record2.Code);
+
+                case ItemSpecID.SerialNr:       return null;
+                case ItemSpecID.PurchaseOrder:  return null;
+                case ItemSpecID.TestResult:     return null;
+                case ItemSpecID.MaxPruefindex:  return null;
+
+                case ItemSpecID.Process:        return Projections.Property(() => refRecord2.Process);
+
+                default: return null;
+            }
+        }
+
+        public ItemSpecCaps GetCaps()
+        {
+            return itemSpecCaps;
+        }
+
+
+        public static ItemSpec GetItem(ItemSpecID id)
+        {
+            foreach (var item in AllItems)
+                if (item.Uid == id)
+                    return item.Clone();
+
+            return null;
+        }
+
+        public static ItemSpec GetItem(string uidName)
+        {
+            foreach (var item in AllItems)
+                if (item.Uid.ToString() == uidName)
+                    return item.Clone();
+
+            return null;
+        }
+
+
+        public static ProjectionList GetProjections(IList<ItemSpec> items, ReferenceRecord refRecord, Record record)
+        {
+            ProjectionList projections = Projections.ProjectionList();
+            foreach (var item in items)
+            {
+                PropertyProjection projection = item.GetProperty(refRecord, record);
+                if (projection != null)
+                    projections.Add(projection);
+            }
+
+            return projections;
+        }
+
+        public static IList<object[]> Expand(IList<object[]> data, IList<ItemSpec> items)
+        {
+            if (data.Count == 0) return data;
+
+            int iSize = data[0].Length;
+            int oSize = items.Count;
+            for (int i = 0; i < data.Count; i++)
+            {
+                object[] inArr = data[i];
+
+                object[] outArr = new object[oSize];
+                int srcIx = 0;
+                for (int dstIx = 0; dstIx < oSize; dstIx++)
+                {
+                    outArr[dstIx] = ((items[dstIx].GetCaps() & ItemSpecCaps.OracleQuery) == ItemSpecCaps.OracleQuery) ? string.Empty : inArr[srcIx++];
+                }
+
+                data[i] = outArr;
+            }
+
+            return data;
+        }
+
+
+        //static string GetPartCode(ReferenceRecord refRecord, string partName)
+        //{
+        //    if (refRecord != null && refRecord.Records != null)
+        //    {
+        //        foreach (var record in refRecord.Records)
+        //        {
+        //            if (record.Part.Name.Equals(partName))
+        //            {
+        //                return record.Code;
+        //            }
+        //        }
+        //    }
+
+        //    return string.Empty;
+        //}
+
+		public static string[] ToStrArray(IList<ItemSpec> items)
+		{
+			int count = (items != null) ? items.Count : 0;
+			string[] result = new string[count];
+            for (int i = 0; i < count; i++)
+            {
+                result[i] = string.Format("{0}~{1}~{2}~{3}~{4}",
+                                          items[i].Uid,
+                                          items[i].Caption,
+                                          items[i].Format,
+                                          items[i].Precision,
+                                          items[i].Width);
+            }
+			return result;
+		}
+
+		public static IList<ItemSpec> FromStrArray(string[] strArray)
+		{
+			IList<ItemSpec> result = new List<ItemSpec>();
+            if (strArray != null)
+			{
+				for (int i = 0; i < strArray.Length; i++)
+				{
+                    string[] field = strArray[i].Split(new char[] { '~' });
+                    try
+                    {
+                        ItemSpec item = GetItem(field[0]);
+                        item.Caption = field[1];
+                        item.Format = field[2];
+                        item.Precision = field[3];
+                        item.Width = int.Parse(field[4]);
+
+                        result.Add(item);
+                    }
+                    catch
+                    {
+                        ItemSpec item = GetItem(ItemSpecID.RefRecordID);
+                        item.Format = string.Format("Parse error: {0}", strArray[i]);
+                        result.Add(item);
+                    }
+                }
+			}
+			return result;
+		}
+    }
+}

MonitoringDB/Mappings/PartMap.cs

@@ -0,0 +1,23 @@
+using FluentNHibernate.Mapping;
+
+namespace MonitoringDB.Mappings
+{
+    class PartMap : ClassMap<Entities.Part>
+    {
+        public PartMap()
+        {
+            Id(x => x.Id);
+            Map(x => x.Name);
+            Map(x => x.OraDBType);
+            Map(x => x.Description);
+			Map(x => x.CodeType);
+            Map(x => x.CodeForm);
+			Map(x => x.CodeLocation);
+			Map(x => x.LifetimeManagement);
+			Map(x => x.StepNumber);
+
+			References(x => x.Process);
+			References(x => x.Workstep);
+		}
+    }
+}

MonitoringDB/Mappings/ProcessMap.cs

@@ -0,0 +1,25 @@
+using FluentNHibernate.Mapping;
+
+namespace MonitoringDB.Mappings
+{
+    class ProcessMap : ClassMap<Entities.Process>
+    {
+        public ProcessMap()
+        {
+            Id(x => x.Id);
+            Map(x => x.ItemNr);
+            Map(x => x.Name);
+			Map(x => x.Description);
+			Map(x => x.ReleaseStatus);
+			Map(x => x.TimeStamp);
+			Map(x => x.UserName);
+
+			HasMany(x => x.Parts)
+				.OrderBy("Name")
+				.Cascade.All();
+			HasMany(x => x.Worksteps)
+				.OrderBy("WorkstepNr")
+				.Cascade.All();
+		}
+    }
+}

MonitoringDB/Mappings/RecordMap.cs

@@ -0,0 +1,17 @@
+using FluentNHibernate.Mapping;
+
+namespace MonitoringDB.Mappings
+{
+    class RecordMap : ClassMap<Entities.Record>
+    {
+        public RecordMap()
+        {
+            Id(x => x.Id);
+			Map(x => x.Code);
+			Map(x => x.TimeStamp);
+
+			References(x => x.Part);
+			References(x => x.ReferenceRecord);
+		}
+    }
+}

MonitoringDB/Mappings/ReferenceRecordMap.cs

@@ -0,0 +1,22 @@
+using FluentNHibernate.Mapping;
+
+namespace MonitoringDB.Mappings
+{
+    class ReferenceRecordMap : ClassMap<Entities.ReferenceRecord>
+    {
+        public ReferenceRecordMap()
+        {
+            Id(x => x.Id);
+			Map(x => x.Code);
+			Map(x => x.TimeStamp);
+			Map(x => x.UserName);
+			Map(x => x.Workplace);
+			Map(x => x.Result);
+
+			References(x => x.Process);
+			References(x => x.Workstep);
+			HasMany(x => x.Records)
+				.Cascade.All();
+		}
+    }
+}

MonitoringDB/Mappings/WorkstepMap.cs

@@ -0,0 +1,23 @@
+using FluentNHibernate.Mapping;
+
+namespace MonitoringDB.Mappings
+{
+    class WorkstepMap : ClassMap<Entities.Workstep>
+    {
+        public WorkstepMap()
+        {
+            Id(x => x.Id);
+            Map(x => x.WorkstepNr);
+            Map(x => x.Name);
+			Map(x => x.Description);
+            Map(x => x.CheckPartNr);
+            Map(x => x.AllowRepairs);
+
+			References(x => x.Process);
+			References(x => x.ReferencePart);
+			HasMany(x => x.Parts)
+				.OrderBy("StepNumber")
+				.Cascade.All();
+		}
+    }
+}

MonitoringDB/MonitoringDB.csproj

@@ -0,0 +1,157 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>MonitoringDB</RootNamespace>
+    <AssemblyName>MonitoringDB</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="FluentNHibernate, Version=2.0.3.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\FluentNHibernate.2.0.3.0\lib\net40\FluentNHibernate.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Iesi.Collections, Version=4.0.0.0, Culture=neutral, PublicKeyToken=aa95f207798dfdb4, processorArchitecture=MSIL">
+      <HintPath>..\packages\Iesi.Collections.4.0.0.4000\lib\net40\Iesi.Collections.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="log4net">
+      <HintPath>..\packages\log4net.2.0.2\lib\net40-full\log4net.dll</HintPath>
+    </Reference>
+    <Reference Include="MySql.Data, Version=6.6.5.0, Culture=neutral, PublicKeyToken=c5687fc88969c44d, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\MySql.Data.6.6.5\lib\net40\MySql.Data.dll</HintPath>
+    </Reference>
+    <Reference Include="NHibernate, Version=4.0.0.4000, Culture=neutral, PublicKeyToken=aa95f207798dfdb4, processorArchitecture=MSIL">
+      <HintPath>..\packages\NHibernate.4.0.4.4000\lib\net40\NHibernate.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Forms\ListViewEx.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Include="Forms\TrivialLoginDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Forms\TrivialLoginDlg.designer.cs">
+      <DependentUpon>TrivialLoginDlg.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Forms\ModelessForm.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Forms\ModelessForm.designer.cs">
+      <DependentUpon>ModelessForm.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Forms\ResultsConfigDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Forms\ResultsConfigDlg.designer.cs">
+      <DependentUpon>ResultsConfigDlg.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Forms\SettingsDlg.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="Forms\SettingsDlg.designer.cs">
+      <DependentUpon>SettingsDlg.cs</DependentUpon>
+    </Compile>
+    <Compile Include="ItemSpec.cs" />
+    <Compile Include="QuitAppException.cs" />
+    <Compile Include="Resources\Strings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Strings.resx</DependentUpon>
+    </Compile>
+    <Compile Include="ScanVerificationInfo.cs" />
+    <Compile Include="SerializableDictionary.cs" />
+    <Compile Include="WMPart.cs" />
+    <Compile Include="Entities\Part.cs" />
+    <Compile Include="Entities\Process.cs" />
+    <Compile Include="Entities\Record.cs" />
+    <Compile Include="Entities\ReferenceRecord.cs" />
+    <Compile Include="Entities\Workstep.cs" />
+    <Compile Include="Enums.cs" />
+    <Compile Include="FluentNH.cs" />
+    <Compile Include="Mappings\PartMap.cs" />
+    <Compile Include="Mappings\ProcessMap.cs" />
+    <Compile Include="Mappings\RecordMap.cs" />
+    <Compile Include="Mappings\ReferenceRecordMap.cs" />
+    <Compile Include="Mappings\WorkstepMap.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Forms\ListViewEx.resx">
+      <DependentUpon>ListViewEx.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Forms\TrivialLoginDlg.resx">
+      <DependentUpon>TrivialLoginDlg.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Forms\ModelessForm.resx">
+      <DependentUpon>ModelessForm.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Forms\ResultsConfigDlg.resx">
+      <DependentUpon>ResultsConfigDlg.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Forms\SettingsDlg.resx">
+      <DependentUpon>SettingsDlg.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Resources\Strings.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Strings.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

MonitoringDB/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Common")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Common")]
+[assembly: AssemblyCopyright("Copyright ©  2015-2017")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("b182c80f-8670-40ab-ad26-6fb8de86552e")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.5.57.0")]
+[assembly: AssemblyFileVersion("1.5.57.0")]

MonitoringDB/Properties/Resources.Designer.cs

@@ -0,0 +1,63 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace MonitoringDB.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("MonitoringDB.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+    }
+}

MonitoringDB/Properties/Resources.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

MonitoringDB/QuitAppException.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace MonitoringDB
+{
+    public class QuitAppException : Exception
+    {
+        public QuitAppException(string message)
+            : base(message)
+        {
+        }
+    }
+}

MonitoringDB/Resources/Strings.Designer.cs

@@ -0,0 +1,333 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace MonitoringDB.Resources {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Strings {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Strings() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("MonitoringDB.Resources.Strings", typeof(Strings).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Add  &gt;.
+        /// </summary>
+        internal static string Add {
+            get {
+                return ResourceManager.GetString("Add", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Available results.
+        /// </summary>
+        internal static string Available_results {
+            get {
+                return ResourceManager.GetString("Available_results", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Barcode.
+        /// </summary>
+        internal static string Barcode {
+            get {
+                return ResourceManager.GetString("Barcode", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cancel.
+        /// </summary>
+        internal static string CancelBtnText {
+            get {
+                return ResourceManager.GetString("CancelBtnText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Caption.
+        /// </summary>
+        internal static string Caption {
+            get {
+                return ResourceManager.GetString("Caption", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Configuration.
+        /// </summary>
+        internal static string Configuration {
+            get {
+                return ResourceManager.GetString("Configuration", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Down.
+        /// </summary>
+        internal static string DownBtnText {
+            get {
+                return ResourceManager.GetString("DownBtnText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Format.
+        /// </summary>
+        internal static string Format {
+            get {
+                return ResourceManager.GetString("Format", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Item.
+        /// </summary>
+        internal static string Item {
+            get {
+                return ResourceManager.GetString("Item", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Max. prüfindex.
+        /// </summary>
+        internal static string Max_pruefindex {
+            get {
+                return ResourceManager.GetString("Max_pruefindex", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to OK.
+        /// </summary>
+        internal static string OkBtnText {
+            get {
+                return ResourceManager.GetString("OkBtnText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Another part barcode.
+        /// </summary>
+        internal static string Part_barcode {
+            get {
+                return ResourceManager.GetString("Part_barcode", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Precision.
+        /// </summary>
+        internal static string Precision {
+            get {
+                return ResourceManager.GetString("Precision", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Process.
+        /// </summary>
+        internal static string Process {
+            get {
+                return ResourceManager.GetString("Process", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Purchase order.
+        /// </summary>
+        internal static string Purchase_order {
+            get {
+                return ResourceManager.GetString("Purchase_order", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Record ID.
+        /// </summary>
+        internal static string RefRecordID {
+            get {
+                return ResourceManager.GetString("RefRecordID", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to &lt;  Remove.
+        /// </summary>
+        internal static string Remove {
+            get {
+                return ResourceManager.GetString("Remove", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Remove all.
+        /// </summary>
+        internal static string Remove_all {
+            get {
+                return ResourceManager.GetString("Remove_all", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Selected results.
+        /// </summary>
+        internal static string Selected_results {
+            get {
+                return ResourceManager.GetString("Selected_results", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Serial nr..
+        /// </summary>
+        internal static string Serial_nr {
+            get {
+                return ResourceManager.GetString("Serial_nr", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Serial_number.
+        /// </summary>
+        internal static string Serial_number {
+            get {
+                return ResourceManager.GetString("Serial_number", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Summary.
+        /// </summary>
+        internal static string Summary {
+            get {
+                return ResourceManager.GetString("Summary", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Test result.
+        /// </summary>
+        internal static string Test_result {
+            get {
+                return ResourceManager.GetString("Test_result", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Text.
+        /// </summary>
+        internal static string Text {
+            get {
+                return ResourceManager.GetString("Text", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Time stamp.
+        /// </summary>
+        internal static string Time_stamp {
+            get {
+                return ResourceManager.GetString("Time_stamp", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Up.
+        /// </summary>
+        internal static string UpBtnText {
+            get {
+                return ResourceManager.GetString("UpBtnText", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to User name.
+        /// </summary>
+        internal static string User_name {
+            get {
+                return ResourceManager.GetString("User_name", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Width.
+        /// </summary>
+        internal static string Width {
+            get {
+                return ResourceManager.GetString("Width", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Workplace.
+        /// </summary>
+        internal static string Workplace {
+            get {
+                return ResourceManager.GetString("Workplace", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Workstep.
+        /// </summary>
+        internal static string Workstep {
+            get {
+                return ResourceManager.GetString("Workstep", resourceCulture);
+            }
+        }
+    }
+}

MonitoringDB/Resources/Strings.resx

@@ -0,0 +1,210 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="Add" xml:space="preserve">
+    <value>Add  &gt;</value>
+  </data>
+  <data name="Available_results" xml:space="preserve">
+    <value>Available results</value>
+  </data>
+  <data name="Barcode" xml:space="preserve">
+    <value>Barcode</value>
+  </data>
+  <data name="CancelBtnText" xml:space="preserve">
+    <value>Cancel</value>
+  </data>
+  <data name="Caption" xml:space="preserve">
+    <value>Caption</value>
+  </data>
+  <data name="Configuration" xml:space="preserve">
+    <value>Configuration</value>
+  </data>
+  <data name="DownBtnText" xml:space="preserve">
+    <value>Down</value>
+  </data>
+  <data name="Format" xml:space="preserve">
+    <value>Format</value>
+  </data>
+  <data name="Item" xml:space="preserve">
+    <value>Item</value>
+  </data>
+  <data name="Max_pruefindex" xml:space="preserve">
+    <value>Max. prüfindex</value>
+  </data>
+  <data name="OkBtnText" xml:space="preserve">
+    <value>OK</value>
+  </data>
+  <data name="Part_barcode" xml:space="preserve">
+    <value>Another part barcode</value>
+  </data>
+  <data name="Precision" xml:space="preserve">
+    <value>Precision</value>
+  </data>
+  <data name="Process" xml:space="preserve">
+    <value>Process</value>
+  </data>
+  <data name="Purchase_order" xml:space="preserve">
+    <value>Purchase order</value>
+  </data>
+  <data name="RefRecordID" xml:space="preserve">
+    <value>Record ID</value>
+  </data>
+  <data name="Remove" xml:space="preserve">
+    <value>&lt;  Remove</value>
+  </data>
+  <data name="Remove_all" xml:space="preserve">
+    <value>Remove all</value>
+  </data>
+  <data name="Selected_results" xml:space="preserve">
+    <value>Selected results</value>
+  </data>
+  <data name="Serial_nr" xml:space="preserve">
+    <value>Serial nr.</value>
+  </data>
+  <data name="Serial_number" xml:space="preserve">
+    <value>Serial_number</value>
+  </data>
+  <data name="Summary" xml:space="preserve">
+    <value>Summary</value>
+  </data>
+  <data name="Test_result" xml:space="preserve">
+    <value>Test result</value>
+  </data>
+  <data name="Text" xml:space="preserve">
+    <value>Text</value>
+  </data>
+  <data name="Time_stamp" xml:space="preserve">
+    <value>Time stamp</value>
+  </data>
+  <data name="UpBtnText" xml:space="preserve">
+    <value>Up</value>
+  </data>
+  <data name="User_name" xml:space="preserve">
+    <value>User name</value>
+  </data>
+  <data name="Width" xml:space="preserve">
+    <value>Width</value>
+  </data>
+  <data name="Workplace" xml:space="preserve">
+    <value>Workplace</value>
+  </data>
+  <data name="Workstep" xml:space="preserve">
+    <value>Workstep</value>
+  </data>
+</root>

MonitoringDB/ScanVerificationInfo.cs

@@ -0,0 +1,25 @@
+using MonitoringDB.Entities;
+
+namespace MonitoringDB
+{
+    public class ScanVerificationInfo
+    {
+        public Workstep Workstep;           /// null = verification is disabled
+        public bool VerifyReferencePart;    /// true = verify current workstep ReferencePart with another part
+                                            /// false = verify Part from current workstep parts with ReferencePart of another Workstep
+        public Part Part;                   /// Applicable when VerifyReferencePart == false
+
+        /// Constructor that disables verification
+        public ScanVerificationInfo()
+        {
+            Workstep = null;
+        }
+
+        public ScanVerificationInfo(Workstep workstep, bool verifyReferencePart, Part part)
+        {
+            Workstep = workstep;
+            VerifyReferencePart = verifyReferencePart;
+            Part = part;
+        }
+    }
+}

MonitoringDB/SerializableDictionary.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Xml.Serialization;
+
+namespace MonitoringDB
+{
+    [XmlRoot("dictionary")]
+    public class SerializableDictionary<TKey, TValue>
+        : Dictionary<TKey, TValue>, IXmlSerializable
+    {
+        public System.Xml.Schema.XmlSchema GetSchema()
+        {
+            return null;
+        }
+
+        public void ReadXml(System.Xml.XmlReader reader)
+        {
+            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
+            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
+
+            bool wasEmpty = reader.IsEmptyElement;
+            reader.Read();
+
+            if (wasEmpty)
+                return;
+
+            while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
+            {
+                reader.ReadStartElement("item");
+
+                reader.ReadStartElement("key");
+                TKey key = (TKey)keySerializer.Deserialize(reader);
+                reader.ReadEndElement();
+
+                reader.ReadStartElement("value");
+                TValue value = (TValue)valueSerializer.Deserialize(reader);
+                reader.ReadEndElement();
+
+                this.Add(key, value);
+
+                reader.ReadEndElement();
+                reader.MoveToContent();
+            }
+            reader.ReadEndElement();
+        }
+
+        public void WriteXml(System.Xml.XmlWriter writer)
+        {
+            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
+            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
+
+            foreach (TKey key in this.Keys)
+            {
+                writer.WriteStartElement("item");
+
+                writer.WriteStartElement("key");
+                keySerializer.Serialize(writer, key);
+                writer.WriteEndElement();
+
+                writer.WriteStartElement("value");
+                TValue value = this[key];
+                valueSerializer.Serialize(writer, value);
+                writer.WriteEndElement();
+
+                writer.WriteEndElement();
+            }
+        }
+    }
+}

MonitoringDB/WMPart.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using MonitoringDB.Entities;
+
+namespace MonitoringDB
+{
+	public class WMPart
+	{
+		public string Name;
+        public Process Process;
+        public string OraDBType;
+        public string Description;
+		public string Code;
+		public DateTime TimeStamp;
+		public CodeType CodeType;
+		public CodeForm CodeForm;
+		public CodeLocation CodeLocation;
+		public string UserName;
+		public string Workplace;
+
+		public WMPart(ReferenceRecord rr)
+		{
+			Name = rr.Workstep.ReferencePart.Name;
+            Process = rr.Process;
+            OraDBType = rr.Workstep.ReferencePart.OraDBType;
+            Description = rr.Workstep.ReferencePart.Description;
+			Code = rr.Code;
+			TimeStamp = rr.TimeStamp;
+			CodeType = rr.Workstep.ReferencePart.CodeType;
+			CodeForm = rr.Workstep.ReferencePart.CodeForm;
+			CodeLocation = rr.Workstep.ReferencePart.CodeLocation;
+			UserName = rr.UserName;
+			Workplace = rr.Workplace;
+		}
+
+		public WMPart(Record r)
+		{
+			Name = r.Part.Name;
+            Process = r.Part.Process;
+            OraDBType = r.Part.OraDBType;
+			Description = r.Part.Description;
+			Code = r.Code;
+			TimeStamp = r.TimeStamp;
+			CodeType = r.Part.CodeType;
+			CodeForm = r.Part.CodeForm;
+			CodeLocation = r.Part.CodeLocation;
+			UserName = r.ReferenceRecord.UserName;
+			Workplace = r.ReferenceRecord.Workplace;
+		}
+	}
+}

MonitoringDB/app.config

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <runtime>
+    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
+      <dependentAssembly>
+        <assemblyIdentity name="NHibernate" publicKeyToken="aa95f207798dfdb4" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.0.4000" newVersion="4.0.0.4000" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Iesi.Collections" publicKeyToken="aa95f207798dfdb4" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.0.0.0" newVersion="4.0.0.0" />
+      </dependentAssembly>
+    </assemblyBinding>
+  </runtime>
+</configuration>

MonitoringDB/packages.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="FluentNHibernate" version="2.0.3.0" targetFramework="net40" />
+  <package id="Iesi.Collections" version="4.0.0.4000" targetFramework="net40" />
+  <package id="NHibernate" version="4.0.4.4000" targetFramework="net40" />
+</packages>

TestBenchFramework.sln

@@ -3,6 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual Studio 2010
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TBF", "TestBenchFramework\TBF.csproj", "{8648FD92-CDA1-4C3A-B5F9-FE547CE1FA48}"
 	ProjectSection(ProjectDependencies) = postProject
+		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF} = {EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}
 		{0C0A1F4D-1363-4544-A7C5-196C76D26CCA} = {0C0A1F4D-1363-4544-A7C5-196C76D26CCA}
 	EndProjectSection
 EndProject
@@ -35,6 +36,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UserManagement", "UserManag
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphLib", "GraphLib\GraphLib.csproj", "{0C0A1F4D-1363-4544-A7C5-196C76D26CCA}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MonitoringDB", "MonitoringDB\MonitoringDB.csproj", "{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -141,6 +144,16 @@ Global
 		{0C0A1F4D-1363-4544-A7C5-196C76D26CCA}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{0C0A1F4D-1363-4544-A7C5-196C76D26CCA}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{0C0A1F4D-1363-4544-A7C5-196C76D26CCA}.Release|x86.ActiveCfg = Release|Any CPU
+		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{EFEC8A31-3022-4DA7-A8F6-16D30A94C3FF}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

clean.bat

@@ -6,6 +6,8 @@ rmdir /s /q Dirichlet.Numerics\bin
 rmdir /s /q Dirichlet.Numerics\obj
 rmdir /s /q GraphLib\bin
 rmdir /s /q GraphLib\obj
+rmdir /s /q MonitoringDB\bin
+rmdir /s /q MonitoringDB\obj
 rmdir /s /q Results\bin
 rmdir /s /q Results\obj
 rmdir /s /q ResultsBrowser\bin